From 9e614e44461f93bcb386e08fd697921a9fced574 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 08:31:35 +0530
Subject: [PATCH 1/9] test(contracts): add a source-file size budget that can
 only shrink

Large single files make coding-agent sessions expensive: agents cannot read
them whole, so they search them repeatedly and every result stays in context.
New source files stay under 80 KB; existing large files carry a ceiling about
5% above their current size that may only be lowered or removed.

Adds the October session-cost survey and refactor plan.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 .../plans/2026-11-06-session-cost-refactor.md | 186 ++++++++++++++++++
 tests/contracts/test_source_size_budget.py    |  93 +++++++++
 2 files changed, 279 insertions(+)
 create mode 100644 specs/plans/2026-11-06-session-cost-refactor.md
 create mode 100644 tests/contracts/test_source_size_budget.py

diff --git a/specs/plans/2026-11-06-session-cost-refactor.md b/specs/plans/2026-11-06-session-cost-refactor.md
new file mode 100644
index 00000000..84f800be
--- /dev/null
+++ b/specs/plans/2026-11-06-session-cost-refactor.md
@@ -0,0 +1,186 @@
+# Session-cost refactor: analysis and plan
+
+Historical point-in-time analysis (2026-11-06). Plan only; nothing implemented.
+
+## Method
+
+- Token Meter MCP `stats` grouped by `session_id`, 2026-10-01 → 2026-10-31,
+  sorted by `cost_usd`, top 100. Dollar figures below come from Token Meter.
+- To attribute those sessions to projects and tools, a local script read the
+  matching Claude Code transcripts for **counts and sizes only**. No content
+  was printed. Transcript-derived figures double-count history copied into
+  forked or resumed sessions, so treat them as **shares**, not dollars.
+- "Carry" = tool-result characters × the turns that result stayed in context.
+  It approximates how much each result was paid for again as cache reads.
+
+## Findings
+
+### Where the money went
+
+| Fact | Value |
+|---|---|
+| October spend, all sessions | $1,194 |
+| Top 100 sessions | $1,010 (85%) |
+| …of which token-meter repo sessions | 68 sessions, **$751** |
+| Opus 5.5 share of the month | $1,050 |
+| Top-100 tokens: cache read / cache write / output / uncached input | 1.25 B / 122 M / 6.4 M / 0.8 M |
+| Estimated cost split (Opus rates) | cache writes ≈ 45–50%, cache reads ≈ 35–40%, output ≈ 10% |
+
+Output is a small share. Almost all the cost is context: re-reading a large
+context every turn, and rebuilding it when the cache expires.
+
+### Context size is the multiplier
+
+| Context per model turn | p50 | p90 | max |
+|---|---|---|---|
+| Main sessions | ~300 k | ~705 k | ~998 k |
+| Subagents | ~54 k | ~226 k | ~688 k |
+
+- Starting context before any work: main ≈ 60 k tokens, subagent ≈ 15 k.
+  `specs/AGENTS.md` (21.7 KB, ≈ 5.4 k tokens) is part of that in every main
+  session and every subagent.
+- About 620 cache rebuilds above 50 k tokens happened in main sessions. 469 of
+  them came after waiting on a user reply (median gap 19 min). Each rebuilt
+  about 400 k tokens. The codebase can't shorten the user's reply time, but a
+  smaller working context makes every rebuild cheaper.
+
+### What fills the context: navigating huge files
+
+Share of carried tool-result volume across the 68 token-meter sessions (560
+transcripts, 492 of them subagents):
+
+| Source | Calls | Carry share |
+|---|---|---|
+| `grep`/`rg` via Bash | 8,459 | **31%** |
+| `sed -n` range reads | 1,569 | **15%** |
+| Reading `/tmp` scratch/persisted outputs | 995 | 8.5% |
+| Ad-hoc `python3` probes | 2,091 | 8.4% |
+| `git diff` | 1,877 | 3.6% |
+| Targeted `unittest` runs | 2,055 | 3.0% |
+| `Read` of `work_insights.py` | 133 | 3.0% |
+
+The grep/sed traffic is aimed at a few files:
+
+| File | Size | grep/sed calls | Output |
+|---|---|---|---|
+| `page.html` | 1.26 MB (≈ 315 k tokens, 13.2 k lines, 755 JS functions, 791 KB script, 333 KB CSS) | 4,350 | 9.5 MB |
+| `token_meter/app.py` | 631 KB (15 k lines, 643 top-level defs) | 2,472 | 5.5 MB |
+| `services/work_insights.py` | 106 KB | 1,063 | 2.2 MB |
+| `tests/test_meter.py` | 1.43 MB (26 k lines, 1,034 tests, 97 classes) | 674 | 1.5 MB |
+
+`page.html` is larger than the context window, so agents can't read it whole.
+They search it over and over, and every search result then stays in context.
+`app.py` and `test_meter.py` work the same way. The monolithic files are the
+main codebase-side cost driver.
+
+### Workflow signals (not code, but they multiply cost)
+
+- Subagent turns were about 98% Opus (20,148 Opus vs 404 Sonnet), even though
+  the tier policy sends the tester and extra reviewers to `sonnet`. This matches
+  the known alias fallback on this machine. The `*-local` agents fix it only
+  if they are actually spawned.
+- 1,101 full-suite invocations across these sessions, against a policy of at
+  most once per head.
+
+## Plan (ranked by expected impact)
+
+Success metric: median main-session context per turn drops from ~300 k toward
+≤ 150 k, and grep/sed calls per session halve. Measure both with Token Meter
+on the next ~20 comparable sessions after each phase. Cost scales roughly
+with context × turns, so halving resting context should cut token-meter
+session cost by an estimated 30–45%. That number is a hypothesis to confirm
+in Phase 1, not a promise.
+
+### Phase 0: guardrails first (small)
+
+1. Add a source-size ratchet to `tests/contracts/test_architecture_guards.py`:
+   a per-file byte baseline that can only shrink, plus a ceiling for new files
+   (e.g. 80 KB). This stops the monolith from regrowing during the split.
+2. Save the survey script as a local tool so each phase reports the same
+   numbers. Keep it under ignored local state, or make it content-free and
+   commit it under `scripts/`.
+
+### Phase 1: split `page.html` (largest win)
+
+- Source layout: `dashboard/index.html` (shell),
+  `dashboard/styles/{tokens,components,<view>}.css`, and
+  `dashboard/js/{core,router,charts,<view>}.js`, one per top-level view
+  (Sessions, Spend, Models, Subagents, Efficiency, Work, Git, Learn, Tools,
+  Settings). Target ≤ 60 KB per file, so an agent can read the one view it is
+  working on in a single call.
+- The server assembles the page in memory at startup with stdlib string
+  concatenation, in a fixed order. No build tool, no hosted assets, and the
+  page stays local-only and dependency-free. `/health` keeps validating the
+  assembled page.
+- Do the move mechanically (a one-off script that cuts on existing section
+  markers) and verify byte-identical assembled output against today's
+  `page.html` before any cleanup. Don't have an agent hand-edit 1.26 MB.
+- Update the consumers together: `runtime-manifest.txt` and parity checks,
+  `scripts/install`, `scripts/install-windows.ps1`, the Linux installer, the
+  design-system contract, `scripts/style-snapshot.js`, the embedded-JS parse
+  command in `specs/AGENTS.md`, and the 69 `page.html` string assertions in
+  `tests/test_meter.py`. Route these through one `assembled_page()` test
+  helper.
+- Risk: high-surface (installer, runtime parity, design contract). This needs
+  the high-risk route: one tester and two reviewers.
+
+### Phase 2: split `tests/test_meter.py`
+
+- Move its 97 classes into `tests/<surface>/test_*.py`, mirroring the source
+  modules (dashboard views, server/HTTP, installer, menubar source, parsers),
+  with shared fixtures in `tests/support/`.
+- Benefit: agents find tests by file name instead of grepping 1.4 MB. Targeted
+  runs (`unittest tests.dashboard.test_spend`) replace full-file runs. Keep
+  `scripts/run-tests` and discovery unchanged.
+- Coverage-preserving: assert the same test count before and after the move.
+
+### Phase 3: split `token_meter/app.py`
+
+- Pull out cohesive modules along existing seams: HTTP routing/handlers,
+  settings and atomic writes, budgets and caps, the menubar payload, discovery
+  and rebuild orchestration, and update/lifecycle. `app.py` keeps composition
+  plus compatibility re-exports (the `meter.py` facade contract is
+  unchanged).
+- Do the same for `services/work_insights.py` (queue/pacing vs Ollama client
+  vs label ledger) and `domain/work.py`, which together draw about 3.7 MB of
+  grep/sed/Read traffic.
+- Update `specs/ARCHITECTURE.md`'s component map in the same change.
+
+### Phase 4: cheaper agent defaults in the repo
+
+- Trim `specs/AGENTS.md` toward ~8 KB. Keep the invariants (privacy, pricing,
+  dashboard order, design rules) and move the long procedural flows
+  (reporter-end-to-end, Slack/GitHub contracts, PR-management replies) into
+  the existing on-demand skills under `.agents/skills/`. Estimated effect:
+  about 3 k fewer tokens on every turn of every main session and subagent,
+  roughly 5–7% of cache reads.
+- Add bounded helpers that replace the ad-hoc probes, which account for about
+  17% of carry (`python3` scratch and `/tmp` reads):
+  - `scripts/show <file> <symbol>` prints one function or CSS block;
+  - `scripts/check-page` runs JS parse + design contract with a terse summary;
+  - an endpoint probe that summarizes `/health`/`/menubar` instead of dumping
+    JSON.
+- Make terse output the default for `scripts/run-tests`: failures plus a
+  one-line summary, with `-v` opt-in. Many of these output-size controls may
+  already exist.
+- Workflow: confirm subagents spawn the `*-local` tiers, and enforce one full
+  suite per head. These need no code change, but on today's evidence the
+  savings are comparable to a code phase.
+
+### Order and checkpoints
+
+Phase 0 → 1 → measure → 2 → 3 → 4. Phase 4's AGENTS.md trim and helpers are
+independent and could run in parallel with Phase 1. Stop and reassess after
+Phase 1: if context per turn and grep counts don't move meaningfully, the
+cost is behavioral (session length, idle rebuilds) rather than structural,
+and Phases 2–3 should shrink.
+
+## Not verified
+
+- Exact Opus 5.5 unit prices weren't checked against the repo's pricing
+  table. The cost split is an estimate from token mix.
+- Transcript shares include forked-session history duplication.
+- The 22 top-100 sessions outside this repo were not analyzed for tools.
+- Some sessions show a covered execution count of exactly 180. That could be
+  a bound in Token Meter's per-session accounting, worth a separate check
+  before relying on per-session totals.
diff --git a/tests/contracts/test_source_size_budget.py b/tests/contracts/test_source_size_budget.py
new file mode 100644
index 00000000..dfbc99a4
--- /dev/null
+++ b/tests/contracts/test_source_size_budget.py
@@ -0,0 +1,93 @@
+"""Source-file size budget.
+
+Large single files are expensive for coding agents: they cannot be read whole,
+so agents search them repeatedly and every result stays in context. New source
+files stay under ``NEW_FILE_LIMIT``. Files that are already larger carry a
+ceiling in ``LEGACY_CEILINGS``. Lower a ceiling, or delete the entry once a file is
+split below the limit. Never raise a ceiling or add a new entry.
+"""
+
+import subprocess
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+NEW_FILE_LIMIT = 80_000
+SOURCE_SUFFIXES = {".py", ".html", ".js", ".css", ".swift", ".ps1", ".sh"}
+EXEMPT_PREFIXES = ("assets/vendor/", "tests/fixtures/")
+
+# Ceilings are about 5% above each file's size when the budget was introduced,
+# so normal maintenance still fits. This dict may only shrink.
+LEGACY_CEILINGS = {
+    "tests/test_meter.py": 1_500_000,
+    "page.html": 1_325_000,
+    "token_meter/app.py": 663_000,
+    "tests/test_work_insights.py": 236_000,
+    "menubar/TokenMeterMenuBar.swift": 148_000,
+    "tests/test_git_delivery.py": 141_000,
+    "docs/talk/index.html": 123_000,
+    "token_meter/services/work_insights.py": 111_000,
+    "token_meter/runtimes/claude.py": 110_000,
+    "token_meter/domain/aggregates.py": 104_000,
+    "token_meter/runtimes/codex.py": 97_000,
+    "token_meter/runtimes/opencode.py": 96_000,
+    "token_meter/domain/work.py": 85_000,
+}
+
+
+def tracked_sources():
+    try:
+        listed = subprocess.run(
+            ["git", "ls-files", "-z"],
+            cwd=ROOT,
+            check=True,
+            capture_output=True,
+        ).stdout.decode("utf-8").split("\0")
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    paths = []
+    for name in listed:
+        if not name or name.startswith(EXEMPT_PREFIXES):
+            continue
+        path = ROOT / name
+        is_script = name.startswith("scripts/") and "." not in Path(name).name
+        if (path.suffix in SOURCE_SUFFIXES or is_script) and path.is_file():
+            paths.append(name)
+    return paths
+
+
+class SourceSizeBudgetTests(unittest.TestCase):
+    def setUp(self):
+        self.sources = tracked_sources()
+        if self.sources is None:
+            self.skipTest("git ls-files is unavailable")
+
+    def test_source_files_stay_within_their_size_budget(self):
+        over = []
+        for name in self.sources:
+            size = (ROOT / name).stat().st_size
+            limit = LEGACY_CEILINGS.get(name, NEW_FILE_LIMIT)
+            if size > limit:
+                over.append(f"{name}: {size} bytes > {limit}")
+        self.assertEqual(
+            over,
+            [],
+            "Split the file instead of raising its budget; see specs/ARCHITECTURE.md.",
+        )
+
+    def test_legacy_ceilings_name_only_files_that_still_need_them(self):
+        tracked = set(self.sources)
+        stale = []
+        for name, ceiling in LEGACY_CEILINGS.items():
+            if name not in tracked:
+                stale.append(f"{name}: no longer tracked; delete its ceiling")
+            elif (ROOT / name).stat().st_size <= NEW_FILE_LIMIT:
+                stale.append(f"{name}: now within the default limit; delete its ceiling")
+            elif ceiling <= NEW_FILE_LIMIT:
+                stale.append(f"{name}: ceiling is not above the default limit")
+        self.assertEqual(stale, [])
+
+
+if __name__ == "__main__":
+    unittest.main()

From bf72e62d0839a208c0740df9bfcb1667ffd0dd4b Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 08:38:23 +0530
Subject: [PATCH 2/9] refactor(dashboard): split page.html into per-view source
 parts

page.html was 1.26 MB (about 315k tokens), larger than an agent's context
window, so every dashboard change began with dozens of grep and sed probes
whose results stayed in context. The October survey attributes about 46% of
carried tool output in this repo's sessions to that navigation.

The dashboard source now lives in dashboard/ as 42 parts (all under 80 KB):
styles/, markup/, and js/ files grouped by view. dashboard/page.manifest lists
their serving order and the server concatenates them byte for byte, so the
served page is identical to the old page.html. No build step or dependency.

- token_meter/dashboard_page.py: validated manifest, cached assembly
- server: serves the assembled page; assets resolve beside dashboard/
- runtime manifest, start script, Windows runtime check, CI updated
- tests read one assembled copy through tests/dashboard_page.py
- scripts/check-page replaces the inline node parse command
- scripts/split-dashboard re-splits a branch's own page.html by anchors,
  so open branches can port their dashboard edits

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 .../skills/token-meter-development/SKILL.md   |     2 +-
 .github/workflows/tests.yml                   |     2 +-
 AGENTS.md                                     |     4 +-
 dashboard/head.html                           |     7 +
 dashboard/js/agent-access.js                  |   276 +
 dashboard/js/all-sessions.js                  |   192 +
 dashboard/js/budgets-discounts.js             |   370 +
 dashboard/js/capabilities.js                  |   498 +
 dashboard/js/charts.js                        |   393 +
 dashboard/js/core.js                          |   396 +
 dashboard/js/current-sessions.js              |   635 +
 dashboard/js/deck.js                          |   379 +
 dashboard/js/efficiency.js                    |   385 +
 dashboard/js/git.js                           |   419 +
 dashboard/js/goals.js                         |   535 +
 dashboard/js/live.js                          |   171 +
 dashboard/js/models.js                        |   361 +
 dashboard/js/motion-readouts.js               |   103 +
 dashboard/js/notifications-settings.js        |   450 +
 dashboard/js/router.js                        |   187 +
 dashboard/js/session-budgets-filters.js       |   459 +
 dashboard/js/session-detail.js                |   442 +
 dashboard/js/session-logs-compare.js          |   364 +
 dashboard/js/spend.js                         |   535 +
 dashboard/js/subagents-explorer.js            |   295 +
 dashboard/js/subagents.js                     |   365 +
 dashboard/js/theme-navigation.js              |   288 +
 dashboard/js/work-insights.js                 |   407 +
 dashboard/js/work-status.js                   |   374 +
 dashboard/markup/efficiency-work.html         |   109 +
 dashboard/markup/git-learn-tools.html         |   108 +
 dashboard/markup/settings.html                |   169 +
 dashboard/markup/shell.html                   |   369 +
 dashboard/markup/spend.html                   |   144 +
 dashboard/markup/subagents-models.html        |    52 +
 dashboard/page.manifest                       |    45 +
 dashboard/styles/base.css                     |    71 +
 dashboard/styles/components.css               |   495 +
 dashboard/styles/git.css                      |    98 +
 dashboard/styles/models-learn.css             |   209 +
 dashboard/styles/motion-sessions.css          |   324 +
 dashboard/styles/sessions-subagents.css       |   342 +
 dashboard/styles/shell.css                    |   318 +
 dashboard/styles/themes.css                   |   789 +
 dashboard/styles/tools.css                    |   349 +
 dashboard/tail.html                           |     1 +
 page.html                                     | 13233 ----------------
 runtime-manifest.txt                          |     3 +-
 scripts/check-page                            |    11 +
 scripts/install-windows.ps1                   |     3 +-
 scripts/split-dashboard                       |   122 +
 scripts/start-token-meter                     |    10 +-
 scripts/style-snapshot.js                     |     2 +-
 specs/AGENTS.md                               |     4 +-
 specs/ARCHITECTURE.md                         |     8 +-
 specs/CONTRIBUTING.md                         |     4 +-
 specs/DESIGN.md                               |     2 +-
 tests/contracts/test_design_system.py         |     5 +-
 tests/contracts/test_kiro_extension_budget.py |     3 +-
 tests/contracts/test_runtime_catalog.py       |     3 +-
 tests/contracts/test_source_size_budget.py    |     1 -
 tests/dashboard_page.py                       |    37 +
 .../integration/test_model_pricing_compat.py  |     3 +-
 tests/test_agent_skills.py                    |     3 +-
 tests/test_cache_countdown.py                 |     3 +-
 tests/test_claude_cost_correctness.py         |     3 +-
 tests/test_codex_model_identity.py            |     3 +-
 tests/test_dashboard_page.py                  |   108 +
 tests/test_git_delivery.py                    |     7 +-
 tests/test_goals.py                           |     3 +-
 tests/test_meter.py                           |   111 +-
 tests/test_work_insights.py                   |    39 +-
 token_meter/app.py                            |    41 +-
 token_meter/dashboard_page.py                 |   112 +
 74 files changed, 13820 insertions(+), 13353 deletions(-)
 create mode 100644 dashboard/head.html
 create mode 100644 dashboard/js/agent-access.js
 create mode 100644 dashboard/js/all-sessions.js
 create mode 100644 dashboard/js/budgets-discounts.js
 create mode 100644 dashboard/js/capabilities.js
 create mode 100644 dashboard/js/charts.js
 create mode 100644 dashboard/js/core.js
 create mode 100644 dashboard/js/current-sessions.js
 create mode 100644 dashboard/js/deck.js
 create mode 100644 dashboard/js/efficiency.js
 create mode 100644 dashboard/js/git.js
 create mode 100644 dashboard/js/goals.js
 create mode 100644 dashboard/js/live.js
 create mode 100644 dashboard/js/models.js
 create mode 100644 dashboard/js/motion-readouts.js
 create mode 100644 dashboard/js/notifications-settings.js
 create mode 100644 dashboard/js/router.js
 create mode 100644 dashboard/js/session-budgets-filters.js
 create mode 100644 dashboard/js/session-detail.js
 create mode 100644 dashboard/js/session-logs-compare.js
 create mode 100644 dashboard/js/spend.js
 create mode 100644 dashboard/js/subagents-explorer.js
 create mode 100644 dashboard/js/subagents.js
 create mode 100644 dashboard/js/theme-navigation.js
 create mode 100644 dashboard/js/work-insights.js
 create mode 100644 dashboard/js/work-status.js
 create mode 100644 dashboard/markup/efficiency-work.html
 create mode 100644 dashboard/markup/git-learn-tools.html
 create mode 100644 dashboard/markup/settings.html
 create mode 100644 dashboard/markup/shell.html
 create mode 100644 dashboard/markup/spend.html
 create mode 100644 dashboard/markup/subagents-models.html
 create mode 100644 dashboard/page.manifest
 create mode 100644 dashboard/styles/base.css
 create mode 100644 dashboard/styles/components.css
 create mode 100644 dashboard/styles/git.css
 create mode 100644 dashboard/styles/models-learn.css
 create mode 100644 dashboard/styles/motion-sessions.css
 create mode 100644 dashboard/styles/sessions-subagents.css
 create mode 100644 dashboard/styles/shell.css
 create mode 100644 dashboard/styles/themes.css
 create mode 100644 dashboard/styles/tools.css
 create mode 100644 dashboard/tail.html
 delete mode 100644 page.html
 create mode 100755 scripts/check-page
 create mode 100755 scripts/split-dashboard
 create mode 100644 tests/dashboard_page.py
 create mode 100644 tests/test_dashboard_page.py
 create mode 100644 token_meter/dashboard_page.py

diff --git a/.agents/skills/token-meter-development/SKILL.md b/.agents/skills/token-meter-development/SKILL.md
index 1287cd23..26d12d50 100644
--- a/.agents/skills/token-meter-development/SKILL.md
+++ b/.agents/skills/token-meter-development/SKILL.md
@@ -59,7 +59,7 @@ that no longer qualifies.
 
 ### Dashboard styling
 
-For any change to `page.html` styles, markup, or chart rendering:
+For any change to dashboard styles, markup, or chart rendering (`dashboard/`):
 
 1. Read `specs/DESIGN.md` → Tokens and Contract, Provider identity, and
    Components before editing.
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index d0890c2d..fe955387 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -98,7 +98,7 @@ jobs:
 
       - name: Parse the dashboard JavaScript
         run: |
-          node -e "const fs=require('fs');const h=fs.readFileSync('page.html','utf8');const m=h.match(/<script>([\s\S]*)<\/script>/);new Function(m[1]);console.log('js ok')"
+          scripts/check-page
 
       - name: Check shell syntax
         run: |
diff --git a/AGENTS.md b/AGENTS.md
index 5549a0ec..3734aa70 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,7 +24,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `token_meter/domain/` | Runtime-neutral usage, timing, tools, insights, and aggregates |
 | `token_meter/domain/compare.py` | Content-free session comparison, cheapest/fastest picks, and same-title matching |
 | `token_meter/projections.py` | Explicit allowlisted public compatibility projections |
-| `page.html` | Entire browser dashboard: markup, styles, routing, and JavaScript |
+| `dashboard/` | Browser dashboard source, one file per view: `styles/*.css`, `markup/*.html`, `js/*.js`. `page.manifest` lists the serving order; the server concatenates the parts into one page. Read the one part you need, not the assembled page |
 | `specs/DESIGN.md` | Visual system: tokens, provider identity, components, readability floor, contract |
 | `tests/contracts/test_design_system.py` | Design-system contract: tokens, scales, contrast, components, dead CSS, provider colors |
 | `scripts/style-snapshot.js` | Browser computed-style before/after diff for stylesheet-wide changes |
@@ -57,7 +57,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `python3 scripts/run-tests` | Run the same suite across one worker per CPU (`-j N` to limit, `-v` for per-test times) |
 | `python3 -m unittest tests.contracts.test_design_system -v` | Check dashboard styling against the design-system contract |
 | `PYTHONPYCACHEPREFIX=/private/tmp/token-meter-pycache python3 -m py_compile meter.py token_meter_mcp.py $(find token_meter -type f -name '*.py' -print)` | Compile Python without polluting the repo |
-| `node -e "const fs=require('fs');const h=fs.readFileSync('page.html','utf8');const m=h.match(/<script>([\\s\\S]*)<\\/script>/);new Function(m[1]);console.log('js ok')"` | Parse embedded dashboard JavaScript |
+| `scripts/check-page` | Assemble the dashboard and parse its JavaScript |
 | `bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux scripts/setup-work-classifier` | Check shell syntax |
 | `swiftc menubar/TokenMeterMenuBar.swift -o /private/tmp/token-meter-menubar` | Compile the native companion |
 | `TOKEN_METER_MENUBAR_SMOKE=1 /private/tmp/token-meter-menubar` | Run deterministic native smoke output |
diff --git a/dashboard/head.html b/dashboard/head.html
new file mode 100644
index 00000000..15fed603
--- /dev/null
+++ b/dashboard/head.html
@@ -0,0 +1,7 @@
+<!doctype html><html lang=en data-theme=classic><head><meta charset=utf-8>
+<script id=theme-boot>(function(){var ids=['classic','nebula','monolith','voltage','phosphor','omarchy','jadehorse','ferrous','afterglow'];function resolve(pref){return ids.indexOf(pref)>=0?pref:'classic';}window.tokenMeterTheme={ids:ids,resolve:resolve};try{document.documentElement.dataset.theme=resolve(localStorage.getItem('tm_theme'));}catch(e){}})();</script>
+<meta name=viewport content="width=device-width,initial-scale=1">
+<title>Token Meter</title>
+<link rel=icon type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='14' fill='%2307090c'/%3E%3Cpath fill='%23fff' d='M47.03 36.16v-7.58L10 10v8.32l28.7 13.97L10 46.44v8.14l37.03-18.4z'/%3E%3C/svg%3E">
+<meta name=theme-color content="#07090c">
+<style>
diff --git a/dashboard/js/agent-access.js b/dashboard/js/agent-access.js
new file mode 100644
index 00000000..bdb11798
--- /dev/null
+++ b/dashboard/js/agent-access.js
@@ -0,0 +1,276 @@
+function budgetAllocationsFromInputs(){
+ const allocations={};
+ budgetRuntimeIds().forEach(provider=>{allocations[provider]=budgetNumber(`budget-input-${provider}`);});
+ return allocations;
+}
+function previewCalculatedBudget(){
+ const total=Object.values(budgetAllocationsFromInputs()).reduce((sum,value)=>sum+(Number.isFinite(value)?Math.max(0,value):0),0);
+ $('budget-total').textContent=total?wholeMoney(total):'Not set';
+ $('budget-total-note').textContent=total?'draft total':'Add runtime budgets to enable tracking';
+}
+$('budget-form').addEventListener('input',event=>{budgetSettingsDirty=true;if(event.target.closest('.budgetRuntimeInput'))previewCalculatedBudget();$('budget-settings-status').className='settingsStatus warn';$('budget-settings-status').textContent='Unsaved changes';});
+$('budget-form').onsubmit=async event=>{
+ event.preventDefault();
+ const button=$('budget-save'),allocations=budgetAllocationsFromInputs();
+	 const payload={currency:'USD',default_session_budget:budgetNumber('budget-input-session-default'),allocations,thresholds:parsedBudgetThresholds(),native_notifications:$('budget-input-notifications').checked};
+ button.disabled=true;button.textContent='Saving…';
+ try{
+  const response=await fetch('/settings/budgets',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':agentActionToken()},body:JSON.stringify(payload)});
+	  const result=await response.json();if(!response.ok||!result.ok)throw new Error(result.error||'Could not save budget settings.');
+  budgetSettingsDirty=false;
+	  if(LATEST?.xsession){LATEST.xsession.budgets=result.budgets;LATEST.xsession.budget=result.budget;LATEST.xsession.monthly=result.monthly;}
+	  renderBudgets(LATEST?.xsession||result);
+	  if(CURRENT)loadBudgetForSession(CURRENT);
+	  $('budget-settings-status').className='settingsStatus good';$('budget-settings-status').textContent='Saved';
+	  const total=Number(result.budgets?.monthly_total||0);
+	  const sessionDefault=Number(result.budgets?.default_session_budget||10);
+	  showAppToast({title:'Budget settings updated',body:total?`${money(sessionDefault)} per session by default · ${money(total)} per month.`:`${money(sessionDefault)} per session by default · monthly tracking is unconfigured.`,kind:'good'});
+ }catch(error){$('budget-settings-status').className='settingsStatus warn';$('budget-settings-status').textContent=error.message||String(error);showAppToast({title:'Budget could not be saved',body:error.message||String(error),kind:'warn',sticky:true});}
+ finally{button.disabled=false;button.textContent='Save budgets';}
+};
+function agentSkillsView(row){
+ const skills=row.skills||{}, managed=(skills.managed||0)>0;
+ const remove={label:'Remove',enabled:false};
+ if(!skills.available)return{text:'Not included in this install',cls:'',buttons:[{label:'Install',enabled:true,disabled:true}]};
+ if(!skills.detected)return managed
+  ?{text:`${skills.target||'Client'} not found · Token Meter skills still installed`,cls:'warn',buttons:[remove]}
+  :{text:`${skills.target||'Client'} not found`,cls:'',buttons:[{label:'Install',enabled:true,disabled:true}]};
+ if(skills.state==='installed')return{text:`${skills.total===1?'1 skill installed':`${skills.total} skills installed`} · available in new sessions`,cls:'connected',buttons:[remove]};
+ if(skills.state==='outdated')return{text:'Update available',cls:'warn',buttons:[{label:'Update',enabled:true},remove]};
+ if(skills.state==='partial'){
+  const installable=(skills.missing||[]).length+(skills.outdated||[]).length>0;
+  const fresh=!(skills.unmanaged||[]).length&&!(skills.outdated||[]).length&&(skills.missing||[]).length;
+  return{text:(skills.unmanaged||[]).length?'Partly installed · a skill you created or edited uses one of the names':fresh?`New skills available · ${skills.installed} of ${skills.total} installed`:'Partly installed',cls:'warn',buttons:installable?[{label:(skills.missing||[]).length?'Install':'Update',enabled:true},remove]:[remove]};
+ }
+ if(skills.state==='conflict')return{text:'A skill you created or edited already uses this name',cls:'warn',buttons:[{label:'Install',enabled:true,disabled:true}]};
+ return{text:'Usage review, budget pacing, and skill hygiene',cls:'',buttons:[{label:'Install',enabled:true}]};
+}
+function agentSkillsRow(row){
+ const view=agentSkillsView(row);
+ const buttons=view.buttons.map(b=>`<button class="tbtn ${b.enabled?'':'danger'}" type=button data-agent-skills="${esc(row.id)}" data-agent-enabled="${b.enabled?'true':'false'}" ${b.disabled?'disabled':''}>${b.label}</button>`).join('');
+ return `<div class="agentClientPart agentClientSkills"><div><div class=agentClientName>Token Meter skills</div><div class="agentClientState ${view.cls}">${esc(view.text)}</div></div><div class=agentClientActions>${buttons}</div></div>`;
+}
+function openAgentSkillsDialog(client,enabled){
+ const row=(AGENT_ACCESS?.clients||[]).find(item=>item.id===client);
+ if(!row?.skills)return;
+ const skills=row.skills, folder=client==='codex'?'~/.codex/skills':'~/.claude/skills';
+ const skip=new Set([...(skills.unmanaged||[]),...(enabled?[]:(skills.missing||[]))]);
+ const keep=enabled?new Set((skills.names||[]).filter(name=>!(skills.missing||[]).includes(name)&&!(skills.outdated||[]).includes(name))):new Set();
+ const names=(skills.names||[]).filter(name=>!skip.has(name)&&!keep.has(name));
+ const verb=!enabled?'Remove':skills.state==='outdated'?'Update':'Install';
+ pendingAgentAccess={kind:'skills',client,enabled,row,verb};
+ $('agent-dialog-title').textContent=`${verb} Token Meter skills for ${skills.target}?`;
+ $('agent-dialog-sub').textContent=enabled?`Copy Token Meter's skills into ${folder}.`:`Delete only Token Meter's own skill files from ${folder}.`;
+ $('agent-dialog-evidence').innerHTML=enabled
+  ? '<div>Skills run only when you ask. They read numbers through the <code>tokenmeter</code> MCP, so connect it too.</div><div>A skill with the same name that you created or edited is never changed.</div><div>Token Meter updates its unedited copies when it updates; remove them here at any time.</div>'
+  : '<div>Your MCP connection, dashboard, and history stay unchanged.</div><div>Skills you created or edited are never deleted.</div>';
+ $('agent-dialog-command-label').textContent=enabled?'Files to write':'Files to delete';
+ $('agent-dialog-command').textContent=names.map(name=>`${folder}/${name}/SKILL.md`).join('\n');
+ $('agent-dialog-note').textContent='Only unedited files Token Meter installed are managed. Start a new agent session after the change.';
+ $('agent-confirm').textContent=verb;
+ $('agent-confirm').classList.toggle('danger',!enabled);
+ $('agent-dialog').showModal();
+}
+function renderAgentAccess(status){
+ AGENT_ACCESS=status;
+ const clients=status?.clients||[];
+ $('agent-clients').innerHTML=clients.map(row=>{
+  const stateClass=row.connected?'connected':row.conflict?'warn':'';
+  const label=row.connected?'Disconnect':row.conflict?'Repair':'Connect';
+  const disabled=!row.connected&&!row.available;
+  const detail=!row.detected?(row.id==='claude'?row.status:'CLI not found'):!row.available?'Token Meter launcher unavailable':row.status;
+  return `<div class=agentClient><div class=agentClientPart><div><div class=agentClientName>${esc(row.label)} MCP</div><div class="agentClientState ${stateClass}">${esc(detail)}${row.connected?' · available in new sessions':''}</div></div><button class="tbtn ${row.connected?'danger':''}" type=button data-agent-client="${esc(row.id)}" data-agent-enabled="${row.connected?'false':'true'}" ${disabled?'disabled':''}>${label}</button></div>${agentSkillsRow(row)}</div>`;
+ }).join('')||'<div class=agentClient><div><div class=agentClientName>Status unavailable</div><div class=agentClientState>Refresh Token Meter and try again.</div></div></div>';
+ const dismissed=localStorage.getItem('tm_agent_discovery_dismissed')==='1';
+ $('agent-discovery').hidden=!!(dismissed||!status?.any_detected||status?.any_connected);
+}
+async function loadAgentAccess(){
+ if(agentAccessLoading)return false;
+ agentAccessLoading=true;
+ try{
+  const response=await fetch('/agent-access/status',{cache:'no-store'});
+  if(!response.ok)throw new Error(`Connection status failed (${response.status}).`);
+  renderAgentAccess(await response.json());
+  return true;
+ }catch(error){
+  $('agent-clients').innerHTML='<div class=agentClient><div><div class=agentClientName>Could not read connection status</div><div class=agentClientState>Token Meter will retry when you reopen this view.</div></div></div>';
+  $('agent-discovery').hidden=true;
+  return false;
+ }finally{agentAccessLoading=false;}
+}
+function openAgentAccessDialog(client,enabled){
+ const row=(AGENT_ACCESS?.clients||[]).find(item=>item.id===client);
+ if(!row)return;
+ const repairing=!!(enabled&&row.conflict);
+ pendingAgentAccess={client,enabled,row};
+ $('agent-dialog-title').textContent=`${repairing?'Repair':enabled?'Connect':'Disconnect'} ${row.label}?`;
+ $('agent-dialog-sub').textContent=repairing
+  ? 'Replace only the existing user-level tokenmeter entry with the launcher from this Token Meter install.'
+  : enabled?'Add Token Meter as a user-level, local stdio MCP server.':'Remove only Token Meter’s exact user-level MCP entry.';
+ $('agent-dialog-evidence').innerHTML=repairing
+  ? '<div>The existing tokenmeter entry will be removed, recreated with this install’s launcher, and verified.</div><div>No other MCP entries or agent settings are changed.</div><div>Existing agent sessions keep their loaded tool list until restarted.</div>'
+  : enabled
+  ? '<div>Read-only and on demand; no background agent monitoring.</div><div>Prompts, messages, reasoning, tool arguments, tool results, credentials, config values, and named history are excluded.</div><div>Returned metrics enter this agent’s context and may be processed by its model provider.</div>'
+  : '<div>Your Token Meter dashboard and local history stay unchanged.</div><div>Existing agent sessions keep their loaded tool list until restarted.</div>';
+ $('agent-dialog-command-label').textContent='Exact local command';
+ $('agent-dialog-note').innerHTML='Only Token Meter&rsquo;s exact <code>tokenmeter</code> entry is managed. Start a new agent session after the change.';
+ $('agent-dialog-command').textContent=repairing?`${row.disconnect_command}\n${row.connect_command}`:enabled?row.connect_command:row.disconnect_command;
+ $('agent-confirm').textContent=repairing?'Repair':enabled?'Connect':'Disconnect';
+ $('agent-confirm').classList.toggle('danger',!enabled);
+ $('agent-dialog').showModal();
+}
+$('agent-clients').onclick=async e=>{
+ const skillsButton=e.target.closest('[data-agent-skills]');
+ if(skillsButton){if(!skillsButton.disabled)openAgentSkillsDialog(skillsButton.dataset.agentSkills,skillsButton.dataset.agentEnabled==='true');return;}
+ const button=e.target.closest('[data-agent-client]');
+ if(!button||button.disabled)return;
+ const client=button.dataset.agentClient;
+ if((AGENT_ACCESS?.clients||[]).find(item=>item.id===client)?.blocked){
+  if(agentAccessRechecking)return;
+  agentAccessRechecking=true;
+  let refreshed=false;
+  try{refreshed=await loadAgentAccess();}finally{agentAccessRechecking=false;}
+  if(!refreshed)return;
+  const row=(AGENT_ACCESS?.clients||[]).find(item=>item.id===client);
+  if(row?.blocked){
+   const action=row.connected?'Disconnect':row.conflict?'Repair':'Connect';
+   showAppToast(row.unreadable
+    ? {title:'Claude app settings could not be read',body:`Token Meter left the Claude app's settings file unchanged. Fix or replace that file, then click ${action} here again.`,kind:'warn',sticky:true}
+    : {title:'Quit the Claude app first',body:`The Claude app rewrites its settings while it is open, so Token Meter cannot change them yet. Quit it with ⌘Q (closing the window is not enough), then click ${action} here again.`,kind:'warn',sticky:true});
+   return;
+  }
+  if(row)openAgentAccessDialog(client,!row.connected);
+  return;
+ }
+ openAgentAccessDialog(client,button.dataset.agentEnabled==='true');
+};
+$('agent-cancel').onclick=()=>{$('agent-dialog').close();pendingAgentAccess=null;};
+$('agent-dialog').addEventListener('cancel',()=>{pendingAgentAccess=null;});
+$('agent-confirm').onclick=async()=>{
+ if(!pendingAgentAccess)return;
+ const token=agentActionToken();
+ if(!token){showAppToast({title:'Connection not ready',body:'Wait for Token Meter’s live state, then try again.',kind:'warn'});return;}
+ const button=$('agent-confirm'), action=pendingAgentAccess;
+ if(action.kind==='skills'){
+  button.disabled=true;button.textContent=action.verb==='Update'?'Updating…':action.enabled?'Installing…':'Removing…';
+  try{
+   const response=await fetch('/agent-skills/toggle',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({client:action.client,enabled:action.enabled})});
+   const result=await response.json();
+   if(!response.ok||!result.ok)throw new Error(result.error||'Skill change failed.');
+   $('agent-dialog').close();pendingAgentAccess=null;
+   await loadAgentAccess();
+   showAppToast({title:result.partial?'Skills partly installed':action.verb==='Update'?'Skills updated':action.enabled?'Skills installed':'Skills removed',body:result.message||'Start a new agent session for the change to take effect.',kind:result.partial?'warn':action.enabled?'good':'neutral',sticky:true});
+  }catch(error){
+   await loadAgentAccess();
+   showAppToast({title:'Skill change failed',body:error.message||String(error),kind:'warn',sticky:true});
+  }finally{button.disabled=false;if(pendingAgentAccess)button.textContent=pendingAgentAccess.verb;}
+  return;
+ }
+ const repairing=!!(action.enabled&&action.row.conflict);
+ button.disabled=true;button.textContent=repairing?'Repairing…':action.enabled?'Connecting…':'Disconnecting…';
+ try{
+  const response=await fetch('/agent-access/toggle',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({client:action.client,enabled:action.enabled,repair:repairing})});
+  const result=await response.json();
+  if(!response.ok||!result.ok)throw new Error(result.error||'Connection change failed.');
+  localStorage.setItem('tm_agent_discovery_dismissed','1');
+  $('agent-dialog').close();pendingAgentAccess=null;
+  await loadAgentAccess();
+  showAppToast({title:result.repaired?'Connection repaired':action.enabled?'Agent connected':'Agent disconnected',body:result.message||'Start a new agent session for the change to take effect.',kind:action.enabled?'good':'neutral',sticky:true});
+ }catch(error){
+  showAppToast({title:'Connection change failed',body:error.message||String(error),kind:'warn',sticky:true});
+ }finally{button.disabled=false;if(pendingAgentAccess)button.textContent=pendingAgentAccess.enabled?(pendingAgentAccess.row.conflict?'Repair':'Connect'):'Disconnect';}
+};
+$('agent-discovery-open').onclick=()=>{setHashRoute('settings');setTimeout(()=>$('agent-access').scrollIntoView({behavior:'smooth',block:'start'}),30);};
+$('agent-discovery-close').onclick=()=>{localStorage.setItem('tm_agent_discovery_dismissed','1');$('agent-discovery').hidden=true;};
+function pushAppNotice(title,body,kind='neutral',opts={}){
+ const entry={title,body:body||'',kind,time:notifyStamp(),sticky:!!opts.sticky};
+ notifyLog.unshift(entry); notifyLog=notifyLog.slice(0,24); saveNotifyLog(); renderNotifyLog(); showAppToast(entry);
+ $('notify')?.classList.add('hasnew');
+ setNotifyState((opts.status||'Notification logged')+' at '+entry.time+'.');
+ return entry;
+}
+function browserBlockReason(){
+ if(!canNotify) return 'Browser notifications are not supported here.';
+ if(!notifySecure) return 'Notifications require localhost or a secure origin.';
+ if(Notification.permission==='denied') return 'Notifications are blocked in browser or system settings.';
+ if(Notification.permission!=='granted') return 'Browser notification permission is not granted.';
+ return '';
+}
+function notifyBlockReason(){
+ if(!notifyOn) return 'Browser notifications are off.';
+ return browserBlockReason();
+}
+function paintNotify(){
+ let browserReason=browserBlockReason();
+ if(notifyOn&&browserReason){
+  notifyOn=false;
+  localStorage.setItem('tm_notify','0');
+ }
+ const control=$('notify');
+ if(control){control.classList.toggle('on',notifyOn);control.setAttribute('aria-checked',String(notifyOn));}
+ browserReason=browserBlockReason();
+ if($('notifytxt'))$('notifytxt').textContent=notifyOn?'Budget alerts':(!canNotify?'Unavailable':(Notification.permission==='denied'?'Blocked':'Budget alerts'));
+ if(notifyOn) setNotifyState('Browser notifications ready.');
+ else setNotifyState(browserReason||'Browser notifications are off.');
+}
+function fireNotification(title,body,key,opts={}){
+ const reason=notifyBlockReason();
+ if(reason){
+  if(reason!=='Browser notifications are off.'){
+   notifyOn=false;
+   localStorage.setItem('tm_notify','0');
+   paintNotify();
+  }
+  setNotifyState(reason);
+  return false;
+ }
+ const k=opts.dedupe===false?(key||title)+':'+Date.now():(key||title+body);
+ if(notifiedKeys.has(k)) return false;
+ try{
+  const n=new Notification(title,{body,tag:k,renotify:!!opts.renotify,requireInteraction:!!opts.requireInteraction,timestamp:Date.now()});
+  n.onclick=()=>{ try{ window.focus(); n.close(); }catch(e){} };
+  notifiedKeys.add(k);
+  const entry=pushAppNotice(title,body,opts.kind||'neutral',{sticky:opts.requireInteraction,status:'Browser notification sent'});
+  setNotifyState('Browser notification sent at '+entry.time+'.');
+  return true;
+ }catch(e){
+  pushAppNotice('Browser notification failed',`${title}: ${body}`,'warn',{sticky:true,status:'Browser notification failed'});
+  setNotifyState('Browser notification failed: '+(e&&e.message?e.message:'browser rejected it')+'.');
+  return false;
+ }
+}
+function sendTestNotification(){
+ return fireNotification('Token Meter test','Notifications are working for this dashboard.','test',{dedupe:false,requireInteraction:true,renotify:true});
+}
+function applyPermission(p,after){
+ if(p==='granted'){
+  notifyOn=true;
+  localStorage.setItem('tm_notify','1');
+  paintNotify();
+  notifiedKeys.clear();
+  if(after==='test') sendTestNotification(); else fireNotification('Token Meter','Notifications enabled.','enabled:'+Date.now(),{dedupe:false,renotify:true});
+  if(CURRENT&&!pinned) setTimeout(()=>notifyAlertForSession(CURRENT,{forceCurrent:true}),350);
+ }
+ else{
+  notifyOn=false;
+  localStorage.setItem('tm_notify','0');
+  paintNotify();
+  if(p==='denied') pushAppNotice('Browser notifications blocked','Enable notifications in browser or system settings, then toggle again.','warn',{sticky:true,status:'Browser notifications blocked'});
+  else pushAppNotice('Browser notifications not enabled','Permission was not granted for browser notifications.','warn',{status:'Permission not granted'});
+ }
+}
+function requestNotify(after){
+ if(!canNotify){ setNotifyState('Browser notifications are not supported here.'); pushAppNotice('Browser notifications unavailable','This browser does not support notifications.','warn',{sticky:true,status:'Browser notifications unavailable'}); return; }
+ if(!notifySecure){ setNotifyState('Notifications require localhost or a secure origin.'); pushAppNotice('Browser notifications unavailable','Notifications require localhost or a secure origin.','warn',{sticky:true,status:'Browser notifications unavailable'}); return; }
+ const req=Notification.requestPermission();
+ if(req&&typeof req.then==='function') req.then(p=>applyPermission(p,after)); else applyPermission(req,after);
+}
+paintNotify();
+renderNotifyLog();
+
+const SESSION_BUDGET_SLIDER_MIN=0.5;
+const SESSION_BUDGET_SLIDER_BASE_MAX=100;
+let legacySessionBudgets={};
+const sessionBudgetWrites=new Map();
+try{legacySessionBudgets=JSON.parse(localStorage.getItem('tm_session_budgets')||'{}')||{};}catch(e){legacySessionBudgets={};}
+localStorage.removeItem('tm_budget');
diff --git a/dashboard/js/all-sessions.js b/dashboard/js/all-sessions.js
new file mode 100644
index 00000000..19fc021b
--- /dev/null
+++ b/dashboard/js/all-sessions.js
@@ -0,0 +1,192 @@
+function allSessionsView(all,{showChildren=false,app='',project='',rangeStart=0,rangeEnd=0,query=''}={}){
+ const baseMatch=s=>{
+  if(app&&appFilterGroup(s)!==app)return false;
+  if(project&&projectFilterValue(s.project)!==project)return false;
+  if(rangeStart&&(s.mtime||0)<rangeStart)return false;
+  if(rangeEnd&&(s.mtime||0)>=rangeEnd)return false;
+  return true;
+ };
+ const textMatch=s=>!query||[s.title,s.project,s.provider,s.label,s.child_agent_role,(s.models||[]).join(' ')].join(' ').toLowerCase().includes(query);
+ const matching=(all||[]).filter(s=>baseMatch(s)&&textMatch(s));
+ const children=matching.filter(s=>s.is_child_session);
+ let rows=matching;
+ if(!showChildren){
+  // A matching child run surfaces its root card, so search still finds it.
+  const childRoots=new Set(children.map(childRootId).filter(Boolean));
+  rows=(all||[]).filter(s=>!s.is_child_session&&((baseMatch(s)&&textMatch(s))||childRoots.has(String(s.id))));
+ }
+ // Header figures cover exactly the matching sessions and child runs in both
+ // modes; a root card surfaced only by a matching child adds no spend of its own.
+ const statsRows=matching;
+ const shownIds=new Set(rows.map(s=>String(s.id)));
+ const underParent=children.filter(s=>shownIds.has(childRootId(s))).length;
+ const matchedSessions=matching.length-children.length;
+ return {
+  rows,statsRows,showChildren,
+  matchedSessions,
+  total:(all||[]).filter(s=>!s.is_child_session).length,
+  surfacedParents:showChildren?0:Math.max(0,rows.length-matchedSessions),
+  children:children.length,
+  childCost:children.filter(s=>metricAvailable(s,'cost')).reduce((a,b)=>a+(b.cost||0),0),
+  underParent,
+  unparented:children.length-underParent,
+ };
+}
+function allSessionsCountText(view){
+ const statsRows=view.statsRows;
+ const cost=statsRows.reduce((a,b)=>a+(b.cost||0),0),localEstimates=statsRows.filter(row=>hasLocalEstimate(row)&&metricAvailable(row,'cost')).length,costCovered=statsRows.filter(row=>metricAvailable(row,'cost')).length;
+ // Hidden subagent runs are still counted in totals, so report how many of the
+ // matching runs sit under a shown parent card and how many have no parent.
+ const parentNote=view.unparented
+  ?`${f(view.underParent)} shown under parent cards · ${f(view.unparented)} with no parent session`
+  :'listed under parents';
+ const childNote=!view.showChildren&&view.children
+  ?` · includes ${f(view.children)} subagent ${countWord(view.children,'run')} (${money(view.childCost)}) counted, ${parentNote}`
+  :'';
+ // Sessions and child runs are counted separately; spend and cost coverage
+ // share one denominator: the matching sessions plus matching child runs.
+ const runNote=view.showChildren&&view.children?` + ${f(view.children)} subagent ${countWord(view.children,'run')}`:'';
+ const surfacedNote=view.surfacedParents?` · ${f(view.surfacedParents)} parent ${countWord(view.surfacedParents,'card')} shown for matching runs`:'';
+ return `${f(view.matchedSessions)} of ${f(view.total)} sessions${runNote} · ${money(cost)} covered spend · ${f(costCovered)} of ${f(statsRows.length)} cost-covered${localEstimates?` · includes ${f(localEstimates)} Cursor local ${countWord(localEstimates,'estimate')}`:''}${childNote}${surfacedNote}`;
+}
+function renderAllSessions(xs){
+ if(!xs)return;
+ const generatedAt=Number(xs.generated_at||0);
+ const liveSessionIds=new Set((xs.current_sessions||[]).map(sessionRowKey));
+ setLogText($('g-hint'),generatedAt?`live · updated ${new Date(generatedAt*1000).toLocaleTimeString([], {hour:'2-digit',minute:'2-digit',second:'2-digit'})}`:'recent activity');
+ const all=$('view-session').classList.contains('on')&&sessionScope==='all'&&allSessionInventory?mergeAllSessionInventory(allSessionInventory,xs.sessions):xs.sessions||[];
+ renderedAllSessions=new Map(all.map(row=>[sessionRowKey(row),row]));
+ // Index every discovered child run, including the ones kept out of the list,
+ // so each parent card can render its own children inline.
+ indexChildSessions(allSessionInventory&&allSessionInventory.length?allSessionInventory:all);
+ renderedAllSessionActions=xs.session_actions||{};
+ const apps=[...new Map(all.map(session=>[
+  appFilterGroup(session),
+  appFilterLabel(session),
+ ])).entries()].map(([id,label])=>({id,label})).sort((a,b)=>a.label.localeCompare(b.label,undefined,{sensitivity:'base'}));
+ if(globalApp&&!apps.some(app=>app.id===globalApp)){
+  globalApp='';
+  localStorage.removeItem('tm_global_app');
+ }
+ setLogSelectOptions($('g-app'),'<option value="">All apps</option>'+apps.map(app=>`<option value="${esc(app.id)}">${esc(app.label)}</option>`).join(''),globalApp);
+ const projects=[...new Set(all.map(s=>projectFilterValue(s.project)))].sort((a,b)=>projectFilterLabel(a).localeCompare(projectFilterLabel(b),undefined,{sensitivity:'base'}));
+ if(globalProject&&!projects.includes(globalProject)){
+ globalProject='';
+ localStorage.removeItem('tm_global_project');
+ }
+ setLogSelectOptions($('g-project'),'<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(projectFilterLabel(project))}</option>`).join(''),globalProject);
+ paintGlobalFilters();
+ const timeLabels=TIME_FILTER_LABELS;
+ const appLabel=apps.find(app=>app.id===globalApp)?.label||globalApp;
+ const activeFilters=[
+  globalSearch.trim()&&['search',`Search: “${globalSearch.trim()}”`],
+  globalApp&&['app',`App: ${appLabel}`],
+  globalProject&&['project',`Project: ${projectFilterLabel(globalProject)}`],
+  globalTime!==DEFAULT_TIME_FILTER_WINDOW&&['time',timeLabels[globalTime]||globalTime],
+  workSessionFilter&&['work',`Work: ${workSessionFilter.label}${workSessionFilter.loading?' (loading)':''}`],
+ ].filter(Boolean);
+ const hideActiveFilters=!activeFilters.length;
+ if($('g-active-filters').hidden!==hideActiveFilters)$('g-active-filters').hidden=hideActiveFilters;
+ setLogHtml($('g-active-filters'),activeFilters.length
+  ? `<span>Filtered by</span>${activeFilters.map(([key,label])=>`<button type=button data-clear-log-filter="${key}" title="Remove ${esc(label)} filter">${esc(label)}<b aria-hidden=true>×</b></button>`).join('')}`
+  : '');
+ const q=globalSearch.trim().toLowerCase();
+ const {start:rangeStart,end:rangeEnd}=timeFilterBounds(globalTime);
+ // A Work drill-down narrows the inventory to the trace files behind that Work cell.
+ const workRows=workSessionFilter?all.filter(s=>workSessionFilter.keys.has(sessionRowKey(s))):all;
+ const view=allSessionsView(workRows,{showChildren:globalShowChildren,app:globalApp,project:globalProject,rangeStart,rangeEnd,query:q});
+ let sessions=view.rows;
+ // Header stats count every matching run, so hiding subagent rows never removes
+ // their spend from the figures that the Hidden control says are still counted.
+ renderAllSessionStats(view.statsRows);
+ const sorters={
+   recent:(a,b)=>(b.mtime||0)-(a.mtime||0),
+   cost:(a,b)=>(b.cost||0)-(a.cost||0)||(b.mtime||0)-(a.mtime||0),
+   tokens:(a,b)=>(b.tokens||0)-(a.tokens||0)||(b.mtime||0)-(a.mtime||0),
+	  executions:(a,b)=>(b.turns||0)-(a.turns||0)||(b.mtime||0)-(a.mtime||0),
+	  wait:(a,b)=>Number(b.wait_time?.total_s||0)-Number(a.wait_time?.total_s||0)||(b.mtime||0)-(a.mtime||0),
+ };
+ sessions=sessions.slice().sort(sorters[globalSort]||sorters.recent);
+ if(workSessionFilter?.loading)setLogText($('g-count'),'Loading the sessions behind this Work filter…');
+ else if(workSessionFilter?.failed)setLogText($('g-count'),'The sessions behind this Work filter could not be loaded. Clear the filter or try again.');
+ else setLogText($('g-count'),allSessionsCountText(view));
+ const maxCost=Math.max(.001,...sessions.map(s=>s.cost||0));
+ reconcileLogRows(sessions,maxCost,liveSessionIds);
+ if(compareIds.length)syncCompareSelectionUi();
+}
+$('slist').onclick=event=>{
+ const compareButton=event.target.closest('[data-compare-toggle]');
+ if(compareButton){
+  event.stopPropagation();
+  if(compareButton.dataset.compareTitle)compareTitles.set(compareButton.dataset.compareToggle,compareButton.dataset.compareTitle);
+  toggleCompareId(compareButton.dataset.compareToggle);
+  return;
+ }
+ const childButton=event.target.closest('[data-open-session]');
+ if(childButton){
+  event.stopPropagation();
+  event.preventDefault();
+ const childId=childButton.dataset.openSession;
+ const childRow=renderedAllSessions.get(childId);
+ if(childRow)selectSession(sessionRowKey(childRow));
+ return;
+ }
+ const identityButton=event.target.closest('[data-session-model-identity]');
+ if(identityButton){
+  event.stopPropagation();
+  const row=renderedAllSessions.get(identityButton.closest('[data-id]')?.dataset.id);
+  if(row)openSessionModelIdentityDialog(row);
+  return;
+ }
+ const button=event.target.closest('[data-delete-session]');
+ if(button){
+  event.stopPropagation();
+  const row=renderedAllSessions.get(button.dataset.deleteSession);
+  if(row)openSessionDeleteDialog(row,renderedAllSessionActions,true,Boolean(LATEST&&sessionRowKey(row)===stateSessionKey(LATEST)));
+  return;
+ }
+ const row=event.target.closest('[data-id]');
+ if(row)selectSession(row.dataset.id);
+};
+$('slist').onkeydown=event=>{
+ const row=event.target.closest('[data-id]');
+ if(!row||!['Enter',' '].includes(event.key)||event.target.closest('button'))return;
+ event.preventDefault();
+ selectSession(row.dataset.id);
+};
+function sessionCoverageCopy(totals,sessionCount,localEstimates){
+ const costCovered=Number(totals?.costCovered)||0,tokenCovered=Number(totals?.tokenCovered)||0,estimateNote=localEstimates?` · includes ${f(localEstimates)} Cursor local ${countWord(localEstimates,'estimate')}`:'';
+ return {
+  costNote:sessionCount?(costCovered?`${f(costCovered)} of ${f(sessionCount)} cost-covered sessions · ${money(Number(totals?.cost||0)/costCovered)}/covered session${estimateNote}`:'cost unavailable for matching sessions'):'no matching sessions',
+  tokenTitle:tokenCovered?`${f(tokenCovered)} of ${f(sessionCount)} token-covered sessions${estimateNote}`:'token evidence unavailable',
+ };
+}
+function renderAllSessionStats(sessions){
+	 const localEstimates=sessions.filter(row=>hasLocalEstimate(row)&&metricAvailable(row,'cost')).length;
+	 const totals=sessions.reduce((sum,row)=>{
+	  sum.cost+=Number(row.cost||0);sum.input+=Number(row.input_tokens||0);sum.output+=Number(row.output_tokens||0);sum.executions+=Number(row.turns||0);sum.wait+=Number(row.wait_time?.total_s||0);sum.waitSamples+=Number(row.wait_time?.sample_count||0);sum.costCovered+=metricAvailable(row,'cost')?1:0;sum.tokenCovered+=metricAvailable(row,'tokens')?1:0;
+	  return sum;
+	 },{cost:0,input:0,output:0,executions:0,wait:0,waitSamples:0,costCovered:0,tokenCovered:0});
+ const coverageCopy=sessionCoverageCopy(totals,sessions.length,localEstimates);
+ setLogHtml($('lf-cost'),costValueHtml(money(totals.cost),Boolean(totals.costCovered)));
+ setLogText($('lf-cost-note'),coverageCopy.costNote);
+ setLogText($('lf-input'),totals.tokenCovered?compactNumber(totals.input):'--');setLogAttribute($('lf-input'),'title',totals.tokenCovered?`${f(totals.input)} reported or locally estimated input/context tokens · ${coverageCopy.tokenTitle}`:'input evidence unavailable');
+ setLogText($('lf-output'),totals.tokenCovered?compactNumber(totals.output):'--');setLogAttribute($('lf-output'),'title',totals.tokenCovered?`${f(totals.output)} reported or locally estimated output tokens · ${coverageCopy.tokenTitle}`:'output evidence unavailable');
+	 setLogText($('lf-executions'),f(totals.executions));
+	 setLogText($('lf-executions-note'),sessions.length?`${(totals.executions/sessions.length).toFixed(1)} average / session`:'no matching executions');
+	 setLogText($('lf-wait'),totals.waitSamples?waitFmt(totals.wait):'--');
+	 setLogText($('lf-wait-note'),totals.waitSamples?`${waitFmt(totals.wait/totals.waitSamples)} average · ${f(totals.waitSamples)} timed ${countWord(totals.waitSamples,'request')}`:'no completed wait timing in filtered sessions');
+ const models=new Map();
+ sessions.forEach(session=>{
+  let rows=session.model_stats||[];
+  if(!rows.length&&(session.models||[]).length===1)rows=[{model:session.models[0],cost:session.cost,tokens:session.tokens,input_tokens:session.input_tokens,output_tokens:session.output_tokens,executions:session.turns,availability:session.availability}];
+  rows.forEach(item=>{
+   const model=item.model||'unknown',runtime=session.runtime||session.label||session.provider||'unknown',key=`${model}::${runtime}`,row=models.get(key)||{model,runtime,cost:0,tokens:0,input:0,output:0,executions:0,sessions:0,costCovered:0,tokenCovered:0,estimated:0};
+   row.cost+=Number(item.cost||0);row.tokens+=Number(item.tokens||0);row.input+=Number(item.input_tokens||0);row.output+=Number(item.output_tokens||0);row.executions+=Number(item.executions||0);row.sessions+=1;row.costCovered+=metricAvailable(item,'cost')?1:0;row.tokenCovered+=metricAvailable(item,'tokens')?1:0;row.estimated+=hasLocalEstimate(session)?1:0;models.set(key,row);
+  });
+ });
+ const ranked=[...models.values()].sort((a,b)=>b.cost-a.cost||b.tokens-a.tokens||a.model.localeCompare(b.model));
+ setLogText($('lf-model-count'),`${f(ranked.length)} ${countWord(ranked.length,'model')}`);
+ setLogHtml($('lf-models'),ranked.length?ranked.slice(0,4).map(row=>`<div class=logModelRow><div><div class=logModelName title="${esc(row.model)} · ${esc(row.runtime)}">${esc(row.model)} · ${esc(row.runtime)}</div><div class=logModelMeta>${f(row.sessions)} ${countWord(row.sessions,'session')} · ${f(row.executions)} execs · ${row.tokenCovered?compactNumber(row.input)+' in · '+compactNumber(row.output)+' out'+(row.estimated?' · includes local estimates':''):'token evidence unavailable'}</div></div><div class=logModelValue><b class=mono>${costValueHtml(money(row.cost),Boolean(row.costCovered))}</b><span>${row.costCovered?pct(totals.cost?row.cost/totals.cost:0)+' of covered cost'+(row.estimated?' · API-rate estimate':''):'billing unavailable'}</span></div></div>`).join('')+(ranked.length>4?`<div class=logModelEmpty>+${f(ranked.length-4)} more ${countWord(ranked.length-4,'model runtime')}</div>`:''):'<div class=logModelEmpty>No model data for these filters</div>');
+}
+
diff --git a/dashboard/js/budgets-discounts.js b/dashboard/js/budgets-discounts.js
new file mode 100644
index 00000000..395a324a
--- /dev/null
+++ b/dashboard/js/budgets-discounts.js
@@ -0,0 +1,370 @@
+const DEFAULT_RUNTIME_BUDGET=0;
+let defaultSessionBudget=10;
+let budgetSettingsDirty=false;
+function budgetNumber(id){const raw=$(id).value.trim();return raw===''?0:Number(raw);}
+function budgetRuntimeIds(){
+ const catalogIds=Object.entries(RUNTIME_CATALOG).filter(([id])=>id!=='unknown-runtime').map(([id])=>id);
+ return catalogIds.length?catalogIds:[...document.querySelectorAll('.budgetRuntime[data-runtime-id]')].map(row=>row.dataset.runtimeId);
+}
+function ensureBudgetRuntimeRows(){
+ const list=$('budget-runtimes');
+ budgetRuntimeIds().forEach(provider=>{
+  if($(`budget-runtime-${provider}`))return;
+  const label=runtimeLabel({provider});
+  list.insertAdjacentHTML('beforeend',`<div class=budgetRuntime id="budget-runtime-${esc(provider)}" data-runtime-id="${esc(provider)}"><span class=budgetRuntimeName>${esc(label)}</span><span class=budgetRuntimeValue><b class=mono id="budget-runtime-spend-${esc(provider)}">$0.00</b><small id="budget-runtime-share-${esc(provider)}">0% of spend</small></span><span class=budgetRuntimeTrack id="budget-runtime-track-${esc(provider)}"><i></i></span><label class=budgetRuntimeInput><span>Budget</span><input id="budget-input-${esc(provider)}" aria-label="${esc(label)} budget" type=number min=0 max=100000000 step=any value=0></label></div>`);
+ });
+}
+function parsedBudgetThresholds(){
+ const values=[...document.querySelectorAll('[data-budget-threshold]')].map(input=>Number(input.value.trim())).filter(value=>Number.isFinite(value));
+ return [...new Set(values)].sort((a,b)=>a-b);
+}
+function paintBudgetSettings(settings){
+  settings=settings||{default_session_budget:10,monthly_total:0,allocations:{},thresholds:[80,90,100],native_notifications:true};
+  if(budgetSettingsDirty)return;
+ defaultSessionBudget=Number(settings.default_session_budget||10);
+ $('budget-input-session-default').value=formatBudgetInput(defaultSessionBudget);
+ ensureBudgetRuntimeRows();
+ budgetRuntimeIds().forEach(provider=>{$(`budget-input-${provider}`).value=Number(settings.allocations?.[provider]??DEFAULT_RUNTIME_BUDGET);});
+ const thresholds=settings.thresholds||[80,90,100];
+ [$('budget-input-threshold-early'),$('budget-input-threshold-mid'),$('budget-input-threshold-full')].forEach((input,index)=>{input.value=thresholds[index]??[80,90,100][index];});
+ $('budget-input-notifications').checked=settings.native_notifications!==false;
+}
+function budgetAlertState(){
+ try{const value=JSON.parse(localStorage.getItem('tm_monthly_budget_alerts')||'{}');return value&&typeof value==='object'?value:{};}catch(error){return {};}
+}
+function budgetExceededAlertState(){
+ try{const value=JSON.parse(localStorage.getItem('tm_monthly_budget_exceeded_alerts')||'{}');return value&&typeof value==='object'?value:{};}catch(error){return {};}
+}
+function observeBudgetThresholds(status){
+ if(!status?.configured)return;
+ const state=budgetAlertState(),crossed=status.thresholds_crossed||[],previous=state[status.month];
+ const seen=Array.isArray(previous)?previous:(Array.isArray(previous?.thresholds)?previous.thresholds:[]);
+ const firstObservation=previous===undefined,over=Number((status.alert_percent??status.percent)||0)>=1;
+ const exceededState=budgetExceededAlertState(),monthExceeded=exceededState[status.month]||{};
+ const inAppNotified=monthExceeded.inApp===true,browserNotified=monthExceeded.browser===true;
+ const fresh=crossed.filter(value=>!seen.includes(value));
+ const alertExceeded=over&&!inAppNotified;
+ const browserReady=notifyOn&&canNotify&&Notification.permission==='granted';
+ const deliverMissedBrowserAlert=over&&!browserNotified&&browserReady;
+ const threshold=alertExceeded||deliverMissedBrowserAlert?100:(!firstObservation&&fresh.length?fresh[fresh.length-1]:null);
+ const lower=status.lower_bound?'At least ':'',isExceeded=alertExceeded||deliverMissedBrowserAlert;
+ if(threshold!==null){
+  const title=isExceeded?'Monthly budget exceeded':`Monthly budget reached ${threshold}%`;
+  const body=isExceeded
+   ? `${lower}${money(status.spend)} of ${money(status.budget)} recorded for ${status.month} (${pct(status.percent)} used).`
+   : `${lower}${money(status.spend)} of ${money(status.budget)} recorded for ${status.month}.`;
+  if(browserReady)fireNotification(isExceeded?'Token Meter budget exceeded':'Token Meter monthly budget',body,`monthly:${status.month}:${isExceeded?'over':threshold}`,{dedupe:true,requireInteraction:isExceeded});
+  else pushAppNotice(title,body,isExceeded?'warn':'neutral',{sticky:isExceeded,status:title});
+ }
+ state[status.month]=[...new Set([...seen,...crossed])];
+ localStorage.setItem('tm_monthly_budget_alerts',JSON.stringify(state));
+ exceededState[status.month]={
+  inApp:inAppNotified||alertExceeded,
+  browser:browserNotified||deliverMissedBrowserAlert,
+ };
+ localStorage.setItem('tm_monthly_budget_exceeded_alerts',JSON.stringify(exceededState));
+}
+function renderCurrentBudgetWarning(status){
+ const banner=$('current-budget-warning'),rows=status?.exceeded_runtimes||[];
+ banner.classList.toggle('on',rows.length>0);
+ if(!rows.length){$('current-budget-warning-msg').textContent='';return;}
+ const lower=status.lower_bound?'At least ':'';
+ $('current-budget-warning-msg').textContent=rows.map(row=>{
+  const over=Number(row.over_by||0),verb=over>0?'exceeded':'reached';
+  return `⚠︎ ${row.label} monthly budget ${verb}: ${lower}${money(row.spend||0)} spent against ${money(row.allocation||0)} (${pct(row.percent||0)} used).`;
+ }).join(' ');
+}
+$('current-budget-settings').onclick=()=>setHashRoute('spend-budgets');
+function budgetMonthLabel(month){
+ const match=/^(\d{4})-(\d{2})$/.exec(String(month||''));
+ if(!match)return 'This month';
+ return new Date(Number(match[1]),Number(match[2])-1,1).toLocaleDateString(undefined,{month:'long',year:'numeric'});
+}
+function renderBudgets(xs){
+ if(!xs)return;
+ const status=xs.budget||{},settings=xs.budgets||status.settings||{};
+ const configured=!!status.configured,lower=status.lower_bound?'At least ':'',allocations=settings.allocations||{};
+ const runtimeExceeded=status.exceeded_runtimes||[],runtimeAttention=runtimeExceeded.length>0;
+ const allocatedTotal=Object.values(allocations).reduce((sum,value)=>sum+Number(value||0),0);
+ $('budget-spend').textContent=wholeMoney(status.spend||0);
+ $('budget-spend-qualifier').hidden=!status.lower_bound;
+ $('budget-month').textContent=budgetMonthLabel(status.month);
+ $('budget-spend-note').textContent=`${status.active_days||0} active spend ${countWord(status.active_days||0,'day')}`;
+ $('budget-total').textContent=configured?wholeMoney(status.budget):'Not set';
+ const runtimeNames=budgetRuntimeIds().map(provider=>runtimeLabel({provider})).join(' + ');
+ $('budget-total').title=allocatedTotal?runtimeNames:'';
+ $('budget-total-note').textContent=allocatedTotal?`across ${Object.values(allocations).filter(value=>Number(value)>0).length} runtime budgets`:configured?'Legacy total · set runtime budgets to replace':'Add runtime budgets to enable tracking';
+ $('budget-remaining').textContent=configured?wholeMoney(status.remaining||0):'--';
+ $('budget-remaining').className=`v mono${configured&&Number(status.percent||0)>=.8?' warn':''}`;
+ $('budget-remaining-note').textContent=status.lower_bound?'Coverage is partial; true remaining may be lower':configured?`${status.days_remaining||0} calendar days left`:'No monthly limit';
+ $('budget-projected').textContent=status.projection_ready?wholeMoney(status.projected_spend):'--';
+ $('budget-projected').className=`v mono${status.projection_ready&&status.projected_spend>status.budget?' warn':''}`;
+ $('budget-projected-note').textContent=status.projection_ready?`${wholeMoney(Math.abs(status.projected_spend-status.budget))} ${status.projected_spend>status.budget?'over':'under'} budget at current pace`:`Shown after ${status.projection_min_active_days||3} active spend days`;
+ const ratio=configured?Math.max(0,Number(status.percent||0)):0,progress=$('budget-progress');
+ progress.querySelector('i').style.width=Math.min(100,100*ratio)+'%';progress.setAttribute('aria-valuenow',String(Math.round(100*ratio)));progress.classList.toggle('warn',ratio>=.8);
+ $('budget-progress-markers').innerHTML=configured?(settings.thresholds||[]).filter(value=>value>0&&value<=100).map(value=>`<span style="left:${value}%"></span>`).join(''):'';
+ const attentionState=runtimeAttention?'over':(status.state||'unconfigured');
+ const stateLabel=runtimeAttention?`${runtimeExceeded.map(row=>row.label).join(', ')} over budget`:{unconfigured:'Not configured',on_track:'On track',warning:'Threshold crossed',over:'Budget exceeded'}[status.state]||'Current month';
+ $('budget-state').textContent=stateLabel;
+ $('budget-state').className=`agentAccessBadge chip budgetState ${attentionState}`;
+ budgetConfigured=configured;
+ paintBudgetEditorToggle();
+ $('budget-current-note').textContent=runtimeAttention
+  ? runtimeExceeded.map(row=>Number(row.over_by||0)>0
+    ? `${row.label} ${pct(row.percent||0)} used · ${wholeMoney(row.over_by||0)} over its runtime budget`
+    : `${row.label} ${pct(row.percent||0)} used · runtime budget reached`).join(' · ')
+  : configured?`${pct(ratio)} used · ${status.next_threshold?`${status.next_threshold}% next threshold`:'all thresholds crossed'}`:'Add runtime budgets to start tracking';
+ $('budget-coverage').className=`budgetCoverage${status.lower_bound?' warn':''}`;
+ const alertExcluded=Number(status.alert_excluded_spend||0);
+ $('budget-coverage').textContent=(status.lower_bound?'Partial cost coverage: recorded spend is a lower bound.':status.estimated?'Includes labeled local cost estimates.':'')+(alertExcluded>0?` Antigravity length-based estimates (${money(alertExcluded)}) are shown but don't trigger budget notifications.`:'');
+ const runtimes=status.runtimes||[],hasAllocations=runtimes.some(row=>Number(row.allocation||0)>0),runtimeSpend=Math.max(0,Number(status.spend||0));
+ $('budget-allocation-note').textContent=hasAllocations?`${lower}${wholeMoney(status.spend||0)} / ${wholeMoney(status.budget)}`:'Add runtime budgets';
+ ensureBudgetRuntimeRows();
+  const runtimeRows=new Map(runtimes.map(row=>[row.provider,row]));
+  budgetRuntimeIds().forEach(provider=>{
+  const row=runtimeRows.get(provider)||{provider,spend:0,allocation:Number(allocations[provider]||0)};
+  const spend=Number(row.spend||0),allocated=Number(row.allocation||0),percent=allocated?spend/allocated:(runtimeSpend?spend/runtimeSpend:0),over=row.exceeded===true||Boolean(allocated&&spend>=allocated);
+  const shareLabel=allocated?`${pct(percent)} of budget`:`${pct(percent)} of spend`;
+  const color=over?'var(--bad)':providerColor(row.provider);
+  const runtime=$(`budget-runtime-${provider}`);
+  runtime.style.setProperty('--provider-color',color);
+  $(`budget-runtime-spend-${provider}`).textContent=wholeMoney(spend);
+  $(`budget-runtime-share-${provider}`).textContent=shareLabel;
+  $(`budget-runtime-track-${provider}`).querySelector('i').style.width=`${Math.min(100,100*percent)}%`;
+ });
+ paintBudgetSettings(settings);
+ observeBudgetThresholds(status);
+}
+let settingsPointerActive=false;
+const settingsView=$('view-settings');
+settingsView.addEventListener('pointerdown',()=>{settingsPointerActive=true;});
+$('spend-budgets').addEventListener('pointerdown',()=>{settingsPointerActive=true;});
+window.addEventListener('pointerup',()=>{settingsPointerActive=false;});
+window.addEventListener('pointercancel',()=>{settingsPointerActive=false;});
+function settingsInteractionActive(){return viewInteractionActive($('view-settings'));}
+function budgetInteractionActive(){return viewInteractionActive($('spend-budgets'));}
+function viewInteractionActive(root){
+ const active=document.activeElement,selection=window.getSelection?.();
+ const editing=active&&root.contains(active)&&active.matches('input,textarea,select,[contenteditable=true]');
+ const selecting=selection&&!selection.isCollapsed&&selection.rangeCount&&(
+  (selection.anchorNode&&root.contains(selection.anchorNode))||(selection.focusNode&&root.contains(selection.focusNode))
+ );
+ return settingsPointerActive||Boolean(editing)||Boolean(selecting);
+}
+function renderSettings(xs){
+ if(!xs||settingsInteractionActive())return;
+ renderModelPricing(xs.model_pricing);
+}
+function renderSpendView(xs){
+ renderSpend(xs);
+ if(xs&&!budgetInteractionActive())renderBudgets(xs);
+ if(xs?.cost_discounts&&!discountEditInProgress())renderDiscounts(xs.cost_discounts);
+}
+let budgetConfigured=false;
+function paintBudgetEditorToggle(){
+ const planJump=$('budget-plan-jump'),open=!$('budget-config').hidden;
+ planJump.textContent=open?'Close editor':budgetConfigured?'Edit budgets':'Set budgets';
+ planJump.setAttribute('aria-expanded',String(open));
+ planJump.setAttribute('aria-label',open?'Close runtime budget editor':budgetConfigured?'Edit runtime budgets':'Set runtime budgets');
+}
+function setBudgetEditorOpen(open,focus=false){
+ const config=$('budget-config');
+ config.hidden=!open;
+ $('spend-discounts').hidden=!open;
+ paintBudgetEditorToggle();
+ if(!open)return;
+ config.classList.remove('attention');
+ void config.offsetWidth;
+ config.classList.add('attention');
+ setTimeout(()=>config.classList.remove('attention'),1400);
+ if(!focus)return;
+ const input=config.querySelector('.budgetRuntimeInput input');
+ config.scrollIntoView({behavior:window.matchMedia('(prefers-reduced-motion: reduce)').matches?'auto':'smooth',block:'nearest'});
+ input.focus({preventScroll:true});
+ if(input.value)input.select();
+}
+$('budget-plan-jump').onclick=()=>setBudgetEditorOpen($('budget-config').hidden,true);
+const DISCOUNT_LISTS={anthropic:['Anthropic','claude'],openai:['OpenAI','codex'],cursor:['Cursor','cursor'],kiro:['Kiro','kiro'],opencode:['OpenCode','opencode']};
+const DISCOUNT_BILLED={direct:'The provider',bedrock:'AWS Bedrock',vertex:'Google Vertex',azure:'Microsoft Azure',any:'Anyone'};
+const DISCOUNT_OWN_LISTS=new Set(['cursor','kiro','opencode']);
+const DISCOUNT_CUE_KEY='tm_discount_cue_dismissed';
+let discountTab='all',discountSettings=null,discountPollSeq=0;
+function discountRuleState(rule,now=Date.now()/1000){
+ if(rule.end!=null&&rule.end<=now)return 'ended';
+ if(rule.start!=null&&rule.start>now)return 'starts later';
+ return 'active';
+}
+function discountActiveRules(){return (discountSettings?.rules||[]).filter(rule=>discountRuleState(rule)==='active');}
+function discountDay(seconds){return new Date(seconds*1000).toLocaleDateString(undefined,{year:'numeric',month:'short',day:'numeric'});}
+// A date input is a local calendar day: send its local midnight with this browser's offset.
+function discountLocalMidnightIso(day){
+ if(!day)return null;
+ const offset=-new Date(`${day}T00:00`).getTimezoneOffset(),sign=offset<0?'-':'+',abs=Math.abs(offset);
+ return `${day}T00:00:00${sign}${String(Math.floor(abs/60)).padStart(2,'0')}:${String(abs%60).padStart(2,'0')}`;
+}
+function discountSay(text,tone=''){const status=$('discount-status');status.className='settingsStatus'+(tone?' '+tone:'');status.textContent=text;}
+// Rendering never touches the add row's inputs, so only a half-typed discount pauses it.
+let discountFormDirty=false;
+function discountEditInProgress(){
+ return discountFormDirty&&Boolean(discountSettings)&&viewInteractionActive($('spend-discounts'));
+}
+function openDiscounts(){
+ const settings=LATEST?.cost_discounts||LATEST?.xsession?.cost_discounts;
+ if(settings)renderDiscounts(settings);
+ setBudgetEditorOpen(true);
+ requestAnimationFrame(()=>{$('spend-discounts').scrollIntoView({block:'start',behavior:window.matchMedia('(prefers-reduced-motion: reduce)').matches?'auto':'smooth'});$('d-pct').focus({preventScroll:true});});
+}
+let discountCueSignature='',discountCardSignature='';
+// Live refreshes re-render only when what a reader sees would change, and keep keyboard focus.
+function discountFocusKey(){
+ const active=document.activeElement;
+ if(!active?.dataset)return '';
+ return active.dataset.dremove?`dremove:${active.dataset.dremove}`:active.dataset.dtab?`dtab:${active.dataset.dtab}`:active.hasAttribute('data-open-discounts')?'open':'';
+}
+function restoreDiscountFocus(key){
+ if(!key)return;
+ const [kind,value]=key.split(':');
+ const target=kind==='dremove'?document.querySelector(`[data-dremove="${CSS.escape(value)}"]`):kind==='dtab'?document.querySelector(`[data-dtab="${CSS.escape(value)}"]`):document.querySelector('#discount-cue [data-open-discounts]');
+ target?.focus({preventScroll:true});
+}
+function renderDiscountCue(){
+ const cue=$('discount-cue'),active=discountActiveRules();
+ if(active.length)localStorage.removeItem(DISCOUNT_CUE_KEY);
+ const hidden=!discountSettings||(!active.length&&localStorage.getItem(DISCOUNT_CUE_KEY)==='1');
+ const signature=JSON.stringify([hidden,active.map(rule=>[rule.id,rule.price_list,rule.percent])]);
+ if(signature===discountCueSignature)return;
+ discountCueSignature=signature;
+ if(hidden){cue.hidden=true;return;}
+ const focus=discountFocusKey();
+ cue.hidden=false;cue.classList.toggle('active',active.length>0);
+ cue.innerHTML=active.length
+  ?`<div class=discountCueText><b>Spend includes your discounts</b><span class=discountCueList>${active.map(rule=>`<span class="badge ${(DISCOUNT_LISTS[rule.price_list]||['','other'])[1]}">${esc((DISCOUNT_LISTS[rule.price_list]||[rule.price_list])[0])} ${esc(rule.percent)}%</span>`).join('')}<span>Costs before discounts are shown beside each total.</span></span></div><div class=discountCueActions><button class=tbtn type=button data-open-discounts>Manage discounts</button></div>`
+  :`<div class=discountCueText><b>Spend uses public list prices.</b><span>Pay a negotiated or company rate? Add a discount so spend and budgets match your bill.</span></div><div class=discountCueActions><button class=discountLink type=button data-dismiss-discounts>Not now</button><button class="tbtn go" type=button data-open-discounts>Add a discount</button></div>`;
+ cue.querySelector('[data-open-discounts]').onclick=openDiscounts;
+ const dismiss=cue.querySelector('[data-dismiss-discounts]');
+ if(dismiss)dismiss.onclick=()=>{localStorage.setItem(DISCOUNT_CUE_KEY,'1');renderDiscountCue();};
+ restoreDiscountFocus(focus);
+}
+// After Remove, focus moves to the next row's Remove button, else the previous one, else the heading.
+async function removeDiscount(button){
+ const buttons=[...$('discount-rows').querySelectorAll('[data-dremove]')],index=buttons.indexOf(button);
+ const neighbours=[buttons[index+1],buttons[index-1]].filter(Boolean).map(item=>item.dataset.dremove);
+ const removed=await saveDiscountOps([{op:'delete',id:button.dataset.dremove}],button);
+ if(!removed)return;
+ const next=neighbours.map(id=>document.querySelector(`[data-dremove="${CSS.escape(id)}"]`)).find(Boolean);
+ (next||$('discount-title')).focus({preventScroll:true});
+}
+function discountRuleName(rule){
+ return `${(DISCOUNT_LISTS[rule.price_list]||[rule.price_list])[0]} ${rule.percent}% discount`;
+}
+function renderDiscounts(settings){
+ if(settings)discountSettings=settings;
+ const rules=discountSettings?.rules||[];
+ const invalid=Number(discountSettings?.invalid_rules||0),readOnly=discountSettings?.read_only===true;
+ const signature=JSON.stringify([discountSettings?.revision,discountTab,invalid,readOnly,rules.map(rule=>[rule.id,discountRuleState(rule)])]);
+ if(signature!==discountCardSignature){
+  discountCardSignature=signature;
+  const focus=discountFocusKey();
+  const counts={all:rules.length};
+  rules.forEach(rule=>{counts[rule.price_list]=(counts[rule.price_list]||0)+1;});
+  $('discount-tabs').innerHTML=['all',...Object.keys(DISCOUNT_LISTS)].map(id=>`<button type=button role=tab aria-selected=${id===discountTab} data-dtab=${id}>${id==='all'?'All':DISCOUNT_LISTS[id][0]}<span class=count>${counts[id]||0}</span></button>`).join('');
+  $('discount-tabs').querySelectorAll('[data-dtab]').forEach(button=>button.onclick=()=>{discountTab=button.dataset.dtab;renderDiscounts();});
+  const shown=rules.filter(rule=>discountTab==='all'||rule.price_list===discountTab);
+  $('discount-rows').innerHTML=shown.length?shown.map(rule=>{
+   const list=DISCOUNT_LISTS[rule.price_list]||[rule.price_list,'other'];
+   return `<tr><td data-label="Models from"><span class="badge ${list[1]}">${esc(list[0])}</span></td><td data-label="Billed by">${esc(DISCOUNT_OWN_LISTS.has(rule.price_list)?list[0]:DISCOUNT_BILLED[rule.channel]||rule.channel)}</td><td class="num mono" data-label="Discount">${esc(rule.percent)}%</td><td data-label="From">${rule.start!=null?esc(discountDay(rule.start)):'All past usage'}</td><td data-label="Until">${rule.end!=null?esc(discountDay(rule.end)):'No end'}</td><td data-label="Note"><div class=modelPriceModel>${esc(rule.label||'—')}<span class=modelPriceSource>${discountRuleState(rule)}</span><button class=modelPriceLifecycle type=button data-dremove="${esc(rule.id)}" aria-label="${esc(`Remove ${discountRuleName(rule)}`)}"${readOnly?' disabled':''}>Remove</button></div></td><td data-label="Set by"><span class=chip>${esc(rule.set_by||'')}</span></td></tr>`;
+  }).join(''):'<tr><td colspan=7 class=modelPricingEmpty>No discounts yet. Costs use public list prices.</td></tr>';
+  $('discount-rows').querySelectorAll('[data-dremove]').forEach(button=>button.onclick=()=>removeDiscount(button));
+  const active=discountActiveRules().length;
+  $('discount-badge').textContent=active?`${active} active`:'List prices';
+  const notes=[];
+  if(invalid)notes.push(`${invalid} saved ${invalid===1?'discount is':'discounts are'} invalid and ignored`);
+  if(readOnly)notes.push(discountSettings?.read_only_reason==='newer_version'?'Discounts were saved by a newer Token Meter. Update Token Meter to change them.':"Discounts in settings.json can't be changed by this version.");
+  $('discount-invalid').hidden=!notes.length;$('discount-invalid').textContent=notes.join(' · ');
+  $('d-add').disabled=readOnly;
+  document.querySelectorAll('[data-runtime-channel]').forEach(select=>{select.disabled=readOnly;});
+  restoreDiscountFocus(focus);
+ }
+ const channels=discountSettings?.runtime_channels||{};
+ document.querySelectorAll('[data-runtime-channel]').forEach(select=>{if(document.activeElement!==select)select.value=channels[select.dataset.runtimeChannel]||'auto';});
+ renderDiscountCue();
+}
+async function pollPricingRevision(target){
+ const seq=++discountPollSeq,deadline=Date.now()+10*60*1000;
+ while(seq===discountPollSeq&&Date.now()<deadline){
+  await new Promise(resolve=>setTimeout(resolve,1500));
+  try{
+   const health=await (await fetch('/health',{cache:'no-store'})).json();
+   if(health.pricing_revision===target){
+    if(seq!==discountPollSeq)return;
+    discountSay('All costs were recalculated.','good');
+    await refreshLiveState();
+    if(LATEST?.xsession)renderSpendView(LATEST.xsession);
+    return;
+   }
+  }catch(_error){/* The server may be busy recalculating; keep polling. */}
+ }
+}
+// /state carries discounts read fresh from settings; the snapshot's copy lags while history reprices.
+function adoptFreshDiscounts(state){
+ if(!state?.cost_discounts)return;
+ if(state.xsession)state.xsession.cost_discounts=state.cost_discounts;
+ else if(!discountEditInProgress())renderDiscounts(state.cost_discounts);
+}
+// Typing pauses live renders; clearing every add-row field again resumes them.
+function discountAddRowHasInput(){return DISCOUNT_ADD_FIELDS.some(id=>String($(id)?.value||'').trim()!=='');}
+const DISCOUNT_ADD_FIELDS=['d-pct','d-start','d-end','d-note'];
+$('discount-form').addEventListener('input',()=>{discountFormDirty=discountAddRowHasInput();});
+async function reloadDiscounts(){
+ const token=agentActionToken();
+ if(!token)return;
+ try{
+  const response=await fetch('/api/v1/cost-discounts',{headers:{'X-Token-Meter-Action':token},cache:'no-store'});
+  const settings=await response.json();
+  if(response.ok&&settings.ok){if(LATEST)LATEST.cost_discounts=settings;renderDiscounts(settings);}
+ }catch(_error){/* Keep the current view; the next live refresh carries fresh discounts. */}
+}
+async function saveDiscountOps(ops,button=null){
+ const token=agentActionToken();
+ if(!token){discountSay('Settings are not ready yet. Wait for live state and try again.','warn');return false;}
+ const original=button?.textContent;
+ if(button){button.disabled=true;button.textContent='Saving…';}
+ try{
+  const response=await fetch('/settings/cost-discounts',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({ops,expected_revision:discountSettings?.revision})});
+  const result=await response.json().catch(()=>({}));
+  if(!response.ok||!result.ok){
+   discountSay(result.error||'The discount could not be saved.','warn');
+   if(response.status===409)await reloadDiscounts();
+   return false;
+  }
+  discountSettings={...(discountSettings||{}),rules:result.rules,revision:result.revision};
+  if(LATEST?.xsession)LATEST.xsession.cost_discounts=discountSettings;
+  if(LATEST)LATEST.cost_discounts=discountSettings;
+  renderDiscounts();
+  if(!result.changed){discountSay('No changes to save.');return true;}
+  discountSay('Discount saved. Costs are being recalculated.');
+  pollPricingRevision(result.pricing_revision);
+  return true;
+ }catch(error){discountSay(error.message||String(error),'warn');return false;}
+ finally{if(button){button.disabled=false;button.textContent=original;}}
+}
+$('d-list').onchange=()=>{const own=DISCOUNT_OWN_LISTS.has($('d-list').value);$('d-channel').disabled=own;if(own)$('d-channel').value='any';};
+$('d-add').onclick=async()=>{
+ const percent=Number($('d-pct').value),start=$('d-start').value,end=$('d-end').value;
+ if(!(percent>0&&percent<100)){discountSay('Enter a discount above 0% and below 100%.','warn');return;}
+ if(start&&end&&start>=end){discountSay('"Until" must be after "From".','warn');return;}
+ const saved=await saveDiscountOps([{op:'upsert',rule:{price_list:$('d-list').value,channel:$('d-channel').value,percent,start:discountLocalMidnightIso(start),end:discountLocalMidnightIso(end),label:$('d-note').value.trim()}}],$('d-add'));
+ if(saved){discountFormDirty=false;$('d-pct').value='';$('d-start').value='';$('d-end').value='';$('d-note').value='';}
+};
+document.querySelectorAll('[data-runtime-channel]').forEach(select=>select.onchange=()=>saveDiscountOps([{op:'set_runtime_channels',[select.dataset.runtimeChannel]:select.value}]));
+$('discount-rotate').onclick=async()=>{
+ if(!confirm('Issue a new API token? Tools using the current token stop working until they read the new one.'))return;
+ const token=agentActionToken();
+ if(!token){discountSay('Settings are not ready yet. Wait for live state and try again.','warn');return;}
+ try{
+  const response=await fetch('/api/v1/api-token/rotate',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:'{}'});
+  const result=await response.json().catch(()=>({}));
+  if(!response.ok||!result.ok)throw new Error(result.error||'A new token could not be issued.');
+  discountSay('New token issued. Tools using the old token must read the new one.','warn');
+ }catch(error){discountSay(error.message||String(error),'warn');}
+};
diff --git a/dashboard/js/capabilities.js b/dashboard/js/capabilities.js
new file mode 100644
index 00000000..caf5fafb
--- /dev/null
+++ b/dashboard/js/capabilities.js
@@ -0,0 +1,498 @@
+const CAPABILITY_SORT_KEYS=new Set(['name','type','runtime','state','use','last','control']);
+const CAPABILITY_TYPES=new Set(['all','tool','mcp','skill']);
+const CAPABILITY_PAGE_SIZE=100;
+let capabilityType='all', capabilityState='all', capabilityRuntime='all', capabilitySearch='';
+let capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+let lastCapabilityReviewRevision='', lastCapabilityInventoryRevision='', capabilityLastGoodAt=0;
+let pendingCapabilityTable=null, pendingCapabilityReview=null, capabilityInventorySnapshot=null;
+let capabilityInventoryLoading=false, capabilitySearchTimer=null, capabilityEvidenceState='loading';
+const selectedCapabilityIds=new Set();
+const openCapabilityReviewIds=new Set();
+let capabilitySort=localStorage.getItem('tm_capability_sort')||'name';
+let capabilitySortDir=localStorage.getItem('tm_capability_sort_dir')||'asc';
+if(capabilitySort==='returned')capabilitySort='use';
+if(!CAPABILITY_SORT_KEYS.has(capabilitySort))capabilitySort='name';
+if(!['asc','desc'].includes(capabilitySortDir))capabilitySortDir='asc';
+function capabilityUseCount(row){ return row.type==='skill'?(row.activations||0):(row.calls||0); }
+function capabilityConfigurationText(row){
+ if(row.type==='tool')return row.configuration||'Unknown';
+ if(row.configuration)return row.configuration;
+ return row.enabled===true?'Enabled':row.enabled===false?'Disabled':'Unknown';
+}
+function capabilityEvidenceText(row){
+ const used=capabilityUseCount(row);
+ if(used)return 'Observed';
+ if(row.unmeasurable)return row.measurement==='instruction'?'Instruction-only':'Evidence unavailable';
+ if(row.type==='tool'&&row.advertised_sessions)return 'Definition observed';
+ return 'No use observed';
+}
+function capabilityControlText(row){
+ if(!row.mutable)return 'read-only';
+ const action=row.enabled?'Disable':'Enable';
+ return row.type==='skill'?`${action} pack`:action;
+}
+function capabilitySortValue(row,key){
+ if(key==='name')return row.name||row.identity||'';
+ if(key==='type')return {tool:'Tool',mcp:'MCP',skill:'Skill'}[row.type]||row.type||'';
+ if(key==='runtime')return [row.runtime,row.source,row.plugin_id,row.path].filter(Boolean).join(' · ');
+ if(key==='state')return capabilityConfigurationText(row);
+ if(key==='use')return Number(capabilityUseCount(row))||0;
+ if(key==='last'){
+  if(!row.last_used||row.last_used==='Never')return 0;
+  const parsed=Date.parse(row.last_used);
+  return Number.isFinite(parsed)?parsed:0;
+ }
+ if(key==='control')return capabilityControlText(row);
+ return '';
+}
+function compareCapabilityRows(a,b){
+ const av=capabilitySortValue(a,capabilitySort), bv=capabilitySortValue(b,capabilitySort);
+ const cmp=typeof av==='number'&&typeof bv==='number'
+  ? av-bv
+  : String(av).localeCompare(String(bv),undefined,{numeric:true,sensitivity:'base'});
+ return capabilitySortDir==='desc'?-cmp:cmp;
+}
+function paintCapabilitySort(){
+ [...$('c-table').querySelectorAll('th[data-csort]')].forEach(th=>{
+  const active=th.dataset.csort===capabilitySort;
+  th.classList.toggle('sort-asc',active&&capabilitySortDir==='asc');
+  th.classList.toggle('sort-desc',active&&capabilitySortDir==='desc');
+  th.setAttribute('aria-sort',active?(capabilitySortDir==='asc'?'ascending':'descending'):'none');
+  th.title=`Sort by ${th.textContent.trim()}${active?` (${capabilitySortDir==='asc'?'ascending':'descending'})`:''}`;
+ });
+ const mobile=$('c-mobile-sort'), choice=`${capabilitySort}:${capabilitySortDir}`;
+ if(mobile&&[...mobile.options].some(option=>option.value===choice))mobile.value=choice;
+}
+function setCapabilitySort(key){
+ if(!CAPABILITY_SORT_KEYS.has(key))return;
+ capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+ if(capabilitySort===key)capabilitySortDir=capabilitySortDir==='asc'?'desc':'asc';
+ else{
+  capabilitySort=key;
+  capabilitySortDir=['use','last'].includes(key)?'desc':'asc';
+ }
+ localStorage.setItem('tm_capability_sort',capabilitySort);
+ localStorage.setItem('tm_capability_sort_dir',capabilitySortDir);
+ paintCapabilitySort();
+ const inventory=currentCapabilityInventory();
+ if(inventory)renderCapabilityTable(inventory,{force:true});
+}
+function capabilityConfigurationClass(row){
+ if(row.enabled===null||row.enabled===undefined)return 'unknown';
+ return row.enabled?'on':'off';
+}
+function capabilityEvidenceClass(row){
+ if(capabilityUseCount(row))return 'observed';
+ if(row.unmeasurable)return 'unknown';
+ if(row.type==='tool'&&/Deferred|Mixed/.test(row.state||''))return 'lazy';
+ return 'unknown';
+}
+function capabilityAction(row){
+ if(!row.mutable) return '<span class=subline>read-only</span>';
+ const next=!row.enabled;
+ const label=row.type==='skill'?`${next?'Enable':'Disable'} pack`:(next?'Enable':'Disable');
+ const locked=capabilityEvidenceState!=='current';
+ return `<button class="capAction ${next?'':'disable'}" data-cap-id="${esc(row.id)}" ${locked?'disabled data-evidence-locked="1" title="Wait for current evidence before changing settings"':''}>${label}</button>`;
+}
+function currentCapabilitySummary(){return LATEST?.xsession?.capabilities||null;}
+function currentCapabilityInventory(){
+ const cap=currentCapabilitySummary();
+ if(!cap||!capabilityInventorySnapshot||capabilityInventorySnapshot.inventory_revision!==cap.inventory_revision)return null;
+ return {...cap,items:capabilityInventorySnapshot.items||[]};
+}
+function paintCapabilityFilters(){
+ [...$('c-type-filter').querySelectorAll('button')].forEach(button=>{
+  const on=capabilityType===button.dataset.ctype;
+  button.classList.toggle('on',on);
+  button.setAttribute('aria-pressed',String(on));
+ });
+ [...document.querySelectorAll('[data-cap-jump]')].forEach(button=>{
+  const on=capabilityType===button.dataset.capJump;
+  button.classList.toggle('on',on);
+  button.setAttribute('aria-pressed',String(on));
+ });
+ [...$('c-state-filter').querySelectorAll('button')].forEach(button=>{
+  const on=capabilityState===button.dataset.cstate;
+  button.classList.toggle('on',on);
+  button.setAttribute('aria-pressed',String(on));
+ });
+ const filters=[];
+ if(capabilityType!=='all')filters.push({key:'type',label:{tool:'Tools',mcp:'MCPs',skill:'Skills'}[capabilityType]||capabilityType});
+ if(capabilityState!=='all')filters.push({key:'state',label:{enabled:'Configured on',observed:'Observed',unused:'No use observed'}[capabilityState]});
+ if(capabilityRuntime!=='all')filters.push({key:'runtime',label:capabilityRuntime});
+ if(capabilitySearch.trim())filters.push({key:'search',label:`Search: ${capabilitySearch.trim()}`});
+ const active=$('c-active-filters');
+ active.hidden=!filters.length;
+ active.innerHTML=filters.length?`<span>Active</span>${filters.map(filter=>`<button type=button data-cap-clear="${filter.key}" aria-label="Remove ${esc(filter.label)} filter">${esc(filter.label)} <b aria-hidden=true>×</b></button>`).join('')}`:'';
+ $('c-clear-filters').hidden=!filters.length;
+ [...active.querySelectorAll('[data-cap-clear]')].forEach(button=>button.onclick=()=>clearCapabilityFilter(button.dataset.capClear));
+}
+function clearCapabilityFilter(key){
+ if(key==='type')capabilityType='all';
+ if(key==='state')capabilityState='all';
+ if(key==='runtime')capabilityRuntime='all';
+ if(key==='search'){capabilitySearch='';$('c-search').value='';}
+ capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+ paintCapabilityFilters();
+ const inventory=currentCapabilityInventory();
+ if(inventory)renderCapabilityTable(inventory,{force:true});
+}
+function clearCapabilityFilters(){
+ capabilityType='all';capabilityState='all';capabilityRuntime='all';capabilitySearch='';capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+ $('c-search').value='';
+ paintCapabilityFilters();
+ const inventory=currentCapabilityInventory();
+ if(inventory)renderCapabilityTable(inventory,{force:true});
+}
+function capabilityPackName(row){
+ const value=String(row?.plugin_id||row?.name||'Skill pack');
+ return value.split('@')[0]||value;
+}
+function capabilityGroupFingerprint(row){
+ return JSON.stringify([
+  row?.id||'',Boolean(row?.enabled),Boolean(row?.used),Boolean(row?.unmeasurable),
+  row?.measurement||'',row?.runtime||'',row?.plugin_id||'',row?.setting_path||'',
+  Number(row?.scanned_sessions||0),
+  Number(row?.unused_eager_definition_tokens||0),[...(row?.members||[])].sort()
+ ]);
+}
+function updateCapabilitySelection(cap){
+ const valid=new Set(unusedReviewGroups(cap).map(row=>row.id));
+ [...selectedCapabilityIds].forEach(id=>{if(!valid.has(id))selectedCapabilityIds.delete(id);});
+ const button=$('c-disable-selected'), count=selectedCapabilityIds.size;
+ $('c-selection-bar').hidden=!count;
+ $('c-selection-count').textContent=`${f(count)} ${countWord(count,'pack')} selected`;
+ button.disabled=!count||capabilityEvidenceState!=='current';
+ button.textContent='Disable selected…';
+ button.title=capabilityEvidenceState==='current'?'Review exact controls before disabling':'Wait for current evidence before changing settings';
+}
+function clearCapabilitySelection(){
+ selectedCapabilityIds.clear();
+ [...$('c-review-list').querySelectorAll('[data-cap-select]')].forEach(input=>{input.checked=false;});
+ updateCapabilitySelection(currentCapabilitySummary());
+}
+function renderCapabilityReviewQueue(cap,{force=false}={}){
+ if(!cap)return;
+ const groups=unusedReviewGroups(cap), optional=cap?.summary?.optional||{};
+ const revision=String(cap.review_revision||JSON.stringify([
+  optional.review_candidates||[],groups.map(capabilityGroupFingerprint)
+ ]));
+ updateCapabilitySelection(cap);
+ if(!force&&revision===lastCapabilityReviewRevision)return;
+ const queue=$('c-review-list');
+ const queueBusy=queue.matches(':hover')||queue.contains(document.activeElement);
+ if(queueBusy&&!force){pendingCapabilityReview=cap;return;}
+ pendingCapabilityReview=null;
+ const panel=$('c-review-queue');
+ panel.classList.toggle('warn',groups.length>0);
+ panel.classList.toggle('good',groups.length===0);
+ $('c-review-title').textContent=groups.length?'Needs review':'Nothing needs review';
+ const runtimes=[...new Set(groups.map(row=>row.runtime||'Runtime'))];
+ const sharedRuntime=runtimes.length===1?runtimes[0]:'';
+ const restartNote=runtime=>`Restart ${runtime} to apply. Re-enable from All capabilities.`;
+  $('c-review-detail').textContent=groups.length
+  ? `No observed use means review, not proof of disuse.${sharedRuntime?` ${restartNote(sharedRuntime)}`:''}`
+  : `${f((optional.instruction_packs||0)+(optional.unknown_evidence_packs||0)+(optional.unscanned_packs||0))} ${countWord((optional.instruction_packs||0)+(optional.unknown_evidence_packs||0)+(optional.unscanned_packs||0),'pack')} excluded for missing use or coverage evidence.`;
+ $('c-review-count').textContent=groups.length?`${f(groups.length)} user-installed ${countWord(groups.length,'pack')}`:'Queue clear';
+ const head=`<div class=capReviewHead aria-hidden=true><span class=capReviewCols><span>Pack</span><span>Observed use</span><span>Prompt load</span><span>Affected</span><span>Status</span></span><span>Select</span></div>`;
+ queue.innerHTML=groups.length?head+groups.map(row=>{
+  const members=row.members||[], scanned=Number(row.scanned_sessions||0);
+  const overhead=Number(row.unused_eager_definition_tokens||0);
+  const runtime=row.runtime||'Runtime', setting=row.setting_path||'runtime plugin settings';
+  const name=capabilityPackName(row), affected=`${f(members.length)} ${countWord(members.length,'skill')}`;
+  const use=`0 uses · ${f(scanned)} ${countWord(scanned,'log')}`;
+  const loadDetail=overhead?`Est. ${f(overhead)} avoidable definition tokens`:'Not measured';
+  const load=overhead?`≈${compactNumber(overhead)} tokens`:'—';
+  const memberChips=members.map(member=>`<span>${esc(member)}</span>`).join('');
+  const label=`${name}, ${runtime}, ${use}, prompt load ${loadDetail.toLowerCase()}, ${affected}, no use observed`;
+  return `<article class=capReviewItem data-cap-review-id="${esc(row.id)}"><details class=capReviewRow data-cap-review-open="${esc(row.id)}"${openCapabilityReviewIds.has(row.id)?' open':''}><summary class=capReviewCols aria-label="${esc(label)}"><span class=capReviewName><strong>${esc(name)}</strong><span>${esc(runtime)} · User-installed</span></span><span class=capReviewNum>${esc(use)}</span><span class=capReviewNum title="${esc(loadDetail)}">${esc(load)}</span><span class=capReviewNum>${esc(affected)}</span><span class="stateDot unknown">No use observed</span></summary><div class=capReviewDisclosureBody><dl class=capReviewFacts><div><dt>Observed use</dt><dd>0 activations · ${f(scanned)} ${esc(runtime)} ${countWord(scanned,'log')}</dd></div><div><dt>Prompt-load impact</dt><dd>${esc(loadDetail)}</dd></div><div><dt>Affected</dt><dd>${affected}</dd></div></dl>${sharedRuntime?'':`<p class=capReviewImpact>${esc(restartNote(runtime))}</p>`}<div><b>Affected skills</b><div class=capReviewMembers>${memberChips||'<span>No member names available</span>'}</div></div><div>${overhead?'The avoidable-load estimate is the cumulative runtime-reported definition evidence across the scanned logs, not a per-prompt saving.':'Prompt saving is not measurable from the available evidence; this is only an activation review.'}</div><div><b>Exact control</b><div class=capReviewControl>${esc(row.id)}</div></div><div><b>Setting</b><div class=capReviewControl>${esc(setting)}</div></div></div></details><label class=capSelect><input type=checkbox data-cap-select="${esc(row.id)}" aria-label="Select ${esc(name)}" ${selectedCapabilityIds.has(row.id)?'checked':''}><span>Select</span></label></article>`;
+ }).join(''):`<div class=capQueueEmpty><h3>No candidate requires a decision</h3><p>Only packs with reliable activation evidence appear here.</p><button class=tbtn type=button data-cap-browse>Browse all capabilities</button></div>`;
+ lastCapabilityReviewRevision=revision;
+ [...queue.querySelectorAll('[data-cap-review-open]')].forEach(details=>details.addEventListener('toggle',()=>{
+  if(details.open)openCapabilityReviewIds.add(details.dataset.capReviewOpen);else openCapabilityReviewIds.delete(details.dataset.capReviewOpen);
+ }));
+ [...queue.querySelectorAll('[data-cap-select]')].forEach(input=>input.onchange=()=>{
+  if(input.checked)selectedCapabilityIds.add(input.dataset.capSelect);else selectedCapabilityIds.delete(input.dataset.capSelect);
+  updateCapabilitySelection(cap);
+ });
+ queue.querySelector('[data-cap-browse]')?.addEventListener('click',()=>openCapabilityInventory());
+ updateCapabilitySelection(cap);
+}
+function renderCapabilityTable(cap,{force=false}={}){
+ if(!cap)return;
+ const tableBusy=$('c-table').matches(':hover')||$('c-table').contains(document.activeElement);
+ if(tableBusy&&!force){pendingCapabilityTable=cap;return;}
+ pendingCapabilityTable=null;
+ const all=cap?.items||[];
+ const runtimes=[...new Set(all.map(row=>row.runtime).filter(Boolean))].sort((a,b)=>a.localeCompare(b));
+ if(capabilityRuntime!=='all'&&!runtimes.includes(capabilityRuntime))capabilityRuntime='all';
+ $('c-runtime-filter').innerHTML='<option value="all">All runtimes</option>'+runtimes.map(runtime=>`<option value="${esc(runtime)}">${esc(runtime)}</option>`).join('');
+ $('c-runtime-filter').value=capabilityRuntime;
+ const q=capabilitySearch.trim().toLowerCase();
+ const rows=all.filter(row=>{
+  if(capabilityType!=='all'&&row.type!==capabilityType)return false;
+  if(capabilityRuntime!=='all'&&row.runtime!==capabilityRuntime)return false;
+  if(capabilityState==='enabled'&&row.enabled!==true)return false;
+  if(capabilityState==='observed'&&!capabilityUseCount(row))return false;
+  if(capabilityState==='unused'&&(row.used||row.unmeasurable))return false;
+  if(q&&![row.name,row.identity,row.runtime,row.source,row.plugin_id,row.path,row.state].join(' ').toLowerCase().includes(q))return false;
+  return true;
+ }).map((row,index)=>({row,index})).sort((a,b)=>compareCapabilityRows(a.row,b.row)||a.index-b.index).map(item=>item.row);
+ const visibleRows=rows.slice(0,capabilityVisibleLimit);
+ $('c-filter-count').textContent=rows.length===visibleRows.length?`${f(rows.length)} shown · ${f(all.length)} discovered`:`${f(visibleRows.length)} of ${f(rows.length)} matches shown · ${f(all.length)} discovered`;
+ $('c-table').querySelector('tbody').innerHTML=rows.length?visibleRows.map(row=>{
+  const source=[row.runtime,row.source].filter(Boolean).join(' · ');
+  const detail=row.path?`<div class=capPath title="${esc(row.path)}">${esc(row.path)}</div>`:(row.plugin_id?`<div class=capPath>${esc(row.plugin_id)}</div>`:'');
+  const identifier=row.type==='skill'?`<div class=capPath title="${esc(row.id)}">${esc(row.id)}</div>`:'';
+  const configuration=capabilityConfigurationText(row), evidence=capabilityEvidenceText(row);
+  const typeLabel=row.control_type==='skill_pack'?'Skill pack':({tool:'Tool',mcp:'MCP',skill:'Skill'}[row.type]||row.type);
+  const use=capabilityUseCount(row);
+  const evidenceDetail=row.unmeasurable
+   ? (row.measurement==='instruction'?'Use cannot be inferred from instruction text.':'No reliable activation evidence is available.')
+   : `${f(use)} ${countWord(use,row.type==='skill'?'activation':'call')}${row.nested_calls?` (${f(row.nested_calls)} ${countWord(row.nested_calls,'code-mode call site')})`:''}${row.type==='skill'?'':` · ${f(row.returned_tokens||0)} returned tokens`}`;
+  return `<tr><td class=nm data-label="Capability">${esc(row.name)}${row.identity&&row.identity!==row.name?`<div class=capPath>${esc(row.identity)}</div>`:''}${identifier}</td><td data-label="Type"><span class="chip ${row.type==='mcp'?'mcp':''}">${typeLabel}</span></td><td data-label="Runtime / source">${esc(source)}${detail}</td><td data-label="Configuration"><span class="stateDot ${capabilityConfigurationClass(row)}">${esc(configuration)}</span>${row.type==='mcp'?`<div class=capPath>${row.configured===false?(row.calls?'Observed in traces; not in Codex or Claude config':'Advertised in traces; not in Codex or Claude config'):`Codex ${row.codex_enabled?'on':'off'} · Claude ${row.claude_enabled?'on':'off'}`}</div>`:''}</td><td data-label="Evidence"><div class=capEvidence><strong><span class="stateDot ${capabilityEvidenceClass(row)}">${esc(evidence)}</span></strong><small>${esc(evidenceDetail)}</small></div></td><td data-label="Last observed">${esc(row.last_used||'Never')}</td><td data-label="Control">${capabilityAction(row)}</td></tr>`;
+ }).join('')+(visibleRows.length<rows.length?`<tr><td colspan=7 class=capMore><button class=tbtn type=button data-cap-more>Show next ${f(Math.min(CAPABILITY_PAGE_SIZE,rows.length-visibleRows.length))}</button></td></tr>`:''):`<tr><td colspan=7 class=capEmpty>No capabilities match these filters.<button class=tbtn type=button data-cap-clear>Clear filters</button></td></tr>`;
+ lastCapabilityInventoryRevision=String(cap.inventory_revision||cap.revision||'');
+ paintCapabilitySort();
+ paintCapabilityFilters();
+ [...$('c-table').querySelectorAll('[data-cap-id]')].forEach(button=>button.onclick=()=>{
+  const item=all.find(row=>row.id===button.dataset.capId);
+  const group=(cap?.control_groups||[]).find(row=>row.id===(item?.control_id||item?.id));
+  requestCapabilityToggle(group?{...item,...group,id:item.id,control_id:group.id}:item,cap);
+ });
+ $('c-table').querySelector('[data-cap-clear]')?.addEventListener('click',clearCapabilityFilters);
+ $('c-table').querySelector('[data-cap-more]')?.addEventListener('click',()=>{capabilityVisibleLimit+=CAPABILITY_PAGE_SIZE;renderCapabilityTable(cap,{force:true});});
+}
+$('c-table').addEventListener('pointerleave',()=>{if(pendingCapabilityTable)renderCapabilityTable(pendingCapabilityTable,{force:true});});
+$('c-table').addEventListener('focusout',()=>requestAnimationFrame(()=>{if(pendingCapabilityTable&&!$('c-table').contains(document.activeElement))renderCapabilityTable(pendingCapabilityTable,{force:true});}));
+$('c-review-list').addEventListener('pointerleave',()=>{if(pendingCapabilityReview)renderCapabilityReviewQueue(pendingCapabilityReview,{force:true});});
+$('c-review-list').addEventListener('focusout',()=>requestAnimationFrame(()=>{if(pendingCapabilityReview&&!$('c-review-list').contains(document.activeElement))renderCapabilityReviewQueue(pendingCapabilityReview,{force:true});}));
+function openCapabilityInventory(type='all'){
+ capabilityType=CAPABILITY_TYPES.has(type)?type:'all';
+ capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+ paintCapabilityFilters();
+ const inventory=currentCapabilityInventory();
+ if(inventory)renderCapabilityTable(inventory,{force:true});else loadCapabilityInventory({force:true});
+ $('c-inventory').scrollIntoView({behavior:'smooth',block:'start'});
+ requestAnimationFrame(()=>$('c-inventory-title').focus({preventScroll:true}));
+}
+async function loadCapabilityInventory({force=false}={}){
+ if(capabilityInventoryLoading)return;
+ const cap=currentCapabilitySummary();
+ if(!cap)return;
+ if(!force&&capabilityInventorySnapshot&&capabilityInventorySnapshot.inventory_revision===cap.inventory_revision){
+  renderCapabilityTable(currentCapabilityInventory());
+  return;
+ }
+ capabilityInventoryLoading=true;
+ $('c-filter-count').textContent='Loading inventory…';
+ $('c-table').querySelector('tbody').innerHTML='<tr><td colspan=7 class=capEmpty>Loading local capability inventory…</td></tr>';
+ try{
+  const response=await fetch('/capabilities/inventory',{cache:'no-store'});
+  const result=await response.json();
+  if(!response.ok||!result.ok||!Array.isArray(result.items))throw new Error('Capability inventory could not be loaded.');
+  capabilityInventorySnapshot=result;
+  const merged=currentCapabilityInventory();
+  if(merged)renderCapabilityTable(merged,{force});
+ }catch(error){
+  $('c-filter-count').textContent='Inventory unavailable';
+  $('c-table').querySelector('tbody').innerHTML='<tr><td colspan=7 class=capEmpty>Inventory could not be loaded.<button class=tbtn type=button data-cap-retry>Retry</button></td></tr>';
+  $('c-table').querySelector('[data-cap-retry]')?.addEventListener('click',()=>loadCapabilityInventory({force:true}));
+ }finally{capabilityInventoryLoading=false;}
+}
+let pendingCapabilityAction=null;
+function requestCapabilityToggle(row,cap){
+ if(!row||!row.mutable||capabilityEvidenceState!=='current')return;
+ const enabled=!row.enabled, members=row.members||[row.name], shown=members.slice(0,8);
+ const controlId=row.control_id||row.id;
+ pendingCapabilityAction={row,controlId,fingerprint:capabilityGroupFingerprint({...row,id:controlId})};
+ $('cap-dialog-title').textContent=`${enabled?'Enable':'Disable'} skill pack?`;
+ $('cap-dialog-sub').textContent=`${row.runtime} · ${row.plugin_id} · ${row.source||row.origin||'configured plugin'}`;
+ $('cap-dialog-evidence').innerHTML=`<div>This changes the entire pack, not only ${esc(row.name)}.</div><div>${f(members.length)} affected ${countWord(members.length,'skill')}: ${esc(shown.join(', '))}${members.length>shown.length?` and ${f(members.length-shown.length)} more`:''}</div>`;
+ $('cap-dialog-control').textContent=controlId;
+ $('cap-dialog-setting').textContent=`The persisted ${row.setting_path||'runtime setting'} will be read back and verified before success is reported. Restart the IDE or agent afterward.`;
+ const button=$('cap-confirm');
+ button.disabled=false; button.textContent=`${enabled?'Enable':'Disable'} pack`;
+ button.classList.toggle('danger',!enabled);
+ $('cap-dialog').showModal();
+}
+$('cap-cancel').onclick=()=>{$('cap-dialog').close();pendingCapabilityAction=null;};
+$('cap-dialog').addEventListener('cancel',()=>{pendingCapabilityAction=null;});
+$('cap-confirm').onclick=()=>{
+ if(!pendingCapabilityAction)return;
+ const {row,controlId,fingerprint}=pendingCapabilityAction, cap=currentCapabilitySummary();
+ const group=(cap?.control_groups||[]).find(item=>item.id===controlId);
+ if(capabilityEvidenceState!=='current'||!group||capabilityGroupFingerprint(group)!==fingerprint){
+  $('cap-dialog').close();pendingCapabilityAction=null;
+  showAppToast({title:'Capability state changed',body:'The exact control or its evidence changed while confirmation was open. Reopen it from the current inventory.',kind:'warn',sticky:true});
+  return;
+ }
+ toggleCapability({...row,...group,id:row.id,control_id:controlId},cap,$('cap-confirm'));
+};
+function applyCapabilitySnapshot(freshCap){
+ if(!freshCap)return;
+ if(LATEST?.xsession)LATEST.xsession.capabilities=freshCap;
+ if(CURRENT?.xsession)CURRENT.xsession.capabilities=freshCap;
+ renderCapabilities(freshCap,{force:true});
+}
+async function toggleCapability(row,cap,confirmButton=null){
+ if(!row||!row.mutable||capabilityEvidenceState!=='current')return;
+ const enabled=!row.enabled;
+ const controlId=row.control_id||row.id;
+ const payload={type:row.type,enabled,control_id:controlId};
+ const buttons=[...document.querySelectorAll(`[data-cap-id="${CSS.escape(row.id)}"]`)];
+ buttons.forEach(button=>{button.disabled=true;button.textContent=enabled?'Enabling…':'Disabling…';});
+ if(confirmButton){confirmButton.disabled=true;confirmButton.textContent=enabled?'Enabling…':'Disabling…';}
+ try{
+  const response=await fetch('/capability/toggle',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':cap.actions.token},body:JSON.stringify(payload)});
+  const result=await response.json();
+  if(!response.ok||!result.ok)throw new Error(result.error||'Capability change failed.');
+  (cap.items||[]).forEach(item=>{
+   if(item.id===row.id||item.control_id===controlId){
+    item.enabled=enabled; item.state=enabled?'Enabled':'Disabled';
+   }
+  });
+  (cap.control_groups||[]).forEach(group=>{if(group.id===controlId)group.enabled=enabled;});
+  let freshCap=result.capabilities||cap;
+  if(!result.capabilities)try{
+   const fresh=await fetch('/state',{cache:'no-store'}).then(response=>response.json());
+   if(fresh?.xsession?.capabilities){adoptFreshDiscounts(fresh);LATEST=fresh;if(!pinned)CURRENT=fresh;freshCap=fresh.xsession.capabilities;}
+  }catch(_error){}
+  if(result.capabilities)applyCapabilitySnapshot(freshCap);
+  if(confirmButton){$('cap-dialog').close();pendingCapabilityAction=null;}
+  if(!result.capabilities)renderCapabilities(freshCap,{force:true});
+  const verified=result.verified?' Setting verified.':'';
+  showAppToast({title:`Skill pack ${enabled?'enabled':'disabled'}`,body:`${row.plugin_id} changed for future sessions.${verified} Restart the IDE or agent to load the change.`,kind:enabled?'neutral':'warn',sticky:true});
+ }catch(error){
+  buttons.forEach(button=>{button.disabled=false;});
+  if(confirmButton){confirmButton.disabled=false;confirmButton.textContent=`${enabled?'Enable':'Disable'} pack`;}
+  showAppToast({title:'Capability change failed',body:error.message||String(error),kind:'warn',sticky:true});
+  const inventory=currentCapabilityInventory();
+  if(inventory)renderCapabilityTable(inventory,{force:true});
+ }
+}
+let pendingBulkDisable=null;
+function unusedReviewGroups(cap){
+ const ids=new Set(cap?.summary?.optional?.review_candidates||[]);
+ return (cap?.control_groups||[]).filter(row=>ids.has(row.id)&&row.reviewable!==false&&row.mutable&&row.enabled&&!row.used&&!row.unmeasurable&&Number(row.scanned_sessions||0)>0);
+}
+function openSelectedDisableDialog(cap){
+ if(capabilityEvidenceState!=='current')return;
+ const groups=unusedReviewGroups(cap).filter(row=>selectedCapabilityIds.has(row.id));
+ if(!groups.length)return;
+ const controlIds=groups.map(row=>row.id);
+ pendingBulkDisable={controlIds,fingerprints:Object.fromEntries(groups.map(row=>[row.id,capabilityGroupFingerprint(row)]))};
+ const affected=groups.reduce((total,row)=>total+(row.members||[]).length,0);
+ const measured=groups.reduce((total,row)=>total+Number(row.unused_eager_definition_tokens||0),0);
+ const coverage=[...new Map(groups.map(row=>[row.runtime||'Runtime',Number(row.scanned_sessions||0)])).entries()].map(([runtime,count])=>`${f(count)} ${runtime} ${countWord(count,'log')}`).join(' · ');
+ $('bulk-dialog-sub').textContent=`${f(groups.length)} selected ${countWord(groups.length,'skill pack')} will be disabled`;
+ $('bulk-dialog-evidence').innerHTML=`<div>${f(affected)} affected ${countWord(affected,'skill')} · evidence from ${esc(coverage)}</div><div>Estimated avoidable prompt load across scanned logs: ${measured?`${f(measured)} definition tokens`:'not measured'}. This is not a per-prompt saving. Restart each affected runtime after the change; packs can be re-enabled from All capabilities.</div><div>MCP servers, runtime packs, built-ins, standalone skills, and used groups are excluded.</div>`;
+ $('bulk-dialog-controls').textContent=controlIds.join('\n');
+ $('bulk-confirm').disabled=false;
+ $('bulk-confirm').textContent='Disable selected';
+ $('bulk-dialog').showModal();
+}
+$('bulk-cancel').onclick=()=>{$('bulk-dialog').close();pendingBulkDisable=null;};
+$('bulk-dialog').addEventListener('cancel',()=>{pendingBulkDisable=null;});
+$('bulk-confirm').onclick=async()=>{
+ if(!pendingBulkDisable)return;
+ const {controlIds,fingerprints}=pendingBulkDisable, button=$('bulk-confirm');
+ const cap=currentCapabilitySummary(), current=new Map(unusedReviewGroups(cap).map(row=>[row.id,row]));
+ const groups=controlIds.map(id=>current.get(id));
+ const changed=capabilityEvidenceState!=='current'||groups.some((row,index)=>!row||capabilityGroupFingerprint(row)!==fingerprints[controlIds[index]]);
+ if(changed){
+  $('bulk-dialog').close();pendingBulkDisable=null;
+  renderCapabilityReviewQueue(cap,{force:true});
+  showAppToast({title:'Review evidence changed',body:'The selected controls or their evidence changed while confirmation was open. Review the current receipts before trying again.',kind:'warn',sticky:true});
+  return;
+ }
+ button.disabled=true;button.textContent='Disabling…';
+ try{
+  const response=await fetch('/capability/disable-unused',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':cap.actions.token},body:JSON.stringify({control_ids:controlIds})});
+  const result=await response.json();
+  if(result.capabilities)applyCapabilitySnapshot(result.capabilities);
+  if(!response.ok||!result.ok){
+   if(result.partial){
+    $('bulk-dialog').close();pendingBulkDisable=null;
+    selectedCapabilityIds.clear();
+    (result.failures||[]).forEach(row=>{if(row.control_id)selectedCapabilityIds.add(row.control_id);});
+    renderCapabilityReviewQueue(currentCapabilitySummary(),{force:true});
+    const names=(result.failures||[]).map(row=>row.name).slice(0,4).join(', ');
+    showAppToast({title:'Some groups could not be disabled',body:`${f(result.changed)} changed; ${f((result.failures||[]).length)} failed${names?`: ${names}`:''}.`,kind:'warn',sticky:true});
+    return;
+   }
+   throw new Error(result.error||'Unused capabilities could not be disabled.');
+  }
+  $('bulk-dialog').close();pendingBulkDisable=null;
+  selectedCapabilityIds.clear();
+  showAppToast({title:'Selected packs disabled',body:`${f(result.changed)} packs changed and verified. Restart the IDE or agent to load the changes.`,kind:'warn',sticky:true});
+ }catch(error){
+  button.disabled=false;button.textContent='Disable selected';
+  showAppToast({title:'Selected capability change failed',body:error.message||String(error),kind:'warn',sticky:true});
+ }
+};
+function setCapabilityAvailability(state){
+ capabilityEvidenceState=state;
+ if(state!=='current'){
+  [...document.querySelectorAll('#c-table [data-cap-id]')].forEach(button=>{button.disabled=true;button.dataset.evidenceLocked='1';});
+  $('c-disable-selected').disabled=true;
+  let closedConfirmation=false;
+  if($('bulk-dialog').open&&!/ing…$/.test($('bulk-confirm').textContent)){$('bulk-dialog').close();pendingBulkDisable=null;closedConfirmation=true;}
+  else if($('bulk-dialog').open)$('bulk-confirm').disabled=true;
+  if($('cap-dialog').open&&!/ing…$/.test($('cap-confirm').textContent)){$('cap-dialog').close();pendingCapabilityAction=null;closedConfirmation=true;}
+  else if($('cap-dialog').open)$('cap-confirm').disabled=true;
+  if(closedConfirmation)showAppToast({title:'Confirmation closed',body:'Capability evidence became stale. Wait for a current snapshot, then review the exact control again.',kind:'warn',sticky:true});
+ }else{
+  [...document.querySelectorAll('#c-table [data-evidence-locked]')].forEach(button=>{delete button.dataset.evidenceLocked;if(!/ing…$/.test(button.textContent))button.disabled=false;});
+  updateCapabilitySelection(currentCapabilitySummary());
+ }
+}
+function renderCapabilities(cap,{force=false}={}){
+ if(!cap){setCapabilityAvailability('unavailable');return;}
+ capabilityLastGoodAt=Date.now();
+ setCapabilityAvailability('current');
+ const sum=cap.summary||{}, defs=sum.definitions||{}, optional=sum.optional||{};
+ const tools=sum.tools||{}, mcps=sum.mcps||{}, skills=sum.skills||{};
+ $('c-stat-tools').textContent=f(tools.available||0);
+ $('c-stat-tools-detail').textContent=`${f(tools.observed||0)} observed`;
+ $('c-stat-mcps').textContent=f(mcps.available||0);
+ $('c-stat-mcps-detail').textContent=`${f(mcps.enabled||0)} configured on · ${f(mcps.historically_used||0)} observed`;
+ $('c-stat-skills').textContent=f(skills.available||0);
+ $('c-stat-skills-detail').textContent=`${f(skills.enabled||0)} enabled · ${f(skills.historically_used||skills.used||0)} activated`;
+ const inventoryCount=Number(cap.inventory_count??(cap.items||[]).length);
+ $('c-inventory-count').textContent=`${f(inventoryCount)} ${countWord(inventoryCount,'capability','capabilities')}`;
+ const eager=defs.eager_definition_tokens||0, unused=defs.unused_eager_definition_tokens||0, deferred=defs.deferred_definition_tokens||0, total=defs.definition_tokens||0, useful=Math.max(0,eager-unused);
+ const denom=Math.max(1,total);
+ $('c-def-chart').innerHTML=`<i class=used style="width:${100*useful/denom}%"></i><i class=unused style="width:${100*unused/denom}%"></i><i class=deferred style="width:${100*deferred/denom}%"></i>`;
+ $('c-def-legend').innerHTML=`<span><i class=dot style="background:var(--good)"></i>useful eager ${f(useful)}</span><span><i class=dot style="background:var(--warn)"></i>unused eager ${f(unused)}</span><span><i class=dot style="background:rgb(var(--signal-hi-rgb)/.42)"></i>deferred ${f(deferred)}</span>`;
+ $('c-def-note').textContent=total?`${f(total)} schema tokens · evidence only`:'No prompt-load token evidence';
+ renderCapabilityReviewQueue(cap,{force});
+ const revision=String(cap.inventory_revision||'');
+ if(capabilityInventorySnapshot&&capabilityInventorySnapshot.inventory_revision===revision){
+  if(force||lastCapabilityInventoryRevision!==revision)renderCapabilityTable(currentCapabilityInventory(),{force});
+ }else loadCapabilityInventory({force});
+}
+$('c-search').oninput=e=>{
+ capabilitySearch=e.target.value;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+ clearTimeout(capabilitySearchTimer);
+ capabilitySearchTimer=setTimeout(()=>{const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});},120);
+};
+$('c-type-filter').onclick=e=>{if(!e.target.dataset.ctype)return;capabilityType=e.target.dataset.ctype;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;paintCapabilityFilters();const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});};
+$('c-state-filter').onclick=e=>{if(!e.target.dataset.cstate)return;capabilityState=e.target.dataset.cstate;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;paintCapabilityFilters();const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});};
+$('c-runtime-filter').onchange=e=>{capabilityRuntime=e.target.value;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});};
+$('c-clear-filters').onclick=clearCapabilityFilters;
+[...document.querySelectorAll('[data-cap-jump]')].forEach(button=>button.onclick=()=>openCapabilityInventory(button.dataset.capJump));
+$('c-clear-selection').onclick=clearCapabilitySelection;
+$('c-disable-selected').onclick=()=>openSelectedDisableDialog(currentCapabilitySummary());
+$('c-table').querySelector('thead').onclick=e=>{const th=e.target.closest('th[data-csort]');if(th)setCapabilitySort(th.dataset.csort);};
+$('c-table').querySelector('thead').onkeydown=e=>{if(!['Enter',' '].includes(e.key))return;const th=e.target.closest('th[data-csort]');if(!th)return;e.preventDefault();setCapabilitySort(th.dataset.csort);};
+$('c-mobile-sort').onchange=e=>{
+ const [key,dir]=e.target.value.split(':');
+ if(!CAPABILITY_SORT_KEYS.has(key)||!['asc','desc'].includes(dir))return;
+ capabilitySort=key;capabilitySortDir=dir;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
+ localStorage.setItem('tm_capability_sort',capabilitySort);localStorage.setItem('tm_capability_sort_dir',capabilitySortDir);
+ paintCapabilitySort();const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});
+};
+paintCapabilityFilters();
+paintCapabilitySort();
+
diff --git a/dashboard/js/charts.js b/dashboard/js/charts.js
new file mode 100644
index 00000000..d0f135f4
--- /dev/null
+++ b/dashboard/js/charts.js
@@ -0,0 +1,393 @@
+const cssVar=name=>getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+// viewBox font size that renders at least `px` CSS pixels in a scaled SVG; never shrinks text.
+const svgTextPx=(svg,VW,VH,px=11)=>{const box=svg.getBoundingClientRect(),scale=Math.min(box.width/VW||1,box.height/VH||1);return +(px/Math.min(1,scale)).toFixed(1);};
+const tint=(name,alpha)=>`rgb(${cssVar(`--${name}-rgb`)}/${alpha})`;
+const CHART={};
+function readChartTokens(){Object.assign(CHART,{
+ ink:cssVar('--bg'),input:cssVar('--c-input'),output:cssVar('--c-output'),tool:cssVar('--toolcall'),side:cssVar('--signal-mid'),
+ cacheRead:cssVar('--c-cache-read'),cacheWrite:cssVar('--c-cache-write'),cost:cssVar('--c-cost'),context:cssVar('--c-context'),
+ reason:cssVar('--reason'),muted:tint('tint',.26),
+ costFill:cssVar('--chart-cost-fill'),
+ axis:cssVar('--chart-axis'),grid:cssVar('--chart-grid'),lbl:cssVar('--chart-label'),
+ tip:cssVar('--chart-tip'),tipHead:cssVar('--chart-tip-head'),tipLine:cssVar('--chart-tip-line')
+});}
+readChartTokens();
+function scaledY(v,maxV){
+ if(maxV<=0)return 1;
+ return Math.max(0,v)/maxV;
+}
+function integerTicks(maxV){
+ const top=Math.max(1,Math.ceil(maxV||1));
+ if(top<=6) return Array.from({length:top+1},(_,i)=>i);
+ const raw=top/4, pow=10**Math.floor(Math.log10(raw));
+ const n=raw/pow;
+ const step=(n<=1?1:n<=2?2:n<=5?5:10)*pow;
+ const hi=Math.ceil(top/step)*step, out=[];
+ for(let v=0;v<=hi;v+=step) out.push(v);
+ return out;
+}
+function ticks(maxV){
+ return [0,.25,.5,.75,1].map(x=>x*maxV);
+}
+function moneyTick(n){
+ return money(n);
+}
+function tipAttrs(text){
+ const safe=esc(text);
+ return `class=fieldtip tabindex=0 aria-description="${safe}" data-tip="${safe}"`;
+}
+function legendField(label,color,tip){
+ return `<span ${tipAttrs(tip)}><i class=dot style="background:${color}"></i>${esc(label)}</span>`;
+}
+function chartLegendHtml(mode,cumulative=false){
+ const cursor=CURRENT?.provider==='cursor';
+ const cumulativeLabel=cumulative?'cumulative ':'';
+ const cumulativeTip=cumulative?' Running total through each execution.':'';
+ const eventMarks=[
+  legendField('user message','var(--fg)','Execution points with a captured user message preview. The diamond marker sits on the active chart series.'),
+  legendField('notable tools','var(--toolcall)','Executions with unusually high tool-call count for this log/thread.'),
+  legendField('notable reasoning','var(--reason)','Executions with unusually high reasoning tokens for this log/thread.'),
+  legendField('coordination','var(--coord)','Subagent or coordination executions when the log marks them separately.'),
+ ].join('');
+ if(mode==='context') return [
+  legendField('context','var(--c-context)','Input tokens as a share of the model context window for each execution.'),
+  legendField('70% watch','var(--warn)','Watch threshold: context is getting large enough to consider summarizing or narrowing tool output.'),
+  legendField('85% high','var(--bad)','High threshold: context is close to the model window limit.'),
+ ].join('')+eventMarks;
+ if(mode==='tokens') return [
+  legendField(cumulativeLabel+(cursor?'input context est':'input total'),'var(--c-input)',(cursor?'One trace-visible context snapshot per Cursor execution; this is a local proxy, not billable input.':'Total input/context tokens for each execution, including uncached input and prompt-cache tokens.')+cumulativeTip),
+  legendField(cumulativeLabel+(cursor?'visible output est':'output'),'var(--c-output)',(cursor?'Model-authored text persisted in Cursor bubbles, estimated at four characters per token.':'Model output tokens produced by the execution.')+cumulativeTip),
+  legendField(cumulativeLabel+'cache read','var(--c-cache-read)','Input tokens served from the provider prompt cache. These are usually cheaper than uncached input.'+cumulativeTip),
+  legendField(cumulativeLabel+'cache write','var(--c-cache-write)','Input tokens written into the provider prompt cache for possible reuse later. Some providers may report zero.'+cumulativeTip),
+  legendField(cumulativeLabel+'uncached input','var(--c-input)','Input tokens charged as normal input because they were new or did not hit prompt cache.'+cumulativeTip),
+ ].join('')+eventMarks;
+ if(mode==='tools') return [
+  legendField('tool calls','var(--toolcall)','Number of tool calls observed in each execution.'),
+ ].join('')+eventMarks;
+ if(mode==='steps') return [
+  legendField('steps','var(--toolcall)','Number of executions grouped under each captured user message.'),
+  legendField('request cost','var(--c-cost)','Total estimated cost for the executions in that request.'),
+  legendField('request message','var(--fg)','The user message that started the request, shown in hover.'),
+ ].join('');
+ if(mode==='wait') return [
+  legendField('wait time','var(--accent)','Wall-clock time from the user prompt until the completed response, including reasoning and tool use.'),
+  legendField('request message','var(--fg)','The captured user message associated with the timed request, when available.'),
+ ].join('');
+ if(mode==='cost') return legendField(cumulative?(cursor?'cumulative local cost est':'cumulative cost'):(cursor?'local execution estimate':'execution cost'),'var(--c-cost)',(cursor?'Context-and-visible-output proxy priced with the persisted model variant; cache and hidden model work are excluded.':'Estimated USD cost for this execution using the configured public API rates.')+cumulativeTip)+eventMarks;
+ return chartLegendHtml('context');
+}
+function chartParts(s){
+ let read=+(s.cache_read||0), write=+(s.cache_write||0);
+ const legacyCache=+(s.cache||0);
+ if(!read&&!write&&legacyCache) read=legacyCache;
+ const cache=read+write, rawFresh=s.fresh_input;
+ const fresh=Number.isFinite(+rawFresh)?Math.max(0,+rawFresh):Math.max(0,+(s.in||0)-cache);
+ const total=Math.max(+(s.in||0),fresh+cache);
+ const ctx=s.context_pct===undefined||s.context_pct===null?null:+s.context_pct;
+ return {fresh,read,write,cache,total,out:+(s.out||0),cost:+(s.cost||0),context:ctx,reason:+(s.reasoning||0),tools:+(s.tools||0)};
+}
+function cumulativeChartParts(parts,mode){
+ const keys=mode==='cost'?['cost']:['fresh','read','write','cache','total','out'];
+ const sums=Object.fromEntries(keys.map(key=>[key,0]));
+ return parts.map(part=>{
+  keys.forEach(key=>{sums[key]+=Math.max(0,Number(part[key]||0));});
+  return {...part,...sums};
+ });
+}
+function requestStepGroups(series){
+ const groups=[];
+ let cur=null;
+ (series||[]).forEach((s,idx)=>{
+  const msg=String(s.user_message||s.user_input||'').trim();
+  const exec=s.i??idx+1;
+  if(msg||!cur){
+   cur={i:groups.length+1,message:msg||'No user message captured',hasMessage:!!msg,start:exec,end:exec,steps:0,cost:0,input:0,output:0,tools:0,peakContext:null};
+   groups.push(cur);
+  }
+  const p=chartParts(s);
+  cur.steps++;
+  cur.end=exec;
+  cur.cost+=p.cost;
+  cur.input+=p.total;
+  cur.output+=p.out;
+  cur.tools+=p.tools;
+  if(p.context!==null&&Number.isFinite(p.context)) cur.peakContext=Math.max(cur.peakContext??0,p.context);
+ });
+ return groups;
+}
+function drawStepsChart(series){
+ const svg=$('iochart'), tip=$('chart-tip'), VW=Math.max(320,Math.round(svg.clientWidth||1040)), VH=Math.max(160,Math.round(svg.clientHeight||244)), MR=16, MT=14, MB=42;
+ svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ const groups=requestStepGroups(series);
+ if(!groups.length){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">no user requests yet</text>'; if(tip)tip.style.display='none'; return;}
+ const n=groups.length, rawMax=Math.max(1,...groups.map(g=>g.steps)), tickVals=integerTicks(rawMax), maxV=tickVals[tickVals.length-1];
+ const fmtY=v=>f(v), widestTick=tickVals.reduce((a,v)=>Math.max(a,String(fmtY(v)).length),0);
+ const ML=Math.min(98,Math.max(58,widestTick*7+18)), PW=VW-ML-MR, PH=VH-MT-MB;
+ const x=i=>ML+(n<=1?PW/2:i/(n-1)*PW);
+ const y=v=>MT+PH-(Math.max(0,v)/maxV)*PH;
+ const T=`font:${svgTextPx(svg,VW,VH)}px var(--font-mono);fill:${CHART.lbl}`;
+ let grid='',ylbl='';
+ tickVals.forEach(v=>{ const yy=y(v).toFixed(1); grid+=`<line x1=${ML} y1=${yy} x2=${VW-MR} y2=${yy} stroke="${CHART.grid}" stroke-dasharray="3 4"/>`; ylbl+=`<text x=${ML-8} y=${(+yy+4).toFixed(1)} text-anchor=end style="${T}">${fmtY(v)}</text>`; });
+ const axes=`<line x1=${ML} y1=${MT} x2=${ML} y2=${MT+PH} stroke="${CHART.axis}"/><line x1=${ML} y1=${MT+PH} x2=${VW-MR} y2=${MT+PH} stroke="${CHART.axis}"/>`;
+ let xlbl=''; [0,n-1,Math.floor((n-1)/2),Math.floor((n-1)/4),Math.floor(3*(n-1)/4)].forEach(i=>{ if(i>=0&&i<n) xlbl+=`<text x=${x(i).toFixed(1)} y=${VH-16} text-anchor=middle style="${T}">#${groups[i].i}</text>`; });
+ const bw=Math.max(8,Math.min(34,PW/Math.max(1,n)/1.8));
+ const bars=groups.map((g,i)=>{ const yy=y(g.steps), h=MT+PH-yy; return `<rect x="${(x(i)-bw/2).toFixed(1)}" y="${yy.toFixed(1)}" width="${bw.toFixed(1)}" height="${Math.max(1,h).toFixed(1)}" rx="3" fill="${tint('signal',.28)}" stroke="${CHART.tool}" stroke-width="1"/>`; }).join('');
+ let d=''; groups.forEach((g,i)=>{ d+=(i?' L':'M')+x(i).toFixed(1)+' '+y(g.steps).toFixed(1); });
+ const line=d?`<path d="${d}" fill="none" stroke="${CHART.tool}" stroke-width="2.6" stroke-linejoin="round" stroke-linecap="round"/>`:'';
+ const costMax=Math.max(.001,...groups.map(g=>g.cost));
+ const costMarks=groups.map((g,i)=>{ const h=4+Math.min(14,(g.cost/costMax)*14); return `<circle cx="${x(i).toFixed(1)}" cy="${(MT+PH+7).toFixed(1)}" r="${h/2}" fill="${CHART.cost}" opacity=".78"/>`; }).join('');
+ const titles=`<text x=${(ML+PW/2).toFixed(1)} y=${VH-1} text-anchor=middle style="${T}">user request</text><text x=14 y=${(MT+PH/2).toFixed(1)} text-anchor=middle transform="rotate(-90 14 ${(MT+PH/2).toFixed(1)})" style="${T}">steps</text>`;
+ const hover=`<rect id=ch-hit x=${ML} y=${MT} width=${PW} height=${PH} fill="transparent" pointer-events="all"/><g id=chart-hover opacity=0 style="pointer-events:none"><line id=ch-x y1=${MT} y2=${MT+PH} stroke="${CHART.tipLine}" stroke-dasharray="4 4"/><circle id=ch-a r=4.8 fill="${CHART.tool}" stroke="${CHART.ink}" stroke-width=2/></g>`;
+ svg.innerHTML=grid+axes+ylbl+xlbl+bars+line+costMarks+titles+hover;
+ const hoverGroup=svg.querySelector('#chart-hover'), hit=svg.querySelector('#ch-hit');
+ const setAttr=(id,attrs)=>{const el=svg.querySelector(id); Object.entries(attrs).forEach(([k,v])=>el.setAttribute(k,v));};
+ function hoverAt(clientX,clientY){
+  const pt=svg.createSVGPoint(); pt.x=clientX; pt.y=clientY;
+  const curPt=pt.matrixTransform(svg.getScreenCTM().inverse());
+  const idx=Math.max(0,Math.min(n-1,Math.round((curPt.x-ML)/PW*(n-1))));
+  const g=groups[idx], xx=x(idx), yy=y(g.steps);
+  hoverGroup.setAttribute('opacity','1');
+  setAttr('#ch-x',{x1:xx.toFixed(1),x2:xx.toFixed(1)});
+  setAttr('#ch-a',{cx:xx.toFixed(1),cy:yy.toFixed(1),opacity:1});
+  if(tip){
+   const sx=svg.clientWidth/VW, sy=svg.clientHeight/VH, w=360, h=244;
+   const left=Math.min(Math.max(xx*sx+14,8),Math.max(8,svg.clientWidth-w-8));
+   const top=Math.min(Math.max(yy*sy-108,8),Math.max(8,svg.clientHeight-h-8));
+   tip.style.display='block'; tip.style.left=left+'px'; tip.style.top=top+'px';
+   const row=(cls,name,val)=>`<div class="r ${cls}"><span>${name}</span><b>${val}</b></div>`;
+   const execRange=g.start===g.end?`#${g.start}`:`#${g.start}-${g.end}`;
+   const messageBlock=g.hasMessage?`<div class=prompt><span>user message</span><b>${esc(g.message)}</b></div>`:'';
+   const est=CURRENT?.provider==='cursor'?' est':'';
+   tip.innerHTML=`<div class=h>request #${g.i}</div>${row('tools','steps',f(g.steps))}${row('in','executions',execRange)}${row('cost','cost',metricAvailable(CURRENT,'cost')?money(g.cost)+est:'--')}${row('in',est?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(g.input)+est:'--')}${row('out',est?'visible output':'output',metricAvailable(CURRENT,'output_tokens')?f(g.output)+est:'--')}${row('tools','tool calls',f(g.tools))}${row('context','peak context',g.peakContext===null?'--':pct(g.peakContext))}${messageBlock}`;
+  }
+ }
+ hit.addEventListener('mousemove',e=>hoverAt(e.clientX,e.clientY));
+ hit.addEventListener('mouseleave',()=>{hoverGroup.setAttribute('opacity','0'); if(tip)tip.style.display='none';});
+ hit.addEventListener('touchmove',e=>{ if(e.touches[0]) hoverAt(e.touches[0].clientX,e.touches[0].clientY); },{passive:true});
+}
+function drawWaitChart(samples,series){
+ const svg=$('iochart'),tip=$('chart-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||244)),MR=16,MT=14,MB=42;
+ svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ samples=samples||[];
+ if(!samples.length){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">no completed wait timing yet</text>';if(tip)tip.style.display='none';return;}
+ const groups=requestStepGroups(series||[]),n=samples.length,rawMax=Math.max(1,...samples.map(row=>Number(row.duration_s||0))),tickVals=ticks(rawMax),maxV=rawMax;
+ const fmtY=value=>waitFmt(value),widestTick=tickVals.reduce((width,value)=>Math.max(width,fmtY(value).length),0);
+ const ML=Math.min(110,Math.max(62,widestTick*7+18)),PW=VW-ML-MR,PH=VH-MT-MB;
+ const x=index=>ML+(n<=1?PW/2:index/(n-1)*PW),y=value=>MT+PH-PH*(Math.max(0,Number(value||0))/maxV);
+ const T=`font:${svgTextPx(svg,VW,VH)}px var(--font-mono);fill:${CHART.lbl}`;
+ let grid='',labels='';
+ tickVals.forEach(value=>{const yy=y(value).toFixed(1);grid+=`<line x1=${ML} y1=${yy} x2=${VW-MR} y2=${yy} stroke="${CHART.grid}" stroke-dasharray="3 4"/>`;labels+=`<text x=${ML-8} y=${(+yy+4).toFixed(1)} text-anchor=end style="${T}">${fmtY(value)}</text>`;});
+ const axes=`<line x1=${ML} y1=${MT} x2=${ML} y2=${MT+PH} stroke="${CHART.axis}"/><line x1=${ML} y1=${MT+PH} x2=${VW-MR} y2=${MT+PH} stroke="${CHART.axis}"/>`;
+ const barWidth=Math.max(8,Math.min(34,PW/Math.max(1,n)/1.8));
+ const bars=samples.map((row,index)=>{const yy=y(row.duration_s),height=MT+PH-yy;return `<rect x="${(x(index)-barWidth/2).toFixed(1)}" y="${yy.toFixed(1)}" width="${barWidth.toFixed(1)}" height="${Math.max(1,height).toFixed(1)}" rx="3" fill="${tint('signal',.28)}" stroke="${CHART.context}" stroke-width="1.2"/>`;}).join('');
+ const line=samples.length>1?`<path d="${samples.map((row,index)=>`${index?'L':'M'}${x(index).toFixed(1)},${y(row.duration_s).toFixed(1)}`).join(' ')}" fill="none" stroke="${CHART.context}" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>`:'';
+ const every=Math.max(1,Math.ceil(n/8));
+ let xlabels='';samples.forEach((row,index)=>{if(index===n-1||index%every===0)xlabels+=`<text x=${x(index).toFixed(1)} y=${VH-16} text-anchor=middle style="${T}">#${index+1}</text>`;});
+ const titles=`<text x=${(ML+PW/2).toFixed(1)} y=${VH-1} text-anchor=middle style="${T}">user request</text><text x=14 y=${(MT+PH/2).toFixed(1)} text-anchor=middle transform="rotate(-90 14 ${(MT+PH/2).toFixed(1)})" style="${T}">wait time</text>`;
+ const hover=`<rect id=ch-hit x=${ML} y=${MT} width=${PW} height=${PH} fill="transparent" pointer-events="all"/><g id=chart-hover opacity=0 style="pointer-events:none"><line id=ch-x y1=${MT} y2=${MT+PH} stroke="${CHART.tipLine}" stroke-dasharray="4 4"/><circle id=ch-a r=4.8 fill="${CHART.context}" stroke="${CHART.ink}" stroke-width=2/></g>`;
+ svg.innerHTML=grid+axes+labels+xlabels+bars+line+titles+hover;
+ const hoverGroup=svg.querySelector('#chart-hover'),hit=svg.querySelector('#ch-hit'),cross=svg.querySelector('#ch-x'),dot=svg.querySelector('#ch-a');
+ function hoverAt(clientX,clientY){
+  const point=svg.createSVGPoint();point.x=clientX;point.y=clientY;
+  const local=point.matrixTransform(svg.getScreenCTM().inverse()),index=Math.max(0,Math.min(n-1,Math.round((local.x-ML)/PW*(n-1))));
+  const row=samples[index],xx=x(index),yy=y(row.duration_s),group=groups[index];
+  hoverGroup.setAttribute('opacity','1');cross.setAttribute('x1',xx);cross.setAttribute('x2',xx);dot.setAttribute('cx',xx);dot.setAttribute('cy',yy);
+  if(tip){const rect=svg.parentElement.getBoundingClientRect(),message=group?.hasMessage?`<div class=prompt><span>user message</span><b>${esc(group.message)}</b></div>`:'',cursor=CURRENT?.provider==='cursor';tip.innerHTML=`<div class=h>request #${index+1}</div><div class="r context"><span>wait time</span><b>${waitFmt(row.duration_s)}</b></div><div class=r><span>model</span><b>${esc(row.model||'unknown')}</b></div><div class="r tools"><span>tool calls</span><b>${f(row.tool_calls)}</b></div><div class="r out"><span>${cursor?'visible output est':'output'}</span><b>${metricAvailable(CURRENT,'output_tokens')?f(row.output_tokens)+' tok'+(cursor?' est':''):'--'}</b></div><div class=r><span>timing</span><b>${esc(row.timing_basis||'observed')}</b></div>${message}`;tip.style.display='block';tip.style.left=Math.min(rect.width-tip.offsetWidth-8,Math.max(8,clientX-rect.left+12))+'px';tip.style.top=Math.max(8,clientY-rect.top-tip.offsetHeight-10)+'px';}
+ }
+ hit.addEventListener('mousemove',event=>hoverAt(event.clientX,event.clientY));
+ hit.addEventListener('mouseleave',()=>{hoverGroup.setAttribute('opacity','0');if(tip)tip.style.display='none';});
+ hit.addEventListener('touchmove',event=>{if(event.touches[0])hoverAt(event.touches[0].clientX,event.touches[0].clientY);},{passive:true});
+}
+function drawIO(series){
+ const svg=$('iochart'), VW=Math.max(320,Math.round(svg.clientWidth||1040)), VH=Math.max(160,Math.round(svg.clientHeight||244)), MR=16, MT=14, MB=42;
+ svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ const tip=$('chart-tip');
+ const mode=CHART_MODES.includes(chartMode)?chartMode:'context';
+ const cumulativeTokens=mode==='tokens'&&chartScale==='cumulative';
+ const cumulativeCost=mode==='cost'&&chartScale==='cumulative';
+ const cumulativeValues=cumulativeTokens||cumulativeCost;
+ const legend=$('chart-legend'); if(legend) legend.innerHTML=chartLegendHtml(mode,cumulativeValues);
+ const profileHint=$('exec-profile-hint'), activity=CURRENT?.tools?.activity||{};
+ const executionCoverage=CURRENT?.execution_coverage||{},hermesAggregate=executionCoverage.basis==='session_aggregate';
+ if(profileHint) profileHint.textContent=hermesAggregate
+  ? `${f(executionCoverage.recorded_executions||0)} recorded executions · one Hermes session aggregate · per-execution token breakdown unavailable`
+  : mode==='tools'
+  ? `${f(activity.total_calls)} total calls · ${f(activity.observed_unique)} observed types · peak ${f(activity.peak_calls_per_execution)}/execution`
+  : mode==='wait'
+   ? `${f(CURRENT?.wait_time?.sample_count||0)} completed timed ${countWord(CURRENT?.wait_time?.sample_count||0,'request')} · lower is better`
+   : cumulativeCost
+    ? 'running estimated cost through each execution'
+   : cumulativeTokens
+    ? 'running token totals through each execution'
+   : 'per execution or request';
+ if(mode==='wait'){drawWaitChart(CURRENT?.wait_time?.samples||[],series);return;}
+ const n=series.length; if(!n){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">no executions yet</text>'; if(tip)tip.style.display='none'; return;}
+ if(mode==='steps'){ drawStepsChart(series); return; }
+ if((mode==='tokens'&&!metricAvailable(CURRENT,'tokens'))||(mode==='cost'&&!metricAvailable(CURRENT,'cost'))){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">'+(mode==='cost'?'cost estimate':'token evidence')+' unavailable in this trace</text>';if(tip)tip.style.display='none';return;}
+ const rawParts=series.map(chartParts), parts=cumulativeValues?cumulativeChartParts(rawParts,mode):rawParts;
+ const maxCache=Math.max(10,...parts.map(p=>Math.max(p.total,p.cache,p.fresh,p.out)));
+ const maxCost=Math.max(.001,...parts.map(p=>p.cost));
+ const maxTools=Math.max(1,...parts.map(p=>p.tools));
+ const rawMaxV=mode==='cost'?maxCost:(mode==='context'?1:(mode==='tools'?maxTools:maxCache));
+ const tickVals=mode==='tools'?integerTicks(rawMaxV):ticks(rawMaxV);
+ const maxV=mode==='tools'?tickVals[tickVals.length-1]:rawMaxV;
+ const fmtY=v=>mode==='cost'?moneyTick(v):(mode==='context'?pct(v):f(v));
+ const widestTick=tickVals.reduce((a,v)=>Math.max(a,String(fmtY(v)).length),0);
+ const ML=Math.min(98,Math.max(58,widestTick*7+18)), PW=VW-ML-MR, PH=VH-MT-MB;
+ const x=i=>ML+(n<=1?PW/2:i/(n-1)*PW);
+ const y=v=>MT+PH-scaledY(v,maxV)*PH;
+ const T=`font:${svgTextPx(svg,VW,VH)}px var(--font-mono);fill:${CHART.lbl}`;
+ let grid='',ylbl='';
+ tickVals.forEach(v=>{ const yy=y(v).toFixed(1); grid+=`<line x1=${ML} y1=${yy} x2=${VW-MR} y2=${yy} stroke="${CHART.grid}" stroke-dasharray="3 4"/>`; ylbl+=`<text x=${ML-8} y=${(+yy+4).toFixed(1)} text-anchor=end style="${T}">${fmtY(v)}</text>`; });
+ const axes=`<line x1=${ML} y1=${MT} x2=${ML} y2=${MT+PH} stroke="${CHART.axis}"/><line x1=${ML} y1=${MT+PH} x2=${VW-MR} y2=${MT+PH} stroke="${CHART.axis}"/>`;
+ const xTickIndexes=[...new Set([0,n-1,Math.floor((n-1)/2),Math.floor((n-1)/4),Math.floor(3*(n-1)/4)])];
+ let xlbl=''; xTickIndexes.forEach(i=>{ if(i>=0&&i<n) xlbl+=`<text x=${x(i).toFixed(1)} y=${VH-16} text-anchor=middle style="${T}">${series[i].i}</text>`; });
+ const lineVals=(vals,col,w=2.4,dash='')=>{
+  let d='',open=false;
+  const validPoints=[];
+  vals.forEach((v,i)=>{ if(v===null||v===undefined||Number.isNaN(v)){open=false;return;} validPoints.push([i,v]); d+=(open?' L':'M')+x(i).toFixed(1)+' '+y(v).toFixed(1); open=true; });
+  const line=d?`<path d="${d}" fill="none" stroke="${col}" stroke-width="${w}" stroke-linejoin="round" stroke-linecap="round"${dash?` stroke-dasharray="${dash}"`:''}/>`:'';
+  const singlePoint=validPoints.length===1?`<circle cx="${x(validPoints[0][0]).toFixed(1)}" cy="${y(validPoints[0][1]).toFixed(1)}" r="3.8" fill="${col}" stroke="${CHART.ink}" stroke-width="1.6"/>`:'';
+  return line+singlePoint;
+ };
+ const band=(top,bottom,col,opacity)=>{
+  let d='';
+  top.forEach((v,i)=>{ d+=(i?' L':'M')+x(i).toFixed(1)+' '+y(v||0).toFixed(1); });
+  for(let i=bottom.length-1;i>=0;i--) d+=' L'+x(i).toFixed(1)+' '+y(bottom[i]||0).toFixed(1);
+  return `<path d="${d} Z" fill="${col}" fill-opacity="${opacity}"/>`;
+ };
+ const bars=(vals,col)=>{
+  const bw=Math.max(2,Math.min(22,PW/Math.max(1,n)/1.85));
+  return vals.map((v,i)=>{ const yy=y(v||0), h=MT+PH-yy; return `<rect x="${(x(i)-bw/2).toFixed(1)}" y="${yy.toFixed(1)}" width="${bw.toFixed(1)}" height="${Math.max(1,h).toFixed(1)}" rx="2" fill="${col}"/>`; }).join('');
+ };
+ const zeros=parts.map(()=>0), fresh=parts.map(p=>p.fresh), inputTotals=parts.map(p=>p.total);
+ const cacheRead=parts.map(p=>p.read), cacheTop=parts.map(p=>p.cache), output=parts.map(p=>p.out), costs=parts.map(p=>p.cost), contexts=parts.map(p=>p.context), toolCalls=parts.map(p=>p.tools);
+ const nonZeroSorted=(vals)=>vals.filter(v=>v>0).sort((a,b)=>a-b);
+ const percentile=(vals,q,fallback=0)=>{ vals=nonZeroSorted(vals); return vals.length?vals[Math.min(vals.length-1,Math.floor((vals.length-1)*q))]:fallback; };
+ const toolCut=Math.max(3,percentile(rawParts.map(p=>p.tools),.85,0));
+ const reasonCut=Math.max(1000,percentile(rawParts.map(p=>p.reason),.85,0));
+ const primaryFor=p=>{
+  if(mode==='tokens') return {value:p.total,color:CHART.input};
+  if(mode==='cost') return {value:p.cost,color:CHART.cost};
+  if(mode==='context') return {value:p.context,color:CHART.context};
+  if(mode==='tools') return {value:p.tools,color:CHART.tool};
+  return {value:p.total,color:CHART.input};
+ };
+ let plot='';
+ if(mode==='context'){
+  plot+=`<rect x="${ML}" y="${y(1).toFixed(1)}" width="${PW}" height="${(y(.85)-y(1)).toFixed(1)}" fill="${tint('red',.08)}"/><rect x="${ML}" y="${y(.85).toFixed(1)}" width="${PW}" height="${(y(.7)-y(.85)).toFixed(1)}" fill="${tint('orange',.07)}"/>`;
+  plot+=`<line x1="${ML}" y1="${y(.85).toFixed(1)}" x2="${VW-MR}" y2="${y(.85).toFixed(1)}" stroke="${CHART.cost}" stroke-dasharray="5 5" opacity=".75"/><line x1="${ML}" y1="${y(.7).toFixed(1)}" x2="${VW-MR}" y2="${y(.7).toFixed(1)}" stroke="${CHART.cacheWrite}" stroke-dasharray="5 5" opacity=".75"/>`;
+  plot+=contexts.some(v=>v!==null)?lineVals(contexts,CHART.context,2.7):`<text x=${Math.round(VW/2)} y=${Math.round(VH/2)} text-anchor=middle fill="${CHART.lbl}">context data unavailable</text>`;
+ }else if(mode==='tokens'){
+  plot+=band(cacheRead,zeros,CHART.cacheRead,.18)+band(cacheTop,cacheRead,CHART.cacheWrite,.18);
+  plot+=lineVals(inputTotals,CHART.input,2.7)+lineVals(output,CHART.output,2.1)+lineVals(cacheTop,CHART.cacheRead,1.7,'4 4')+lineVals(fresh,CHART.input,1.5,'5 4');
+ }else if(mode==='tools'){
+  plot+=bars(toolCalls,tint('signal',.24))+lineVals(toolCalls,CHART.tool,2.6);
+ }else{
+  plot+=bars(costs,CHART.costFill)+lineVals(costs,CHART.cost,2.4);
+ }
+ let marks='';
+ series.forEach((s,i)=>{
+  const p=parts[i], xx=x(i), y0=MT+PH+6;
+  if(p.tools>=toolCut) marks+=`<line x1="${(xx-3).toFixed(1)}" y1="${(y0-7).toFixed(1)}" x2="${(xx-3).toFixed(1)}" y2="${y0.toFixed(1)}" stroke="${CHART.tool}" stroke-width="2.2" stroke-linecap="round" opacity=".75"/>`;
+  if(p.reason>=reasonCut) marks+=`<line x1="${(xx+3).toFixed(1)}" y1="${(y0-7).toFixed(1)}" x2="${(xx+3).toFixed(1)}" y2="${y0.toFixed(1)}" stroke="${CHART.reason}" stroke-width="2.2" stroke-linecap="round" opacity=".75"/>`;
+  if(s.side) marks+=`<circle cx="${xx.toFixed(1)}" cy="${(y0-3).toFixed(1)}" r="3" fill="${CHART.side}" opacity=".85"/>`;
+  if(s.user_message||s.user_input){
+   const u=primaryFor(p);
+   if(u.value!==null&&u.value!==undefined&&!Number.isNaN(u.value)){
+    const yy=y(u.value);
+    marks+=`<path d="M ${xx.toFixed(1)} ${(yy-5).toFixed(1)} L ${(xx+5).toFixed(1)} ${yy.toFixed(1)} L ${xx.toFixed(1)} ${(yy+5).toFixed(1)} L ${(xx-5).toFixed(1)} ${yy.toFixed(1)} Z" fill="${CHART.tip}" stroke="${u.color}" stroke-width="2" opacity=".96"/>`;
+   }
+  }
+ });
+ const yTitle=mode==='cost'?(cumulativeCost?'cumulative usd':'usd'):(mode==='context'?'context':(mode==='tools'?'tool calls':(cumulativeTokens?'cumulative tokens':'tokens')));
+ const titles=`<text x=${(ML+PW/2).toFixed(1)} y=${VH-1} text-anchor=middle style="${T}">execution</text><text x=14 y=${(MT+PH/2).toFixed(1)} text-anchor=middle transform="rotate(-90 14 ${(MT+PH/2).toFixed(1)})" style="${T}">${yTitle}</text>`;
+ const hover=`<rect id=ch-hit x=${ML} y=${MT} width=${PW} height=${PH} fill="transparent" pointer-events="all"/><g id=chart-hover opacity=0 style="pointer-events:none">
+  <line id=ch-x y1=${MT} y2=${MT+PH} stroke="${CHART.tipLine}" stroke-dasharray="4 4"/>
+  <circle id=ch-a r=4.8 fill="${CHART.input}" stroke="${CHART.ink}" stroke-width=2/>
+  <circle id=ch-b r=4.4 fill="${CHART.output}" stroke="${CHART.ink}" stroke-width=2/>
+ </g>`;
+ svg.innerHTML=grid+axes+ylbl+xlbl+plot+marks+titles+hover;
+ const hoverGroup=svg.querySelector('#chart-hover'), hit=svg.querySelector('#ch-hit');
+ const setAttr=(id,attrs)=>{const el=svg.querySelector(id); Object.entries(attrs).forEach(([k,v])=>el.setAttribute(k,v));};
+ function hoverAt(clientX,clientY){
+  const pt=svg.createSVGPoint(); pt.x=clientX; pt.y=clientY;
+  const cur=pt.matrixTransform(svg.getScreenCTM().inverse());
+  const idx=Math.max(0,Math.min(n-1,Math.round((cur.x-ML)/PW*(n-1))));
+  const s=series[idx], p=parts[idx], xx=x(idx);
+  const primaryInfo=primaryFor(p);
+  let primary=primaryInfo.value, primaryColor=primaryInfo.color, secondary=p.out, secondaryColor=CHART.output;
+  if(mode!=='tokens') secondary=null;
+  const yPrimary=primary===null||primary===undefined?MT+PH:y(primary), ySecondary=secondary===null||secondary===undefined?null:y(secondary);
+  hoverGroup.setAttribute('opacity','1');
+  setAttr('#ch-x',{x1:xx.toFixed(1),x2:xx.toFixed(1)});
+  setAttr('#ch-a',{cx:xx.toFixed(1),cy:yPrimary.toFixed(1),fill:primaryColor,opacity:primary===null||primary===undefined?0:1});
+  setAttr('#ch-b',{cx:xx.toFixed(1),cy:(ySecondary??yPrimary).toFixed(1),fill:secondaryColor,opacity:ySecondary===null?0:1});
+  if(tip){
+   const sx=svg.clientWidth/VW, sy=svg.clientHeight/VH, w=360, h=272;
+   const left=Math.min(Math.max(xx*sx+14,8),Math.max(8,svg.clientWidth-w-8));
+   const top=Math.min(Math.max(Math.min(yPrimary,ySecondary??yPrimary)*sy-112,8),Math.max(8,svg.clientHeight-h-8));
+   tip.style.display='block';
+   tip.style.left=left+'px';
+   tip.style.top=top+'px';
+   const row=(cls,name,val)=>`<div class="r ${cls}"><span>${name}</span><b>${val}</b></div>`;
+   const userMessage=s.user_message||s.user_input||'';
+   const markers=[userMessage?'user message':null,p.tools?`${f(p.tools)} tool calls`:null,p.reason?`${f(p.reason)} reasoning`:null,s.side?'coordination':null].filter(Boolean).join(' / ');
+   const prompt=userMessage?esc(userMessage):'--';
+   const promptBlock=userMessage?`<div class=prompt><span>user message</span><b>${prompt}</b></div>`:'';
+   const cursor=CURRENT?.provider==='cursor',est=cursor?' est':'';
+   const costLabel=cumulativeCost?'cumulative cost':'cost';
+   const common=[
+    row('context','context',p.context===null?'--':pct(p.context)),
+    row('cost',costLabel,metricAvailable(CURRENT,'cost')?money(p.cost)+est:'--'),
+   ];
+   const tokenPrefix=cumulativeTokens?'cumulative ':'';
+   const tokenRows=[
+    row('in',tokenPrefix+(cursor?'input context':'input total'),metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),
+    row('out',tokenPrefix+(cursor?'visible output':'output'),metricAvailable(CURRENT,'output_tokens')?f(p.out)+est:'--'),
+    row('fresh',tokenPrefix+'uncached input',metricAvailable(CURRENT,'cache')?f(p.fresh):'--'),
+    row('cacheRead',tokenPrefix+'cache read',metricAvailable(CURRENT,'cache')?f(p.read):'--'),
+    row('cacheWrite',tokenPrefix+'cache write',metricAvailable(CURRENT,'cache')?f(p.write):'--'),
+   ];
+   const toolRows=[
+    row('tools','tool calls',f(p.tools)),
+    row('in',cursor?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),
+    row('out',cursor?'visible output':'output',metricAvailable(CURRENT,'output_tokens')?f(p.out)+est:'--'),
+   ];
+   const rows=mode==='tools'?[...toolRows,...common]:mode==='tokens'?[...tokenRows,row('tools','tool calls',f(p.tools)),...common]:mode==='context'?[row('context','context',p.context===null?'--':pct(p.context)),row('in',cursor?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),row('tools','tool calls',f(p.tools)),row('cost','cost',metricAvailable(CURRENT,'cost')?money(p.cost)+est:'--')]:[row('cost',costLabel,metricAvailable(CURRENT,'cost')?money(p.cost)+est:'--'),row('in',cursor?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),row('out',cursor?'visible output':'output',metricAvailable(CURRENT,'output_tokens')?f(p.out)+est:'--'),row('tools','tool calls',f(p.tools))];
+   const heading=s.aggregate?`session aggregate · ${f(CURRENT?.execution_coverage?.recorded_executions||0)} executions`:`execution #${esc(s.i??idx+1)}`;
+   tip.innerHTML=`<div class=h>${heading}</div>${rows.join('')}${markers?`<div class=r><span>markers</span><b>${esc(markers)}</b></div>`:''}${promptBlock}`;
+  }
+ }
+ hit.addEventListener('mousemove',e=>hoverAt(e.clientX,e.clientY));
+ hit.addEventListener('mouseleave',()=>{hoverGroup.setAttribute('opacity','0'); if(tip)tip.style.display='none';});
+ hit.addEventListener('touchmove',e=>{ if(e.touches[0]) hoverAt(e.touches[0].clientX,e.touches[0].clientY); },{passive:true});
+}
+
+function renderOverview(s){
+ const ex=s.executions||[], avg=s.turns?s.total_cost/s.turns:0, peak=Math.max(0,...(s.series||[]).map(x=>x.in||0)),costAvailable=metricAvailable(s,'cost'),estimate=s.provider==='cursor'?' est':'';
+ const timing=s.timing||{}, wait=s.wait_time||{}, context=s.context||{}, tools=s.tools||{};
+ $('exec-hint').textContent=(s.source?.label||s.provider||'')+' · '+(s.primary_model||'');
+ $('cost-start').textContent=dt12(timing.start_local)||'--';
+ $('cost-end-label').textContent=timing.end_label||'Last activity';
+ $('cost-end').textContent=dt12(timing.end_local)||'--';
+ $('ov-duration').textContent=wait.available?waitFmt(wait.total_s):'--';
+ $('ov-idle').textContent=wait.available?`${waitFmt(wait.avg_s)} avg · ${f(wait.sample_count)} completed ${countWord(wait.sample_count,'request')}`:'completed wait timing unavailable';
+ $('ov-context').textContent=f(context.latest||0);
+ $('ov-contextsm').textContent=context.window?`${pct(context.latest_pct)} of ${f(context.window)} window${s.provider==='cursor'?' · context snapshot':''}`:'latest input tokens';
+ $('ov-loaded-label').textContent=tools.loaded_known?'Catalog advertised':'Tool types observed';
+ $('ov-loaded').textContent=f(tools.loaded||0);
+ $('ov-loadedsm').textContent=tools.loaded_known?`${f(tools.eager||0)} eager · ${f(tools.deferred||0)} deferred · partial catalog`:`${f(tools.unique_used||0)} observed · catalog unavailable`;
+ $('ov-exec').textContent=f(s.turns); $('ov-model').textContent=s.primary_model||'';
+ for(const [key,id] of [['skills','ov-skills'],['mcp_servers','ov-mcp']]){
+  const counts=capabilityCounts(s.capabilities,key);
+  $(id).textContent=capabilityRatio(counts);
+  $(id+'sm').textContent=counts.loaded==null?'loaded list not recorded':`${f(counts.used)} used of ${f(counts.loaded)} ${counts.basis==='configured'?'configured now':'loaded'}`;
+ }
+ setCostValue('ov-avg',money(avg)+estimate,costAvailable);
+ $('ov-tools').textContent=f(tools.total_calls||0); $('ov-tooltok').textContent=f(tools.total_output_tokens||0)+' returned tok';
+ $('ov-peak').textContent=f(peak);
+ $('ov-peak').textContent=f(context.peak||peak);
+ $('ov-peak').nextElementSibling.textContent=context.window?`${pct(context.peak_pct)} of model window`:'max input tokens';
+ setCostValue('ov-big',money(s.biggest_turn?.cost||0)+estimate,costAvailable); $('ov-bigsm').textContent=costAvailable?(s.biggest_turn?'execution #'+s.biggest_turn.idx+(estimate?' · local estimate':''):''):'billing unavailable';
+}
diff --git a/dashboard/js/core.js b/dashboard/js/core.js
new file mode 100644
index 00000000..636880d9
--- /dev/null
+++ b/dashboard/js/core.js
@@ -0,0 +1,396 @@
+// Data-series palettes for charts and SVG; CSS colors live in the stylesheet :root.
+const THEME={
+ compare:['#00bceb','#c7a7ff','#ffb457','#66d990'],
+ modelOther:'#5E6E7E',
+ modelSpeedExtra:['#F3C76A','#7AA7FF','#D4E157','#E6E6E6','#A1887F','#4DB6AC','#CE93D8','#90A4AE'],
+};
+const $=id=>document.getElementById(id);
+const TOKENOMICS_SEARCH_URL='https://www.google.com/search?q=site%3Asplunk.com+tokenomics';
+const DELIVERY_RANGES=['today','yesterday','7','30','90','month','last_month'];
+const TIME_FILTER_WINDOWS=['today','yesterday','7d','30d','90d','month','last_month','all'];
+const TIME_FILTER_LABELS={today:'Today',yesterday:'Yesterday','7d':'7 days','30d':'30 days','90d':'90 days',month:'Month','last_month':'Last month',all:'All history'};
+const DEFAULT_TIME_FILTER_WINDOW='30d';
+function normalizeTimeFilterWindow(value){return value==='24h'?'today':TIME_FILTER_WINDOWS.includes(value)?value:DEFAULT_TIME_FILTER_WINDOW;}
+function timeFilterBounds(window,nowMs=Date.now()){
+ const now=new Date(nowMs),stamp=(month,day)=>new Date(now.getFullYear(),month,day).getTime()/1000;
+ if(window==='today')return {start:stamp(now.getMonth(),now.getDate()),end:0};
+ if(window==='yesterday')return {start:stamp(now.getMonth(),now.getDate()-1),end:stamp(now.getMonth(),now.getDate())};
+ if(window==='month')return {start:stamp(now.getMonth(),1),end:0};
+ if(window==='last_month')return {start:stamp(now.getMonth()-1,1),end:stamp(now.getMonth(),1)};
+ const seconds={'7d':604800,'30d':2592000,'90d':7776000}[window]||0;
+ return {start:seconds?nowMs/1000-seconds:0,end:0};
+}
+const DELIVERY_EVIDENCE_FILTERS=['all','comparable','spend_only','git_only','unavailable'];
+let deliveryRange=localStorage.getItem('tm_delivery_range')||'30';
+if(!DELIVERY_RANGES.includes(deliveryRange)){deliveryRange='30';localStorage.setItem('tm_delivery_range',deliveryRange);}
+let deliveryProject=localStorage.getItem('tm_delivery_project')||'';
+let deliveryPayload=null,deliveryRequest=0,deliverySelectedDay='',deliveryLastLoadedAt=0;
+let deliverySort={key:'covered_cost',direction:'desc'};
+let deliveryModelSort={key:'covered_cost',direction:'desc'};
+let deliveryEvidenceFilter='all';
+let deliveryIgnorePointerSelection=false;
+function stripNativeFieldTipTitles(root=document){
+ root.querySelectorAll('.fieldtip[title]').forEach(el=>{if(!el.hasAttribute('aria-description'))el.setAttribute('aria-description',el.getAttribute('title'));el.removeAttribute('title');});
+}
+stripNativeFieldTipTitles();
+function initFieldTipPopup(){
+ const popup=document.createElement('div');
+ popup.id='fieldtip-popup';popup.setAttribute('role','tooltip');popup.hidden=true;document.body.append(popup);
+ let activeFieldTip=null,positionFrame=0;
+ const fieldTipTarget=node=>node instanceof Element?node.closest('.fieldtip[data-tip]'):null;
+ const hideFieldTip=target=>{
+  if(target&&activeFieldTip!==target)return;
+  activeFieldTip=null;popup.hidden=true;
+ };
+ const positionFieldTip=()=>{
+  positionFrame=0;
+  const target=activeFieldTip,tip=target?.getAttribute('data-tip')?.trim();
+  if(!target||!target.isConnected||!tip){hideFieldTip();return;}
+  popup.textContent=tip;popup.hidden=false;
+  const rect=target.getBoundingClientRect(),margin=12,gap=8,width=popup.offsetWidth,height=popup.offsetHeight;
+  const maxLeft=Math.max(margin,window.innerWidth-margin-width),maxTop=Math.max(margin,window.innerHeight-margin-height);
+  const left=Math.max(margin,Math.min(rect.left,maxLeft)),below=rect.bottom+gap,above=rect.top-gap-height;
+  const top=Math.max(margin,Math.min(below+height<=window.innerHeight-margin||above<margin?below:above,maxTop));
+  popup.style.left=`${left}px`;popup.style.top=`${top}px`;
+ };
+ const scheduleFieldTipPosition=()=>{
+  if(positionFrame)cancelAnimationFrame(positionFrame);
+  positionFrame=requestAnimationFrame(positionFieldTip);
+ };
+ document.addEventListener('pointerover',event=>{
+  const target=fieldTipTarget(event.target);
+  if(target&&!target.contains(event.relatedTarget)){activeFieldTip=target;scheduleFieldTipPosition();}
+ });
+ document.addEventListener('pointerout',event=>{
+  const target=fieldTipTarget(event.target);
+  if(target&&!target.contains(event.relatedTarget))hideFieldTip(target);
+ });
+ document.addEventListener('focusin',event=>{
+  const target=fieldTipTarget(event.target);
+  if(target){activeFieldTip=target;scheduleFieldTipPosition();}
+ });
+ document.addEventListener('focusout',event=>{
+  const target=fieldTipTarget(event.target);
+  if(target&&!target.contains(event.relatedTarget))hideFieldTip(target);
+ });
+ window.addEventListener('resize',scheduleFieldTipPosition);
+ window.addEventListener('scroll',scheduleFieldTipPosition,true);
+}
+initFieldTipPopup();
+const f=n=>Math.round(n||0).toLocaleString();
+const compactNumber=n=>{n=Number(n)||0;const a=Math.abs(n);if(a>=1e9)return (n/1e9).toFixed(a>=1e10?0:1).replace(/\.0$/,'')+'B';if(a>=1e6)return (n/1e6).toFixed(a>=1e7?0:1).replace(/\.0$/,'')+'M';if(a>=1e3)return (n/1e3).toFixed(a>=1e4?0:1).replace(/\.0$/,'')+'K';return f(n);};
+const money=n=>{n=Number(n)||0;const a=Math.abs(n),d=a>=1000?1:2;if(a>0&&a<.005)return n<0?'-<$0.01':'<$0.01';return (n<0?'-':'')+'$'+a.toLocaleString('en-US',{minimumFractionDigits:d,maximumFractionDigits:d});};
+const wholeMoney=n=>`${Number(n||0)<0?'-':''}$${Math.round(Math.abs(Number(n||0))).toLocaleString('en-US')}`;
+const COST_UNAVAILABLE_TIP='Cost is unavailable, not $0. Token Meter can estimate cost only from locally stored usage with an identifiable model and an available configured rate. The local trace may omit billable usage, the model may be unknown or unpriced, or the session may be cloud-hosted without a readable local trace.';
+function setCostValue(id,value,available){
+ const element=$(id);element.textContent=available?value:'--';
+ element.classList.toggle('fieldtip',!available);
+ if(available){
+  element.removeAttribute('tabindex');element.removeAttribute('aria-description');element.removeAttribute('data-tip');
+  return;
+ }
+ element.setAttribute('tabindex','0');element.setAttribute('aria-description',COST_UNAVAILABLE_TIP);element.setAttribute('data-tip',COST_UNAVAILABLE_TIP);
+}
+function costUnavailableAttrs(){const safe=esc(COST_UNAVAILABLE_TIP);return `data-tip="${safe}"`;}
+function costValueHtml(value,available,focusable=true){
+ if(available)return value;
+ if(focusable)return `<span ${tipAttrs(COST_UNAVAILABLE_TIP)}>--</span>`;
+ const safe=esc(COST_UNAVAILABLE_TIP);return `<span class=fieldtip aria-description="${safe}" data-tip="${safe}">--</span>`;
+}
+const pct=n=>Math.round((n||0)*100)+'%';
+const metricAvailable=(row,metric)=>row?.availability?.[metric]!==false;
+const metricText=(row,metric,value,formatter)=>metricAvailable(row,metric)?formatter(value):'--';
+const metricPartial=(row,metric)=>row?.coverage?.[metric]?.complete===false;
+const partialSuffix=(row,metric)=>metricPartial(row,metric)?' · partial':'';
+const usageProvenance=row=>row?.provenance||{};
+const usageBasis=row=>usageProvenance(row).usage_basis||row?.usage_basis||(row?.token_estimate?'local_estimate':'reported');
+const hasLocalEstimate=row=>['local_estimate','mixed'].includes(usageBasis(row))||row?.provider==='cursor';
+const estimateSuffix=row=>usageBasis(row)==='local_estimate'?' est':usageBasis(row)==='mixed'?' incl. est':'';
+const runtimeId=session=>String(session?.provider||session?.runtime_id||session?.client||'unknown-runtime');
+const runtimeMeta=session=>RUNTIME_CATALOG[runtimeId(session)]||RUNTIME_CATALOG['unknown-runtime']||{label:'Unknown Runtime',symbol:'runtime.generic',color:'runtime-neutral',capabilities:['sessions']};
+const runtimeMarkSvg=session=>{
+ const symbol=runtimeMeta(session).symbol;
+ const mark={
+  'runtime.claude':'<path d="M25.7146 63.2153L41.4393 54.3917L41.7025 53.6226L41.4393 53.1976H40.6705L38.0394 53.0359L29.054 52.7929L21.2624 52.4691L13.7134 52.0644L11.8111 51.6594L10.0303 49.3118L10.2123 48.138L11.8111 47.0657L14.0981 47.2681L19.1574 47.6119L26.7467 48.138L32.2516 48.4618L40.4073 49.3118H41.7025L41.8846 48.7857L41.4393 48.4618L41.0955 48.138L33.243 42.8155L24.7432 37.1894L20.2909 33.9513L17.8824 32.3119L16.6684 30.774L16.1422 27.4147L18.328 25.0062L21.2624 25.2088L22.0112 25.4112L24.9861 27.6979L31.3407 32.616L39.6381 38.7273L40.8525 39.7391L41.3381 39.395L41.399 39.1523L40.8525 38.2415L36.3394 30.0858L31.5227 21.7883L29.3775 18.3478L28.811 16.2837C28.6087 15.4334 28.4669 14.7252 28.4669 13.8549L30.9563 10.4753L32.3321 10.0303L35.6515 10.4756L37.0479 11.6897L39.112 16.4052L42.4513 23.8327L47.6321 33.9313L49.15 36.9265L49.9594 39.6991L50.2632 40.5491H50.7894V40.0632L51.2141 34.3766L52.0035 27.3944L52.7726 18.4087L53.0358 15.8793L54.2905 12.8435L56.7795 11.2041L58.7224 12.135L60.3212 14.422L60.0986 15.899L59.1474 22.0718L57.2857 31.7458L56.0713 38.2218H56.7795L57.5892 37.4121L60.8677 33.061L66.3723 26.18L68.801 23.448L71.6342 20.4325L73.4556 18.9957H76.8962L79.4255 22.7601L78.2926 26.6456L74.7509 31.1384L71.8163 34.943L67.607 40.6097L64.9758 45.1431L65.2188 45.5072L65.8464 45.4466L75.358 43.4228L80.4984 42.4917L86.6304 41.4393L89.4033 42.7346L89.7065 44.0502L88.6135 46.7419L82.0566 48.3607L74.3662 49.8989L62.9118 52.6109L62.77 52.7121L62.9321 52.9144L68.0925 53.4L70.2987 53.5214H75.7021L85.7601 54.2702L88.3912 56.0108L89.9697 58.1358L89.7065 59.7545L85.6589 61.8189L80.1949 60.5236L67.4452 57.4881L63.0735 56.3952H62.4665V56.7596L66.1093 60.3213L72.7877 66.3523L81.1461 74.1236L81.5707 76.0462L80.4984 77.5638L79.3649 77.4021L72.0186 71.8772L69.1854 69.3879L62.77 63.9844H62.3453V64.5509L63.8223 66.7164L71.6342 78.4544L72.0389 82.0567L71.4725 83.2308L69.4487 83.939L67.2222 83.534L62.6485 77.1189L57.9333 69.8937L54.1284 63.4177L53.6631 63.6809L51.4167 87.8651L50.3644 89.0995L47.9356 90.0303L45.9121 88.4924L44.8392 86.0031L45.9118 81.0852L47.2071 74.6701L48.2594 69.5699L49.2106 63.2356L49.7773 61.131L49.7367 60.9892L49.2715 61.0498L44.4954 67.607L37.23 77.4224L31.4825 83.5746L30.1063 84.1211L27.7181 82.8864L27.9408 80.6805L29.2763 78.7177L37.2297 68.5988L42.026 62.3248L45.1227 58.7025L45.1024 58.176H44.9204L23.7917 71.8975L20.0274 72.3831L18.4083 70.8655L18.6106 68.3761L19.3798 67.5664L25.7343 63.195L25.7146 63.2153Z" fill="currentColor"/>',
+  'runtime.codex':'<path d="M83.7733 42.8087C84.6678 40.1149 84.9771 37.2613 84.6807 34.4385C84.3843 31.6156 83.489 28.8885 82.0544 26.4394C77.6908 18.8436 68.9203 14.9365 60.3548 16.7725C57.9831 14.1344 54.9591 12.1668 51.5864 11.0673C48.2137 9.96772 44.611 9.77498 41.1402 10.5084C37.6694 11.2418 34.4527 12.8755 31.8132 15.2455C29.1736 17.6155 27.204 20.6383 26.1024 24.0103C23.3212 24.5806 20.6938 25.738 18.3958 27.405C16.0977 29.0721 14.1819 31.2104 12.7765 33.6772C8.36538 41.2609 9.3669 50.8267 15.2527 57.3327C14.3549 60.0251 14.0424 62.8782 14.3361 65.7012C14.6298 68.5241 15.523 71.2518 16.9558 73.7017C21.325 81.3002 30.1011 85.207 38.6712 83.3686C40.5554 85.4904 42.8707 87.1858 45.4623 88.3416C48.0539 89.4975 50.8622 90.0871 53.6999 90.0713C62.4793 90.079 70.2575 84.4114 72.9393 76.0515C75.7201 75.4802 78.347 74.3225 80.6449 72.6555C82.9427 70.9886 84.8587 68.8507 86.2649 66.3846C90.6227 58.8145 89.6172 49.3005 83.7733 42.8087ZM53.6999 84.8356C50.1955 84.8411 46.801 83.6129 44.1116 81.3661L44.5848 81.098L60.5123 71.9043C60.9087 71.6718 61.2379 71.3402 61.4674 70.942C61.6969 70.5439 61.8189 70.0929 61.8215 69.6333V47.1769L68.5553 51.072C68.6225 51.1063 68.6694 51.1707 68.6814 51.2456V69.854C68.6641 78.1208 61.9667 84.8183 53.6999 84.8356ZM21.4977 71.0843C19.7402 68.0497 19.1092 64.4925 19.7156 61.0386L20.1885 61.3225L36.1321 70.5165C36.5266 70.748 36.9757 70.87 37.4331 70.87C37.8905 70.87 38.3396 70.748 38.7341 70.5165L58.21 59.2883V67.0628C58.2081 67.1031 58.1973 67.1424 58.1782 67.1779C58.1591 67.2134 58.1322 67.2441 58.0996 67.2678L41.9671 76.5722C34.798 80.7022 25.6388 78.2463 21.4977 71.0843ZM17.3026 36.3898C19.0723 33.3357 21.8655 31.0062 25.1878 29.8138V48.7376C25.1818 49.1949 25.2986 49.6453 25.5261 50.042C25.7535 50.4387 26.0833 50.7671 26.4809 50.9928L45.8622 62.1739L39.1283 66.069C39.0919 66.0883 39.0513 66.0984 39.0101 66.0984C38.9689 66.0984 38.9283 66.0883 38.8919 66.069L22.7908 56.7809C15.6359 52.6337 13.1822 43.4816 17.3026 36.3112V36.3898ZM72.624 49.2426L53.1792 37.9512L59.8976 34.0718C59.9341 34.0524 59.9747 34.0423 60.016 34.0423C60.0573 34.0423 60.0979 34.0524 60.1344 34.0718L76.2355 43.3761C78.6973 44.7966 80.7043 46.8882 82.0221 49.4065C83.3398 51.9249 83.914 54.7661 83.6775 57.5985C83.4411 60.431 82.4038 63.1377 80.6867 65.4027C78.9696 67.6677 76.6436 69.3975 73.9803 70.3901V51.466C73.9663 51.0096 73.834 50.5647 73.5962 50.1749C73.3584 49.7851 73.0234 49.4638 72.624 49.2426ZM79.3261 39.1657L78.8529 38.8815L62.9411 29.6089C62.5442 29.376 62.0924 29.2532 61.6322 29.2532C61.172 29.2532 60.7202 29.376 60.3233 29.6089L40.8629 40.8374V33.0628C40.8587 33.0233 40.8654 32.9834 40.882 32.9473C40.8987 32.9113 40.9248 32.8803 40.9575 32.8579L57.0586 23.5692C59.5263 22.1476 62.3478 21.458 65.193 21.5811C68.0382 21.7042 70.7896 22.6348 73.1253 24.2642C75.461 25.8936 77.2845 28.1543 78.3825 30.782C79.4806 33.4097 79.8077 36.2957 79.3257 39.1025V39.1657H79.3261ZM37.1888 52.9484L30.455 49.069C30.4213 49.0487 30.3925 49.0212 30.3707 48.9884C30.3488 48.9557 30.3345 48.9186 30.3286 48.8797V30.3188C30.3323 27.4714 31.1466 24.6839 32.6761 22.2822C34.2057 19.8805 36.3874 17.9639 38.9661 16.7564C41.5448 15.549 44.4139 15.1005 47.2381 15.4636C50.0622 15.8267 52.7247 16.9862 54.9141 18.8067L54.4409 19.0748L38.5134 28.2686C38.117 28.5011 37.7879 28.8327 37.5584 29.2308C37.329 29.629 37.207 30.0799 37.2045 30.5395L37.1888 52.9487V52.9484ZM40.8472 45.0632L49.5209 40.0643L58.21 45.0635V55.0615L49.5523 60.0608L40.8632 55.0615L40.8472 45.0632Z" fill="currentColor"/>',
+  'runtime.cursor':'<path d="M84.0704 28.9353L51.9066 10.4454C50.8738 9.85153 49.5994 9.85153 48.5666 10.4454L16.4043 28.9353C15.536 29.4345 15 30.3576 15 31.3575V68.6425C15 69.6424 15.536 70.5655 16.4043 71.0647L48.5681 89.5546C49.6009 90.1485 50.8753 90.1485 51.9081 89.5546L84.0719 71.0647C84.9402 70.5655 85.4762 69.6424 85.4762 68.6425V31.3575C85.4762 30.3576 84.9402 29.4345 84.0719 28.9353H84.0704ZM82.0501 32.8519L51.0006 86.4003C50.7907 86.7611 50.2366 86.6138 50.2366 86.1958V51.1329C50.2366 50.4322 49.8606 49.7842 49.2506 49.4324L18.7553 31.9017C18.3929 31.6927 18.5409 31.141 18.9606 31.141H81.0595C81.9414 31.141 82.4925 32.0927 82.0516 32.8534H82.0501V32.8519Z" fill="currentColor"/>',
+  'runtime.opencode':'<g transform="scale(6.25)"><path d="M6.2 2.5 2 8l4.2 5.5M9.8 2.5 14 8l-4.2 5.5" fill=none stroke=currentColor stroke-width=1.6 stroke-linecap=round stroke-linejoin=round/></g>',
+ }[symbol]||'<g transform="scale(6.25)"><circle cx=8 cy=8 r=5.7 fill=none stroke=currentColor stroke-width=1.4/><circle cx=8 cy=8 r=1.6 fill="currentColor"/></g>';
+ return `<svg class=runtimeMark viewBox="0 0 100 100" aria-hidden=true focusable=false>${mark}</svg>`;
+};
+const runtimeBadgeContent=(session,label)=>`${runtimeMarkSvg(session)}<span>${esc(label)}</span>`;
+const runtimeLabel=session=>session?.runtime||session?.label||runtimeMeta(session).label;
+const PROVIDER_COLOR_IDS=new Set(['claude','codex','cursor','opencode','kiro']);
+const providerColor=id=>PROVIDER_COLOR_IDS.has(id)?`var(--provider-${id})`:'var(--provider-other)';
+const runtimeHarness=session=>providerColor(runtimeId(session));
+const appBadgeClass=session=>PROVIDER_COLOR_IDS.has(runtimeId(session))?runtimeId(session):'neutral';
+const appFilterGroup=session=>runtimeId(session);
+const appFilterLabel=session=>runtimeMeta(session).label||session?.label||session?.runtime||'Unknown app';
+const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
+const speedFmt=n=>{n=Number(n)||0;if(n<=0)return'--';if(n>=100)return n.toFixed(0);if(n>=10)return n.toFixed(1);return n.toFixed(2);};
+const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+// Work page state is declared early: the initial hash route can run before later definitions.
+let WORK=null,workRequest=0,workLastLoadedAt=0,workMonths='6',workRuntime='',workProject='';
+let workSupported=null;
+// Declared before the first route runs: a deep link schedules its scroll during startup.
+let pendingSettingsScroll=null;
+let workSessionFilter=null,workFilterRequest=0;
+let WORK_SETTINGS=null,workAreasDraft=null;
+function durationShort(seconds){
+ seconds=Math.max(0,Math.round(seconds||0));
+ if(seconds<60) return seconds+'s';
+ const minutes=Math.floor(seconds/60);
+ if(minutes<60) return minutes+'m';
+ const hours=Math.floor(minutes/60);
+ if(hours<48) return hours+'h '+String(minutes%60).padStart(2,'0')+'m';
+ const days=Math.floor(hours/24);
+ return days+'d '+String(hours%24).padStart(2,'0')+'h';
+}
+function waitFmt(seconds){
+ seconds=Math.max(0,Number(seconds)||0);
+ if(seconds<10)return seconds.toFixed(1).replace(/\.0$/,'')+'s';
+ const whole=Math.round(seconds);
+ if(whole<60)return whole+'s';
+ const minutes=Math.floor(whole/60),secs=whole%60;
+ if(minutes<60)return minutes+'m '+String(secs).padStart(2,'0')+'s';
+ const hours=Math.floor(minutes/60),rem=minutes%60;
+ if(hours<48)return hours+'h '+String(rem).padStart(2,'0')+'m';
+ const days=Math.floor(hours/24);
+ return days+'d '+String(hours%24).padStart(2,'0')+'h';
+}
+// Readouts pair one number with a reference point and a plain-language reading.
+function typicalComparison(value,typical){
+ value=Number(value);typical=Number(typical);
+ if(!Number.isFinite(value)||!Number.isFinite(typical)||typical<=0)return {ratio:null,band:''};
+ const ratio=value/typical;
+ return {ratio,band:value<=0?'none':ratio>=1.15?'above':ratio<=.85?'below':'near'};
+}
+function typicalCaption(value,typical,noun,typicalText){
+ const {ratio,band}=typicalComparison(value,typical);
+ if(!band)return '';
+ if(band==='none')return `Nothing yet · ${noun} is ${typicalText}`;
+ if(band==='above')return `${ratio>=10?Math.round(ratio):ratio.toFixed(1)}× ${noun} of ${typicalText}`;
+ if(band==='below')return `${Math.round((1-ratio)*100)}% below ${noun} of ${typicalText}`;
+ return `In line with ${noun} of ${typicalText}`;
+}
+function readoutScaleHtml({value,typical,high=0,label='',toned=true}){
+ const {ratio,band}=typicalComparison(value,typical);
+ if(!band)return '';
+ const top=Math.max(Number(high)||0,Number(value)*1.1,Number(typical)*2);
+ const at=Math.min(100,Math.max(0,Number(value)/top*100)),typ=Math.min(100,Number(typical)/top*100);
+ const tone=toned&&ratio>=1.5?'high':'';
+ return `<span class=readoutScale role=img aria-label="${esc(label)}" data-tone="${tone}" style="--at:${at.toFixed(1)}%;--typ:${typ.toFixed(1)}%"><i class=readoutScaleFill></i><i class=readoutScaleTypical></i><i class=readoutScaleMark></i></span>`;
+}
+const medianOf=values=>{const sorted=values.filter(Number.isFinite).sort((a,b)=>a-b);if(!sorted.length)return null;const mid=sorted.length>>1;return sorted.length%2?sorted[mid]:(sorted[mid-1]+sorted[mid])/2;};
+// Baselines come from up to 30 prior active days; today is excluded so it is compared, not averaged in.
+function dailyBaseline(days,todayKey=localDayKey()){
+ const start=new Date(`${todayKey}T12:00:00`);start.setDate(start.getDate()-30);
+ const startKey=localDayKey(start);
+ const prior=(Array.isArray(days)?days:[]).filter(row=>row?.day&&row.day<todayKey&&row.day>=startKey&&Number(row.sessions)>0);
+ const costRows=prior.filter(row=>metricAvailable(row,'cost')&&!metricPartial(row,'cost'));
+ const costs=costRows.map(row=>Number(row.cost)||0),sessions=prior.map(row=>Number(row.sessions)||0);
+ // A median of per-day rates keeps one burst of scripted sessions from swamping the baseline.
+ const sessionCosts=costRows.map(row=>(Number(row.cost)||0)/Number(row.sessions));
+ return {
+  days:prior.length,
+  typicalCost:medianOf(costs),highCost:costs.length?Math.max(...costs):0,
+  typicalSessions:medianOf(sessions),highSessions:sessions.length?Math.max(...sessions):0,
+  sessionCost:medianOf(sessionCosts),
+  estimated:costRows.some(row=>hasLocalEstimate(row)),
+ };
+}
+function idleLabel(seconds){
+ seconds=Math.max(0,Math.round(seconds||0));
+ if(seconds<60) return seconds+'s idle';
+ const minutes=Math.floor(seconds/60);
+ if(minutes<60) return minutes+'m idle';
+ const hours=Math.floor(minutes/60), rem=minutes%60;
+ return hours+'h '+String(rem).padStart(2,'0')+'m idle';
+}
+function dt12(v){
+ const s=String(v||'');
+ if(/\b[ap]m\b/i.test(s)) return s.toLowerCase();
+ return s.replace(/\b(\d{4}-\d{2}-\d{2}) (\d{2}):(\d{2}):(\d{2})\b/,(_,d,h,m,sec)=>{
+  const n=Number(h), hh=String(n%12||12).padStart(2,'0');
+  return `${d} ${hh}:${m}:${sec} ${n>=12?'pm':'am'}`;
+ });
+}
+function costTipHtml(s,tok){
+ if(!metricAvailable(s,'cost'))return `<div class=h>Cost unavailable</div><div class=note>${s.provider==='cursor'?'No supported public rate or input-context evidence was found for this Cursor trace.':'This trace does not expose enough pricing evidence.'}</div>`;
+ const cost=s.cost||{};
+ const rate=(usd,tokens)=>tokens?money((usd||0)*1e6/tokens):'$0.00';
+ const row=(name,tokens,usd)=>tokens||usd?`<div class=r><span class=name>${name}</span><span class=formula>${f(tokens)} x ${rate(usd,tokens)} / 1M</span><span class=amt>${money(usd)}</span></div>`:'';
+ const requestRow=(name,usd)=>usd?`<div class=r><span class=name>${name}</span><span class=formula>${f(Math.round(usd/.01))} x $0.01 / request</span><span class=amt>${money(usd)}</span></div>`:'';
+ const cursor=s.provider==='cursor';
+ const rows=(cursor?[
+  row('Input context proxy',tok.input||0,cost.input||0),
+  row('Visible model output',tok.output||0,cost.output||0),
+ ]:[
+  row('Uncached input',tok.input||0,cost.input||0),
+  row('Cached input',tok.cache_read||0,cost.cache_read||0),
+  row('Cache write',tok.cache_write||0,cost.cache_write||0),
+  row('Output',tok.output||0,cost.output||0),
+  requestRow('Web searches',cost.server_tools||0),
+ ]).join('');
+ const note=s.source?.pricing_note||(cursor?'Local Cursor estimate; cache and hidden model work are excluded.':`${s.cost_approx?'Estimated with public API rates. ':''}Cached input is priced separately from uncached input.`);
+ return `<div class=h>${cursor?'Local cost estimate':'Cost calculation'}</div>${rows}<div class=total><span>Total</span><span>${money(s.total_cost||0)}${s.cost_approx?' est':''}</span></div><div class=note>${esc(note)}</div>`;
+}
+let LATEST=null, CURRENT=null, pinned=null, sessionRequest=0, selectedPollId='', RUNTIME_CATALOG={};
+// Declared early: the first header render looks up trace titles before the All sessions code runs.
+let allSessionInventory=null,allSessionInventoryAt=0,allSessionsRequest=null,renderedAllSessions=new Map(),renderedAllSessionActions={},forceAllSessionRowRefresh=false;
+const LIVE_XSESSION={state:{snapshot:null,revision:''},session:{snapshot:null,revision:''}};
+let AGENT_ACCESS=null, pendingAgentAccess=null, agentAccessLoading=false, agentAccessRechecking=false;
+const CURRENT_SESSION_ORDER_KEY='tm_current_session_order_v1';
+const CURRENT_SESSION_ORDER_LIMIT=200;
+const CURRENT_SESSION_ORDER_MIGRATION_KEY='tm_current_session_newest_first_v1';
+let currentSessionOrder=loadCurrentSessionOrder();
+let currentSessionOrderNeedsNewestMigration=localStorage.getItem(CURRENT_SESSION_ORDER_MIGRATION_KEY)!=='1';
+let currentSessionRuntimeFilter='all',currentSessionActivityFilter='all';
+let currentSessionDragId='',currentSessionDropId='',currentSessionDropAfter=false;
+let currentSessionSuppressClickUntil=0;
+let currentSessionSeenIds=[],currentSessionSeenReady=false;
+const pageSignalReducedMotionQuery=window.matchMedia('(prefers-reduced-motion: reduce)');
+const pageSignalClockStartedAt=performance.now();
+let pageEffectsModulePromise=null,pageEffectsDisabled=false;
+let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
+let activePageSignalMounting=false,activePageSignalGeneration=0;
+let latestSessionSignalSnapshot=null;
+const usageDetails=$('usage-details');
+usageDetails.open=localStorage.getItem('tm_usage_details_open')==='1';
+usageDetails.addEventListener('toggle',()=>localStorage.setItem('tm_usage_details_open',usageDetails.open?'1':'0'));
+
+function routedSessionId(){
+ const match=(location.pathname||'').match(/^\/sessions\/([^/]+)\/?$/);
+ if(!match)return null;
+ try{return decodeURIComponent(match[1]);}catch(e){return null;}
+}
+function sessionRoute(id){return `/sessions/${encodeURIComponent(id)}#summary`;}
+function stateSessionId(state){return state?.source?.id||String(state?.session||'').split('.')[0]||null;}
+function sessionRowKey(row){return String(row?.session||row?.id||'');}
+function stateSessionKey(state){return String(state?.session||stateSessionId(state)||'');}
+const DESKTOP_RESUME_ID=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function desktopSessionTarget(session){
+ const source=session?.source||session||{},provider=String(source.provider||session?.provider||'').toLowerCase();
+ if(provider==='codex'){
+  const id=String(source.id||session?.id||stateSessionId(session)||'').trim();
+  return id?{href:`codex://threads/${encodeURIComponent(id)}`,label:'Open in Codex',title:'Open this session in the Codex desktop app'}:null;
+ }
+ if(provider==='claude'){
+  const resume=String(source.desktop_resume_id||session?.desktop_resume_id||'');
+  return DESKTOP_RESUME_ID.test(resume)?{href:`claude://resume?session=${encodeURIComponent(resume)}`,label:'Open in Claude',title:'Open this session in the Claude desktop app'}:null;
+ }
+ return null;
+}
+function renderDesktopSessionLink(session){
+ const link=$('session-desktop-link'),target=desktopSessionTarget(session);
+ link.hidden=!target;
+ if(target){
+  link.href=target.href;
+  link.textContent=target.label;
+  link.title=target.title;
+  link.setAttribute('aria-label',target.title);
+ }else{
+  link.removeAttribute('href');
+  link.removeAttribute('title');
+ }
+}
+function setHashRoute(route,{replace=false,apply=true}={}){
+ const url=`${location.pathname}${location.search||''}#${route}`;
+ if(history.pushState){
+  history[replace?'replaceState':'pushState'](null,'',url);
+  if(apply)applyHashRoute();
+ }else location.hash=route;
+}
+function openSelectedSessionRoute(route='summary'){
+ if(pinned&&history.pushState){
+  history.pushState({sessionScope:sessionReturnScope},'',sessionRoute(pinned));
+  applyHashRoute();
+  return;
+ }
+ setHashRoute(route);
+}
+const SESSION_SCOPES=['current','all','compare','subagents'];
+let sessionScope='current',sessionReturnScope='current';
+const COMPARE_MAX=4,COMPARE_LETTERS='ABCD',COMPARE_COLORS=THEME.compare;
+function loadCompareIds(){
+ try{
+  const stored=JSON.parse(localStorage.getItem('tm_compare_ids')||'[]');
+  return Array.isArray(stored)?[...new Set(stored.map(String).filter(id=>id&&id.length<=240))].slice(0,COMPARE_MAX):[];
+ }catch(error){return [];}
+}
+let compareIds=loadCompareIds(),compareBaseline=localStorage.getItem('tm_compare_baseline')||'';
+let compareChartMetric=localStorage.getItem('tm_compare_chart')==='tokens'?'tokens':'cost';
+let compareMissing=[],compareData=null,compareError='',compareLoading=false,compareRequestSeq=0,compareLoadedKey='',compareLoadedAt=0,compareNotice='';
+const compareTitles=new Map();
+let compareUiReady=false;
+function normalizeSessionScope(scope){return SESSION_SCOPES.includes(scope)?scope:'current';}
+function sessionScopeRoute(scope){scope=normalizeSessionScope(scope);return scope==='all'?'sessions-all':scope==='compare'?'sessions-compare':scope==='subagents'?'sessions-subagents':'sessions';}
+function sessionScopeLabel(scope){return {all:'All sessions',compare:'Compare',subagents:'Subagents'}[normalizeSessionScope(scope)]||'Current sessions';}
+function sessionListBackAvailable(scope){return !routedSessionId()&&(location.hash||'').replace(/^#/,'')===sessionScopeRoute(scope);}
+function renderSessionBack(){
+ const label=sessionScopeLabel(sessionReturnScope);
+ $('session-back-label').textContent=label;
+ $('session-back').setAttribute('aria-label',`Back to ${label}`);
+}
+function openSessionBack(){
+ const scope=normalizeSessionScope(sessionReturnScope),state=history.state;
+ if(state?.sessionListBack&&normalizeSessionScope(state.sessionScope)===scope&&history.back){history.back();return;}
+ openSessionScope(scope);
+}
+function sessionScopeCopy(scope){
+ return {
+  all:['Local session history.','Search, filter, and compare local session history.'],
+  compare:['Selected sessions side by side.','Compare up to four selected sessions and see which is cheapest and fastest.'],
+  subagents:['Investigate child-agent spend, completion, and role patterns.','Filter child agents, inspect incomplete work, and open their parent sessions.'],
+ }[scope]||['Last 30 minutes','Select a card to inspect it. Drag a card or press ⌥ and an arrow key to reorder.'];
+}
+function renderSessionScope(){
+ const all=sessionScope==='all',subagents=sessionScope==='subagents',compare=sessionScope==='compare',overview=currentPanel==='sessions';
+ $('view-session').classList.toggle('sessionAll',all);
+ $('view-session').classList.toggle('sessionSubagents',subagents);
+ $('view-session').classList.toggle('sessionCompare',compare);
+ $('current-sessions-overview').hidden=all||subagents||compare;
+ $('all-session-history').hidden=!all;
+ $('session-compare').hidden=!compare;
+ if($('subagent-explorer').parentElement===$('preview-surface-sessions'))$('subagent-explorer').hidden=!subagents;
+ [...$('session-scope-tabs').querySelectorAll('[data-session-scope]')].forEach(button=>{
+  const selected=button.dataset.sessionScope===sessionScope;
+  button.setAttribute('aria-selected',String(selected));
+  button.classList.toggle('on',selected);
+  button.tabIndex=selected?0:-1;
+ });
+ if(overview){
+  const [description,help]=sessionScopeCopy(sessionScope);
+  $('current-description').textContent=description;
+  $('session-page-title').setAttribute('aria-description',help);
+ }
+ if(compareUiReady)syncCompareSelectionUi();
+ if(compareUiReady&&compare&&overview){
+  renderComparison();
+  loadComparison();
+  if(!allSessionInventory)loadAllSessions();
+ }
+ if(all&&LATEST){
+  renderAllSessions(LATEST.xsession);
+  loadAllSessions();
+ }
+ if(subagents&&LATEST){renderSubagentExplorer(LATEST.xsession?.agent_usage);loadAllSessions();}
+}
+function setSessionScope(scope){
+ sessionScope=normalizeSessionScope(scope);
+ renderSessionScope();
+}
+function openSessionScope(scope,{replace=false}={}){
+ if(scope==='subagents')mountSubagentExplorer('sessions');
+ sessionRequest++;
+ pinned=null;
+ CURRENT=LATEST;
+ sessionScope=normalizeSessionScope(scope);
+ sessionReturnScope=sessionScope;
+ const route=sessionScopeRoute(sessionScope);
+ if(history.pushState)history[replace?'replaceState':'pushState'](null,'',`/#${route}`);
+ else location.hash=route;
+ applyHashRoute();
+ return sessionScope==='all'?allSessionInventory||[]:sessionScope==='compare'?compareData?.sessions||[]:sessionScope==='subagents'?LATEST?.xsession?.agent_usage?.inventory||[]:LATEST?.xsession?.current_sessions||[];
+}
+
diff --git a/dashboard/js/current-sessions.js b/dashboard/js/current-sessions.js
new file mode 100644
index 00000000..4765f423
--- /dev/null
+++ b/dashboard/js/current-sessions.js
@@ -0,0 +1,635 @@
+const CACHE_RING_TICKS=30,CACHE_RING_SIZE=40;
+function cacheRingState(win,now=Date.now()/1000){
+ const anchor=Number(win?.anchor_ts),windowS=Number(win?.window_s);
+ if(!(anchor>0)||!(windowS>0))return null;
+ const elapsed=Math.max(0,now-anchor),maxS=win.max_window_s==null?null:Number(win.max_window_s);
+ const left=windowS-elapsed,maxLeft=maxS==null?Infinity:maxS-elapsed;
+ const estimate=win.basis!=='recorded',fixed=maxS!=null&&maxS<=windowS;
+ // A documented range or minimum is typical, not guaranteed, so past it the cache may still be warm.
+ const tone=left>120?'good':left>30?'warn':left>0?'bad':(maxLeft>0||(estimate&&!fixed))?'maybe':'cold';
+ return {left,maxLeft,tone,windowS,total:maxS&&maxS>windowS?maxS:windowS,estimate};
+}
+function cacheClock(seconds){
+ const s=Math.max(0,Math.ceil(seconds));
+ return s>=600?`${Math.round(s/60)}m`:`${Math.floor(s/60)}:${String(s%60).padStart(2,'0')}`;
+}
+function cacheWindowLabel(win){
+ const s=Number(win.window_s),max=win.max_window_s==null?null:Number(win.max_window_s);
+ const span=v=>v>=3600?`${v/3600} h`:`${Math.round(v/60)} min`;
+ if(win.basis==='recorded')return `recorded ${span(s)} cache lifetime`;
+ const who=win.source==='openai'?'OpenAI':win.source==='anthropic'?'Anthropic':'The provider';
+ if(max==null)return `${who} documents at least ${span(s)}; estimate`;
+ return max>s?`${who} documents about ${span(s)}–${span(max)}; estimate`:`${who} documents ${span(s)}; estimate`;
+}
+function cacheRingText(win,state){
+ const head=state.left>0
+  ?`Cache ${state.tone==='good'?'warm':'cooling'} · ${state.estimate?'about ':''}${cacheClock(state.left)} left`
+  :state.tone==='maybe'?'Cache may have expired':state.estimate?'Cache likely expired':'Cache expired';
+ const parts=[`${head} (${cacheWindowLabel(win)}).`];
+ if(win.prefix_tokens>0&&win.cold_cost_delta!=null){
+  const cost=win.cold_cost_delta<.05?`under ${money(.1)}`:`about ${money(win.cold_cost_delta)}`;
+  const verb=win.cold_kind==='write'?'re-writes':'re-sends, uncached,';
+  parts.push(`${state.left>0?'After that, the next prompt':'The next prompt'} ${verb} ${compactNumber(win.prefix_tokens)} tokens: ${cost} more than a warm prompt (estimate).`);
+ }else if(!win.cache_reported){
+  parts.push('This agent does not report per-request cache use, so the timer uses the provider’s documented lifetime.');
+ }
+ return parts.join(' ');
+}
+function cacheRingTicks(state,size=CACHE_RING_SIZE,count=CACHE_RING_TICKS){
+ const center=size/2,outer=center-1,length=3;
+ const lit=Math.ceil(Math.max(0,state.left)/state.total*count);
+ const remainingMax=Number.isFinite(state.maxLeft)?state.maxLeft:(state.left>0?state.left:0);
+ const maybe=Math.max(0,Math.ceil(Math.max(0,remainingMax)/state.total*count)-lit);
+ let lines='';
+ for(let i=0;i<count;i++){
+  const angle=i/count*2*Math.PI-Math.PI/2,fromEnd=count-i;
+  const cls=fromEnd<=lit?'':fromEnd<=lit+maybe?'maybe':'off';
+  const x1=center+Math.cos(angle)*(outer-length),y1=center+Math.sin(angle)*(outer-length);
+  const x2=center+Math.cos(angle)*outer,y2=center+Math.sin(angle)*outer;
+  lines+=`<line${cls?` class=${cls}`:''} x1="${x1.toFixed(2)}" y1="${y1.toFixed(2)}" x2="${x2.toFixed(2)}" y2="${y2.toFixed(2)}"/>`;
+ }
+ return `<svg viewBox="0 0 ${size} ${size}" aria-hidden=true>${lines}</svg>`;
+}
+function cacheRingFace(state){return state.left>0?cacheClock(state.left):state.tone==='maybe'?'?':'—';}
+function cacheRingAttrs(win){
+ return `data-cache-window="${esc(JSON.stringify(win))}"`;
+}
+function cacheRingHtml(row){
+ const win=row?.cache_window,state=cacheRingState(win);
+ if(!state)return'';
+ const text=cacheRingText(win,state);
+ return `<span class="cacheRing ${state.tone}" role=img aria-label="${esc(text)}" title="${esc(text)}" ${cacheRingAttrs(win)}>${cacheRingTicks(state)}<b>${cacheRingFace(state)}</b></span>`;
+}
+function tickCacheRings(){
+ document.querySelectorAll('.cacheRing[data-cache-window]').forEach(el=>{
+  let win;try{win=JSON.parse(el.dataset.cacheWindow);}catch(error){return;}
+  const state=cacheRingState(win);if(!state)return;
+  const text=cacheRingText(win,state);
+  el.className=`cacheRing ${state.tone}`;
+  el.setAttribute('aria-label',text);el.setAttribute('title',text);
+  el.innerHTML=`${cacheRingTicks(state)}<b>${cacheRingFace(state)}</b>`;
+ });
+}
+function currentSessionAge(row){
+ const seconds=Math.max(0,Math.round(Date.now()/1000-Number(row?.mtime||0)));
+ if(seconds<60)return `${seconds}s ago`;
+ const minutes=Math.floor(seconds/60);
+ if(minutes<60)return `${minutes}m ago`;
+ return `${Math.floor(minutes/60)}h ago`;
+}
+function currentSessionContext(row){
+ const context=row?.context||{},latest=Number(context.latest||0),window=Number(context.window||0),ratio=Number(context.latest_pct);
+ if(window&&Number.isFinite(ratio))return `${Math.round(Math.max(0,ratio)*100)}%`;
+ if(latest)return `${compactNumber(latest)}${context.estimated?' est':''}`;
+ return '--';
+}
+function currentSessionModelName(value){
+ const raw=String(value||'').trim();
+ if(!raw||raw.toLowerCase()==='unknown')return 'Unknown model';
+ const claude=raw.match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)(?:-.+)?$/i);
+ if(claude)return `Claude ${claude[1][0].toUpperCase()+claude[1].slice(1).toLowerCase()} ${claude[2]}.${claude[3]}`;
+ return raw.split(/[-_]+/).filter(Boolean).map(part=>{
+  const lower=part.toLowerCase();
+  if(lower==='gpt')return 'GPT';
+  if(lower==='ai')return 'AI';
+  if(/^\d/.test(part))return part;
+  return part[0].toUpperCase()+part.slice(1);
+ }).join(' ');
+}
+function loadCurrentSessionOrder(){
+ try{
+  const value=JSON.parse(localStorage.getItem(CURRENT_SESSION_ORDER_KEY)||'[]');
+  return Array.isArray(value)?[...new Set(value.filter(id=>typeof id==='string'&&id).slice(0,CURRENT_SESSION_ORDER_LIMIT))]:[];
+ }catch(error){return [];}
+}
+function saveCurrentSessionOrder(){
+ try{localStorage.setItem(CURRENT_SESSION_ORDER_KEY,JSON.stringify(currentSessionOrder.slice(0,CURRENT_SESSION_ORDER_LIMIT)));}catch(error){}
+}
+function orderedCurrentSessionRows(rows){
+ const source=Array.isArray(rows)?rows:[],byId=new Map(),sourceIds=[];
+ source.forEach(row=>{
+  const id=String(row.id||'');
+  if(!id||byId.has(id))return;
+  byId.set(id,row);sourceIds.push(id);
+ });
+ const known=currentSessionOrder.filter(id=>byId.has(id)),seen=new Set(known);
+ const unseen=sourceIds.filter(id=>!seen.has(id));
+ let next=[...unseen,...known];
+ if(currentSessionOrderNeedsNewestMigration&&sourceIds.length){
+  const newest=sourceIds[0];
+  next=[newest,...next.filter(id=>id!==newest)];
+  currentSessionOrderNeedsNewestMigration=false;
+  try{localStorage.setItem(CURRENT_SESSION_ORDER_MIGRATION_KEY,'1');}catch(error){}
+ }
+ if(next.length!==currentSessionOrder.length||next.some((id,index)=>id!==currentSessionOrder[index])){
+  currentSessionOrder=next;
+  saveCurrentSessionOrder();
+ }
+ return currentSessionOrder.map(id=>byId.get(id)).filter(Boolean);
+}
+function currentSessionPositionMessage(id,index,total){
+ const row=(LATEST?.xsession?.current_sessions||[]).find(item=>String(item.id)===String(id));
+ return `${row?.session_name||row?.project||'Session'} moved to position ${index+1} of ${total}.`;
+}
+function setCurrentSessionOrder(ids){
+ currentSessionOrder=ids;
+ saveCurrentSessionOrder();
+}
+function currentSessionKeyboardMove(allIds,visibleIds,sourceId,delta){
+ const ids=[...allIds].map(String),visible=[...visibleIds].map(String),source=String(sourceId);
+ const from=visible.indexOf(source);
+ if(from<0)return null;
+ const destination=Math.max(0,Math.min(visible.length-1,from+delta));
+ if(destination===from)return null;
+ const target=visible[destination],allFrom=ids.indexOf(source);
+ if(allFrom<0)return null;
+ ids.splice(allFrom,1);
+ const allTarget=ids.indexOf(target);
+ if(allTarget<0)return null;
+ ids.splice(allTarget+(destination>from?1:0),0,source);
+ return {ids,index:destination,total:visible.length};
+}
+function moveCurrentSessionCard(sourceId,targetId,after=false){
+ const ids=orderedCurrentSessionRows(LATEST?.xsession?.current_sessions||[]).map(row=>String(row.id));
+ const from=ids.indexOf(String(sourceId)),target=ids.indexOf(String(targetId));
+ if(from<0||target<0||from===target)return null;
+ const [moved]=ids.splice(from,1);
+ let destination=ids.indexOf(String(targetId))+(after?1:0);
+ destination=Math.max(0,Math.min(ids.length,destination));
+ ids.splice(destination,0,moved);
+ setCurrentSessionOrder(ids);
+ return {index:destination,total:ids.length};
+}
+function moveCurrentSessionCardBy(sourceId,delta){
+ const orderedRows=orderedCurrentSessionRows(LATEST?.xsession?.current_sessions||[]);
+ const result=currentSessionKeyboardMove(
+  orderedRows.map(row=>String(row.id)),
+  currentSessionFilterView(orderedRows,currentSessionRuntimeFilter,currentSessionActivityFilter).rows.map(row=>String(row.id)),
+  sourceId,
+  delta,
+ );
+ if(!result)return null;
+ setCurrentSessionOrder(result.ids);
+ return {index:result.index,total:result.total};
+}
+function clearCurrentSessionDropMarkers(){
+ $('current-session-grid').querySelectorAll('.dropBefore,.dropAfter').forEach(card=>card.classList.remove('dropBefore','dropAfter'));
+ currentSessionDropId='';
+ currentSessionDropAfter=false;
+}
+function currentSessionContextSparkline(row){
+ const context=row?.context||{},windowSize=Math.max(0,Number(context.window)||0);
+ const samples=(Array.isArray(context.samples)?context.samples:[])
+  .map(value=>Math.max(0,Number(value)||0)).filter(value=>Number.isFinite(value));
+ const observed=Math.max(0,Number(context.latest)||0),hasObservedSamples=samples.some(value=>value>0);
+ if(!observed&&!hasObservedSamples)return {html:'',summary:'Context evidence unavailable.'};
+ if(!windowSize)return {
+  html:'<span class=currentSessionContextUnavailable aria-hidden=true>window --</span>',
+  summary:observed
+   ?`Context window unavailable; ${compactNumber(observed)} context tokens observed.`
+   :'Context window and latest token count unavailable.',
+ };
+ if(!samples.length)return {html:'',summary:'Context trajectory unavailable.'};
+ const plotted=samples.slice(-24);
+ const values=plotted.map(value=>value/windowSize);
+ const peak=Math.max(...values),domain=Math.max(1,peak*1.05);
+ const width=96,height=22,padX=2,padY=2,plotHeight=height-padY*2,bottom=height-padY,gap=1;
+ const barWidth=Math.max(1.5,(width-padX*2-gap*(values.length-1))/values.length);
+ const bars=values.map((value,index)=>{
+  const normalized=Math.min(domain,Math.max(0,value))/domain;
+  const barHeight=Math.max(1.5,normalized*plotHeight);
+  const x=padX+index*(barWidth+gap),y=bottom-barHeight;
+  const pressure=value>=.85?' high':value>=.7?' watch':'';
+  const latest=index===values.length-1?' latest':'';
+  return `<rect class="currentSessionContextBar${pressure}${latest}" x="${x.toFixed(2)}" y="${y.toFixed(2)}" width="${barWidth.toFixed(2)}" height="${barHeight.toFixed(2)}" rx=".8"/>`;
+ }).join('');
+ const latest=values[values.length-1];
+ const latestText=pct(latest),peakText=pct(peak);
+ const countText=`${plotted.length} recent ${countWord(plotted.length,'execution')}`;
+ const summary=`Context across ${countText}: ${latestText} latest, ${peakText} peak.`;
+ return {
+  summary,
+  html:`<svg class=currentSessionContextSpark viewBox="0 0 ${width} ${height}" preserveAspectRatio="none" aria-hidden=true><path class=currentSessionContextBaseline d="M${padX},${bottom} H${width-padX}"/>${bars}</svg>`,
+ };
+}
+function focusCurrentSessionCard(id){
+ const card=[...$('current-session-grid').querySelectorAll('[data-current-session-id]')]
+  .find(item=>item.dataset.currentSessionId===String(id));
+ card?.focus();
+}
+function currentSessionActivity(row){
+ const state=['working','waiting','recent'].includes(row?.activity_state)?row.activity_state:'recent';
+ return {state,label:{working:'Working',waiting:'Waiting',recent:'Recent'}[state]};
+}
+function currentSessionIdsMatch(ids,rows){
+ const mounted=[...ids].map(String),expected=(Array.isArray(rows)?rows:[]).map(row=>String(row.id||''));
+ return mounted.length===expected.length&&mounted.every((id,index)=>id===expected[index]);
+}
+function sessionFlowSnapshot(rows,seenIds=[],seenReady=false){
+ if(!Array.isArray(rows))return {evidence:'unavailable',mode:'idle',count:0,working:0,waiting:0,recent:0,ids:[],arriving:[]};
+ const ids=[],states={working:0,waiting:0,recent:0},known=new Set();
+ rows.forEach(row=>{
+  const id=String(row?.id||'');
+  if(!id||known.has(id))return;
+  known.add(id);ids.push(id);
+  const state=['working','waiting','recent'].includes(row?.activity_state)?row.activity_state:'recent';
+  states[state]++;
+ });
+ const previous=new Set((Array.isArray(seenIds)?seenIds:[]).map(String));
+ return {
+  evidence:'available',
+  mode:states.working?'working':states.waiting?'waiting':states.recent?'recent':'idle',
+  count:ids.length,
+  working:states.working,
+  waiting:states.waiting,
+  recent:states.recent,
+  ids,
+ arriving:seenReady?ids.filter(id=>!previous.has(id)):[],
+ };
+}
+function pageSignalTiming(reducedMotion=false,now=performance.now()){
+ const elapsed=Math.max(0,now-pageSignalClockStartedAt);
+ return {heroSpeed:reducedMotion?0:.018,heroFrame:elapsed*.018,borderSpeed:reducedMotion?0:.016,borderFrame:9000+elapsed*.016};
+}
+function sessionSignalPresentation(snapshot,reducedMotion=false){
+ const mode=snapshot?.evidence==='available'&&['working','waiting','recent','idle'].includes(snapshot.mode)?snapshot.mode:'unavailable';
+ const strengths={working:1,waiting:.92,recent:.84,idle:.72,unavailable:.62};
+ return {...pageSignalTiming(reducedMotion||mode==='unavailable'),mode,heroStrength:strengths[mode]};
+}
+function loadPageEffectsModule(){
+ if(!pageEffectsModulePromise)pageEffectsModulePromise=import('/assets/session-effects.js');
+ return pageEffectsModulePromise;
+}
+function ensurePageSignalHosts(head){
+ let field=head.querySelector('.pageSignalField'),heroHost=head.querySelector('.pageDither');
+ if(!field){
+  field=document.createElement('div');field.className='pageSignalField';field.setAttribute('aria-hidden','true');
+  heroHost=document.createElement('div');heroHost.className='pageDither';
+  const fallback=document.createElement('div');fallback.className='pageSignalFallback';
+  field.append(heroHost,fallback);head.appendChild(field);
+ }
+ let borderHost=head.querySelector('.pageHeroBorder');
+ if(!borderHost){borderHost=document.createElement('div');borderHost.className='pageHeroBorder';borderHost.setAttribute('aria-hidden','true');head.appendChild(borderHost);}
+ return {heroHost,borderHost};
+}
+function pageSignalPresentation(head){
+ if(head?.dataset.pageSignal==='sessions'&&latestSessionSignalSnapshot){
+  return sessionSignalPresentation(latestSessionSignalSnapshot,pageSignalReducedMotionQuery.matches);
+ }
+ return {...pageSignalTiming(pageSignalReducedMotionQuery.matches),mode:'ambient',heroStrength:.76};
+}
+function pageSignalHandle(handle){
+ let disposed=false;
+ return {
+  update(presentation){if(!disposed)handle.update(presentation);},
+  dispose(){if(disposed)return;disposed=true;handle.dispose();},
+ };
+}
+function disposeActivePageSignalEffects(){
+ activePageSignalGeneration++;
+ activePageHeroHandle?.dispose();activePageBorderHandle?.dispose();
+ activePageHeroHandle=null;activePageBorderHandle=null;activePageSignalHead=null;activePageSignalMounting=false;
+}
+async function syncActivePageSignalEffects(){
+ let head=document.querySelector('.view.on .spectrumPageHead[data-page-signal]');
+ if(head?.closest('#view-session.sessionDetail'))head=null;
+ if(!head){disposeActivePageSignalEffects();return;}
+ const presentation=pageSignalPresentation(head);
+ if(activePageSignalHead===head&&activePageHeroHandle&&activePageBorderHandle){
+  activePageHeroHandle.update(presentation);activePageBorderHandle.update(presentation);return;
+ }
+ if(activePageSignalHead===head&&activePageSignalMounting)return;
+ disposeActivePageSignalEffects();activePageSignalHead=head;
+ const generation=++activePageSignalGeneration,{heroHost,borderHost}=ensurePageSignalHosts(head);
+ heroHost.dataset.pageEffect=pageEffectsDisabled?'fallback':'loading';borderHost.dataset.pageEffect=pageEffectsDisabled?'fallback':'loading';
+ if(pageEffectsDisabled)return;
+ activePageSignalMounting=true;
+ let heroHandle=null,borderHandle=null;
+ const mountIsCurrent=()=>generation===activePageSignalGeneration&&activePageSignalHead===head&&head.isConnected;
+ try{
+  const module=await loadPageEffectsModule();
+  if(!mountIsCurrent())return;
+  heroHandle=pageSignalHandle(await module.mountDitherField(heroHost,presentation));
+  if(!mountIsCurrent()){heroHandle.dispose();return;}
+  activePageHeroHandle=heroHandle;
+  const mountedBorder=await module.mountPulsingBorder(borderHost,presentation,mountIsCurrent);
+  if(!mountedBorder)return;
+  borderHandle=pageSignalHandle(mountedBorder);
+  if(!mountIsCurrent()){heroHandle.dispose();borderHandle.dispose();return;}
+  activePageBorderHandle=borderHandle;
+ }catch(error){
+  heroHandle?.dispose();borderHandle?.dispose();
+  if(activePageHeroHandle===heroHandle)activePageHeroHandle=null;
+  if(activePageBorderHandle===borderHandle)activePageBorderHandle=null;
+  if(mountIsCurrent()){
+   pageEffectsDisabled=true;
+   heroHost.replaceChildren();borderHost.replaceChildren();heroHost.dataset.pageEffect='fallback';borderHost.dataset.pageEffect='fallback';
+  }
+ }finally{
+  if(generation===activePageSignalGeneration)activePageSignalMounting=false;
+ }
+}
+function syncSessionSignal(snapshot){
+ latestSessionSignalSnapshot=snapshot;
+ if(activePageSignalHead?.dataset.pageSignal==='sessions')syncActivePageSignalEffects();
+}
+function syncSessionFlow(snapshot){
+ const head=$('session-flow-head'),label=$('session-flow-label');
+ if(!head||!label)return;
+ const mode=snapshot.evidence==='available'?snapshot.mode:'unavailable';
+ head.dataset.sessionFlow=mode;head.closest('.spectrumPageHeadFrame').dataset.sessionFlow=mode;
+ const count=snapshot.count,activeLabel=`${count} active`;
+ const nextLabel=snapshot.evidence!=='available'?'Waiting for evidence':!count?'Listening':snapshot.working?`${snapshot.working} working · ${activeLabel}`:activeLabel;
+ if(label.textContent!==nextLabel)label.textContent=nextLabel;
+ syncSessionSignal(snapshot);
+}
+pageSignalReducedMotionQuery.addEventListener?.('change',syncActivePageSignalEffects);
+function syncCurrentSessionActivity(root,rows){
+ const byId=new Map();
+ rows.forEach(row=>{const id=String(row.id||'');if(id&&!byId.has(id))byId.set(id,row);});
+ root.querySelectorAll('.currentSessionCard[data-current-session-id]').forEach(card=>{
+  const row=byId.get(card.dataset.currentSessionId);
+  if(!row)return;
+  const {state,label}=currentSessionActivity(row),status=card.querySelector('.currentSessionStatus');
+  card.classList.remove('activity-working','activity-waiting','activity-recent');
+  card.classList.add(`activity-${state}`);
+  if(status){status.className=`currentSessionStatus ${state}`;status.textContent=label;}
+ });
+}
+function renderCurrentDaySummary(xs){
+ if(!Array.isArray(xs?.daily)){
+  // No cross-session payload yet means loading (no note); a payload without daily rows is unavailable.
+  const note=xs&&typeof xs==='object'?'Unavailable':'';
+  $('current-day-spend').textContent='--';$('current-day-spend-note').textContent=note;
+  $('current-day-sessions').textContent='--';$('current-day-sessions-note').textContent=note;
+  $('current-day-vs-yesterday').textContent='--';$('current-day-vs-yesterday-note').textContent=note;
+  return;
+ }
+ const days=xs.daily;
+ const todayKey=localDayKey(),yesterdayDate=new Date();
+ yesterdayDate.setHours(12,0,0,0);
+ yesterdayDate.setDate(yesterdayDate.getDate()-1);
+ const yesterdayKey=localDayKey(yesterdayDate);
+ const today=days.find(row=>row.day===todayKey),yesterday=days.find(row=>row.day===yesterdayKey);
+ const todayCostAvailable=Boolean(today)&&metricAvailable(today,'cost'),todayPartial=Boolean(today)&&metricPartial(today,'cost');
+ const yesterdayCostAvailable=Boolean(yesterday)&&metricAvailable(yesterday,'cost'),yesterdayPartial=Boolean(yesterday)&&metricPartial(yesterday,'cost');
+ setCostValue('current-day-spend',money(today?.cost),todayCostAvailable);
+ // The value carries no estimate suffix, so the note always says when today includes local estimates.
+ $('current-day-spend-note').textContent=!today?'No recorded activity today':!todayCostAvailable?'Cost unavailable':todayPartial?`Partial billing coverage${hasLocalEstimate(today)?' · includes estimates':''}`:`${Number(today.discount_usd||0)>0?`After discounts · list ${money(Number(today.cost||0)+Number(today.discount_usd||0))}`:'API-equivalent estimate'}${hasLocalEstimate(today)?' · includes local estimates':''}`;
+ const todaySessions=Number(today?.sessions||0),yesterdaySessions=Number(yesterday?.sessions||0),sessionDelta=todaySessions-yesterdaySessions;
+ $('current-day-sessions').textContent=f(todaySessions);
+ $('current-day-sessions-note').textContent=!today?(yesterday?`${f(yesterdaySessions)} yesterday · none recorded today`:'No recorded sessions today'):yesterday?`${f(yesterdaySessions)} yesterday${sessionDelta?` · ${f(Math.abs(sessionDelta))} ${countWord(Math.abs(sessionDelta),'session')} ${sessionDelta>0?'more':'fewer'}`:' · unchanged'}`:'No recorded sessions yesterday';
+ let comparison='--',comparisonNote='No recorded activity today';
+ if(today&&todayCostAvailable){
+  // Partial billing coverage still compares the recorded spend; the note says which day is partial.
+  const partial=todayPartial&&yesterdayPartial?' · both days partial':todayPartial?' · today partial':yesterdayPartial?' · yesterday partial':'';
+  if(!yesterday){comparison=Number(today.cost||0)?'New':'0%';comparisonNote=`No recorded spend yesterday${todayPartial?' · today partial':''}`;}
+  else if(!yesterdayCostAvailable)comparisonNote='Yesterday cost unavailable';
+  else{comparison=dailyDeltaLabel(today.cost,yesterday.cost);comparisonNote=`vs ${money(yesterday.cost)}${hasLocalEstimate(yesterday)?' est':''} yesterday${partial}`;}
+ }
+ $('current-day-vs-yesterday').textContent=comparison;
+ $('current-day-vs-yesterday-note').textContent=comparisonNote;
+}
+function currentSessionsIdleHistory(xs,todayKey=localDayKey()){
+ const rows=Array.isArray(xs?.daily)?xs.daily:[];
+ const end=new Date(`${todayKey}T12:00:00`);
+ const byDay=new Map(rows.map(row=>[row.day,row]));
+ const dayKey=date=>`${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;
+ const days=Array.from({length:7},(_,index)=>{
+  const date=new Date(end);
+  date.setDate(end.getDate()-6+index);
+  const day=dayKey(date),row=byDay.get(day);
+  return {day,sessions:Math.max(0,Number(row?.sessions)||0)};
+ });
+ const activeRows=days.map(day=>byDay.get(day.day)).filter(row=>row&&Number(row.sessions)>0);
+ const availableCostRows=activeRows.filter(row=>row.availability?.cost!==false);
+ const runtimes=[...new Set(activeRows.flatMap(row=>(row.providers||[]).map(provider=>String(provider?.provider||'').trim()).filter(Boolean)))].sort();
+ return {
+  days,
+  sessions:days.reduce((total,day)=>total+day.sessions,0),
+  cost:availableCostRows.reduce((total,row)=>total+(Number(row.cost)||0),0),
+  costAvailable:availableCostRows.length>0,
+  costPartial:activeRows.some(row=>row.availability?.cost===false||row.coverage?.cost?.complete===false),
+  costEstimated:availableCostRows.some(row=>['local_estimate','mixed'].includes(row.usage_basis)||Number(row.provenance?.estimated_sessions)>0),
+  runtimes,
+ };
+}
+function currentSessionsEmptyHtml(xs,todayKey=localDayKey()){
+ const history=currentSessionsIdleHistory(xs,todayKey),maxSessions=Math.max(1,...history.days.map(day=>day.sessions));
+ const costText=history.costAvailable?`${history.costPartial?'At least ':''}${money(history.cost)}${history.costEstimated?' est':''} tracked`:'Spend unavailable';
+ const runtimeText=`${f(history.runtimes.length)} ${countWord(history.runtimes.length,'runtime')}`;
+ const historyTitle=history.sessions?`${f(history.sessions)} past ${countWord(history.sessions,'session')}`:'No past sessions yet';
+ const historyDetail=history.sessions?`over 7 days · <b>${esc(costText)}</b> · <b>${esc(runtimeText)}</b>`:'Your seven-day activity will build here.';
+ const horizonLabel=history.days.map(day=>`${new Date(`${day.day}T12:00:00`).toLocaleDateString([],{weekday:'short'})} ${day.sessions}`).join(', ');
+ const horizon=history.days.map(day=>{
+  const weekday=new Date(`${day.day}T12:00:00`).toLocaleDateString([],{weekday:'short'});
+  const height=day.sessions?Math.max(7,Math.round(62*day.sessions/maxSessions)):0;
+  return `<div class=currentSessionsHistoryDay aria-hidden=true><span class=currentSessionsHistoryValue>${f(day.sessions)}</span><i class=currentSessionsHistoryBar style="--activity:${height}px"></i><small data-short="${esc(weekday.slice(0,1))}">${esc(weekday)}</small></div>`;
+ }).join('');
+ const historyAction=history.sessions?`<button class=currentSessionsEmptyAction type=button data-current-empty-history>Explore ${f(history.sessions)} past ${countWord(history.sessions,'session')}<svg viewBox="0 0 16 16" aria-hidden=true><path d="M3 8h9M9 4l4 4-4 4"/></svg></button>`:'';
+ return `<section class="card currentSessionsEmpty"><div class=currentSessionsEmptyInner><h3>Your next live session appears here</h3><p class=currentSessionsEmptyCopy>Start a supported agent. Its live card appears here.</p><div class=currentSessionsArrival role=group aria-label="Placeholder for the next live session card"><div class=currentSessionsArrivalHead><strong>Next live session</strong><span>Listening</span></div><div class=currentSessionsArrivalMetrics><div class=currentSessionsArrivalMetric><span>Cost</span><strong>--</strong></div><div class=currentSessionsArrivalMetric><span>Output / $</span><strong>--</strong></div><div class=currentSessionsArrivalMetric><span>Context in use</span><strong>--</strong></div><div class=currentSessionsArrivalMetric><span>Speed</span><strong>--</strong></div></div></div><div class=currentSessionsHistorySummary><strong>${esc(historyTitle)}</strong><span>${historyDetail}</span></div><div class=currentSessionsHorizon role=img aria-label="Sessions over the last seven days: ${esc(horizonLabel)}">${horizon}</div><div class=currentSessionsEmptyActions>${historyAction}<a class="currentSessionsEmptyAction secondary" href="https://github.com/splunk/token-meter/issues" target=_blank rel="noopener noreferrer">Share feedback<svg viewBox="0 0 16 16" aria-hidden=true><path d="M6 3h7v7M13 3 6 10M11 9v4H3V5h4"/></svg></a></div></div></section>`;
+}
+function currentSessionsFilteredEmptyHtml(activitySelection){
+ const activity=activitySelection==='recent'?'recent':'working';
+ return `<section class="card currentSessionsEmpty currentSessionsFilteredEmpty"><div class=currentSessionsEmptyInner><h3>No ${activity} sessions right now</h3><p class=currentSessionsEmptyCopy>Filters are still active. Matching live sessions will appear here automatically.</p></div></section>`;
+}
+function currentSessionRuntimeView(rows,selection='all'){
+ const source=Array.isArray(rows)?[...rows]:[],byId=new Map();
+ source.forEach(row=>{
+  const id=String(appFilterGroup(row)||'unknown-runtime'),label=String(appFilterLabel(row)||'Unknown Runtime');
+  const option=byId.get(id)||{id,label,count:0};
+  option.count+=1;byId.set(id,option);
+ });
+ const options=[...byId.values()].sort((a,b)=>a.label.localeCompare(b.label)||a.id.localeCompare(b.id));
+ const active=selection==='all'||options.some(option=>option.id===selection)?selection:'all';
+ const visible=active==='all'?source:source.filter(row=>String(appFilterGroup(row)||'unknown-runtime')===active);
+ return {options,selection:active,rows:visible,countLabel:active==='all'?`${source.length} active`:`${visible.length} of ${source.length} active`};
+}
+function currentSessionFilterView(rows,runtimeSelection='all',activitySelection='all'){
+ const source=Array.isArray(rows)?[...rows]:[];
+ const runtimeView=currentSessionRuntimeView(source,runtimeSelection);
+ const activity=['all','working','recent'].includes(activitySelection)?activitySelection:'all';
+ const visible=activity==='all'?runtimeView.rows:runtimeView.rows.filter(row=>currentSessionActivity(row).state===activity);
+ const filtered=runtimeView.selection!=='all'||activity!=='all';
+ return {...runtimeView,activitySelection:activity,rows:visible,countLabel:filtered?`${visible.length} of ${source.length} active`:`${source.length} active`};
+}
+function currentSessionFilterFocusTarget(view,focusedFilter){
+ if(!focusedFilter)return '';
+ const ids=['all',...view.options.map(option=>option.id)];
+ return ids.includes(focusedFilter)?focusedFilter:view.selection;
+}
+function renderCurrentSessionRuntimeFilters(view){
+ const root=$('current-session-runtime-filters'),signature=JSON.stringify(view.options.map(({id,label})=>[id,label]));
+ const focusedFilter=root.contains(document.activeElement)?document.activeElement.dataset.currentRuntimeFilter||'':'';
+ let optionsChanged=false;
+ root.hidden=!view.options.length;
+ $('current-session-runtime-filter-group').hidden=root.hidden;
+ if(root.dataset.options!==signature){
+  optionsChanged=true;
+  root.dataset.options=signature;
+  root.innerHTML=`<button type=button data-current-runtime-filter=all>All</button>`+view.options.map(option=>`<button type=button data-current-runtime-filter="${esc(option.id)}">${esc(option.label)}</button>`).join('');
+ }
+ root.querySelectorAll('[data-current-runtime-filter]').forEach(button=>{
+  const selected=button.dataset.currentRuntimeFilter===view.selection;
+  button.classList.toggle('on',selected);button.setAttribute('aria-pressed',selected?'true':'false');
+ });
+ if(optionsChanged&&focusedFilter){
+  const target=currentSessionFilterFocusTarget(view,focusedFilter);
+  [...root.querySelectorAll('[data-current-runtime-filter]')].find(button=>button.dataset.currentRuntimeFilter===target)?.focus();
+ }
+}
+function renderCurrentSessionActivityFilters(selection){
+ const root=$('current-session-activity-filters');
+ $('current-session-activity-filter-group').hidden=false;
+ root.querySelectorAll('[data-current-activity-filter]').forEach(button=>{
+  const selected=button.dataset.currentActivityFilter===selection;
+  button.classList.toggle('on',selected);button.setAttribute('aria-pressed',selected?'true':'false');
+ });
+}
+function renderCurrentSessions(state=LATEST){
+ renderCurrentDaySummary(state?.xsession);
+ const sourceRows=state?.xsession?.current_sessions;
+ const flow=sessionFlowSnapshot(sourceRows,currentSessionSeenIds,currentSessionSeenReady);
+ syncSessionFlow(flow);
+ if(!Array.isArray(sourceRows)){
+  $('current-session-runtime-filters').hidden=true;
+  $('current-session-runtime-filter-group').hidden=true;
+  $('current-session-activity-filters').hidden=true;
+  $('current-session-activity-filter-group').hidden=true;
+  $('current-session-count-label').textContent='Waiting';
+  return;
+ }
+ const orderedRows=orderedCurrentSessionRows(sourceRows),filterView=currentSessionFilterView(orderedRows,currentSessionRuntimeFilter,currentSessionActivityFilter);
+ currentSessionSeenIds=flow.ids;currentSessionSeenReady=true;
+ currentSessionRuntimeFilter=filterView.selection;
+ currentSessionActivityFilter=filterView.activitySelection;
+ renderCurrentSessionRuntimeFilters(filterView);
+ $('current-session-activity-filters').hidden=false;
+ renderCurrentSessionActivityFilters(filterView.activitySelection);
+ const rows=filterView.rows,count=rows.length;
+ const arrivingIds=new Set(flow.arriving);
+ const baseline=dailyBaseline(state?.xsession?.daily),sessionTypical=baseline.sessionCost;
+ const sessionTypicalText=sessionTypical>0?money(sessionTypical)+(baseline.estimated?' est':''):'';
+ const focusedId=document.activeElement?.closest?.('[data-current-session-id]')?.dataset.currentSessionId||'';
+ $('current-session-count-label').textContent=filterView.countLabel;
+ const currentGrid=$('current-session-grid'),interactingCurrentSessionCard=currentGrid.querySelector('.currentSessionSlot:hover,.currentSessionCard:focus,.currentSessionDesktop:focus');
+ const mountedCurrentSessionIds=[...currentGrid.querySelectorAll('.currentSessionCard[data-current-session-id]')].map(card=>card.dataset.currentSessionId);
+ if(currentSessionDragId||(interactingCurrentSessionCard&&currentSessionIdsMatch(mountedCurrentSessionIds,rows))){syncCurrentSessionActivity(currentGrid,rows);return;}
+ currentGrid.innerHTML=count?rows.map(row=>{
+  const provider=runtimeId(row);
+  const {state:activity,label:activityLabel}=currentSessionActivity(row);
+  const costAvailable=row.availability?.cost!==false;
+  const estimate=row.cost_approx||['local_estimate','mixed'].includes(row.usage_basis);
+  // A folded family with an unmeasured member reports a lower bound.
+  const costPartial=costAvailable&&!!row.cost_partial;
+  const cost=costValueHtml(money(row.cost)+(estimate?' est':''),costAvailable,false),costLabel=costPartial?'Cost, at least':'Cost';
+  const costTipAttrs=costAvailable?'':costUnavailableAttrs();
+  const outputPerDollar=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar);
+  const context=currentSessionContext(row);
+  const runtime=runtimeLabel(row),model=currentSessionModelName(row.primary_model);
+  const effort=String(row.reasoning_effort||'').trim().replaceAll('_',' ');
+  const runtimeLine=`${runtime} / ${model}${effort?` ${effort}`:''}`;
+  const sessionName=row.session_name||row.project||'Untitled session';
+	  const throughput=sessionDisplayThroughput(row),speedAvailable=row.availability?.throughput!==false&&throughput.available;
+  const speed=speedAvailable?`${speedFmt(throughput.output_tps)} tok/s${row.token_estimate?' est':''}`:'--';
+  const contextSpark=currentSessionContextSparkline(row);
+  const outputDollarDescription=row.output_per_dollar==null?'Output per dollar unavailable.':`${compactNumber(row.output_per_dollar)} output tokens per covered dollar.`;
+  const costComparable=costAvailable&&!costPartial&&sessionTypical>0;
+  const heroCaption=costComparable?typicalCaption(Number(row.cost)||0,sessionTypical,'your typical session',sessionTypicalText):'';
+  const heroScale=costComparable?readoutScaleHtml({value:Number(row.cost)||0,typical:sessionTypical,label:`${money(row.cost)} against a typical session of ${sessionTypicalText}`}):'';
+  const hints=(row.hints||[]).slice(0,3);
+  const hintText=hints.map(hint=>`${hint.title}: ${hint.detail}`).join(' ');
+  const cardDescription=`${heroCaption?heroCaption+'. ':''}${contextSpark.summary} ${outputDollarDescription}${costPartial?' Cost is a lower bound: some runs in this session family have no cost evidence.':''}${hints.length?` Suggestion${hints.length===1?'':'s'}: ${hintText}`:''} Drag to reorder. Press ⌥ and an arrow key to move.`;
+  const hintsHtml=hints.length?`<div class=currentSessionHints>${hints.map(hint=>`<span class=currentSessionHint data-kind="${esc(hint.kind)}" title="${esc(hint.detail)}"><b>${esc(hint.title)}</b><small>${esc(hint.detail)}</small></span>`).join('')}</div>`:'';
+  const arriving=arrivingIds.has(String(row.id))?' is-arriving':'';
+  const desktop=desktopSessionTarget(row);
+  const desktopLink=desktop?`<a class=currentSessionDesktop href="${esc(desktop.href)}" draggable=false title="${esc(desktop.title)}" aria-label="${esc(`${desktop.label}: ${sessionName}`)}"><svg viewBox="0 0 16 16" aria-hidden=true><path d="M9.5 2.5h4v4M13.5 2.5 7.5 8.5M12 9.5v3a1 1 0 0 1-1 1H3.5a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h3"/></svg></a>`:'';
+  return `<div class=currentSessionSlot${desktop?' data-desktop':''}><button class="card currentSessionCard provider-${esc(provider)} activity-${activity}${arriving}${costAvailable?'':' fieldtip'}" style="--harness:${esc(runtimeHarness(row))}" type=button draggable=true data-current-session-id="${esc(row.id)}" aria-label="${esc(`Open ${sessionName}`)}" aria-description="${esc(cardDescription)}" aria-keyshortcuts="Alt+ArrowLeft Alt+ArrowRight Alt+ArrowUp Alt+ArrowDown" ${costTipAttrs}><div class=currentSessionTop><div class=currentSessionRuntime>${runtimeMarkSvg(row)}<span>${esc(runtimeLine)}</span><span class=currentSessionProject>${esc(row.project||'No project')}</span></div><div class=currentSessionTopMeta><span class=currentSessionMove><svg class=currentSessionGrip viewBox="0 0 12 16" aria-hidden=true><circle cx="3" cy="3" r="1.2"/><circle cx="9" cy="3" r="1.2"/><circle cx="3" cy="8" r="1.2"/><circle cx="9" cy="8" r="1.2"/><circle cx="3" cy="13" r="1.2"/><circle cx="9" cy="13" r="1.2"/></svg>${currentSessionAge(row)}</span>${cacheRingHtml(row)}<div class="currentSessionStatus ${activity}">${activityLabel}</div></div></div><div class=currentSessionIdentity><h3>${esc(sessionName)}</h3><span class="currentSessionCaps mono" title="${esc(CAPABILITY_SUMMARY_TIP)}">${esc(capabilitySummaryText(row.capabilities))}</span></div><div class=currentSessionHero><div class=currentSessionHeroCost><span class=currentSessionHeroLabel>${costLabel}</span><b class="currentSessionHeroValue mono">${cost}</b></div><div class=currentSessionHeroCompare>${heroScale}${heroCaption?`<span class=readoutCaption>${esc(heroCaption)}</span>`:''}</div></div><div class=currentSessionMetrics><div class="currentSessionMetric metric"><span>Output / $</span><b class=mono>${esc(outputPerDollar)}</b></div><div class="currentSessionMetric metric"><span>Context in use</span><div class=currentSessionContextValue><b class=mono>${esc(context)}</b>${contextSpark.html}</div></div><div class="currentSessionMetric metric"><span>Speed</span><b class=mono>${esc(speed)}</b></div></div>${hintsHtml}</button>${desktopLink}</div>`;
+ }).join(''):(filterView.activitySelection==='all'?currentSessionsEmptyHtml(state?.xsession):currentSessionsFilteredEmptyHtml(filterView.activitySelection));
+ if(focusedId)requestAnimationFrame(()=>focusCurrentSessionCard(focusedId));
+}
+function keepCurrentSessionFilterFocusVisible(event){
+ const button=event.target.closest('button');
+ if(button)button.scrollIntoView({block:'nearest',inline:'nearest'});
+}
+const currentSessionRuntimeFilters=$('current-session-runtime-filters');
+currentSessionRuntimeFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);
+currentSessionRuntimeFilters.onclick=event=>{
+ const button=event.target.closest('[data-current-runtime-filter]');
+ if(!button)return;
+ currentSessionRuntimeFilter=button.dataset.currentRuntimeFilter||'all';
+ renderCurrentSessions();
+};
+const currentSessionActivityFilters=$('current-session-activity-filters');
+currentSessionActivityFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);
+currentSessionActivityFilters.onclick=event=>{
+ const button=event.target.closest('[data-current-activity-filter]');
+ if(!button)return;
+ currentSessionActivityFilter=button.dataset.currentActivityFilter||'all';
+ renderCurrentSessions();
+};
+const currentSessionGrid=$('current-session-grid');
+currentSessionGrid.onclick=event=>{
+ if(Date.now()<currentSessionSuppressClickUntil){event.preventDefault();return;}
+ const historyAction=event.target.closest('[data-current-empty-history]');
+ if(historyAction){openSessionScope('all');return;}
+ const card=event.target.closest('[data-current-session-id]');
+ if(card)selectSession(card.dataset.currentSessionId);
+};
+currentSessionGrid.addEventListener('dragstart',event=>{
+ const card=event.target.closest('[data-current-session-id]');
+ if(!card)return;
+ currentSessionDragId=card.dataset.currentSessionId;
+ card.classList.add('dragging');
+ if(event.dataTransfer){
+  event.dataTransfer.effectAllowed='move';
+  event.dataTransfer.setData('text/plain',currentSessionDragId);
+ }
+});
+currentSessionGrid.addEventListener('dragover',event=>{
+ if(!currentSessionDragId)return;
+ const card=event.target.closest('[data-current-session-id]');
+ if(!card||card.dataset.currentSessionId===currentSessionDragId){clearCurrentSessionDropMarkers();return;}
+ event.preventDefault();
+ if(event.dataTransfer)event.dataTransfer.dropEffect='move';
+ const rect=card.getBoundingClientRect();
+ const columns=getComputedStyle(currentSessionGrid).gridTemplateColumns.trim().split(/\s+/).length;
+ const after=columns===1?event.clientY>rect.top+rect.height/2:event.clientX>rect.left+rect.width/2;
+ if(currentSessionDropId!==card.dataset.currentSessionId||currentSessionDropAfter!==after){
+  clearCurrentSessionDropMarkers();
+  currentSessionDropId=card.dataset.currentSessionId;
+  currentSessionDropAfter=after;
+  card.classList.add(after?'dropAfter':'dropBefore');
+ }
+});
+currentSessionGrid.addEventListener('drop',event=>{
+ const card=event.target.closest('[data-current-session-id]');
+ if(!currentSessionDragId||!currentSessionDropId||!card||
+    card.dataset.currentSessionId!==currentSessionDropId)return;
+ event.preventDefault();
+ const result=moveCurrentSessionCard(currentSessionDragId,currentSessionDropId,currentSessionDropAfter);
+ if(result)$('current-session-order-status').textContent=currentSessionPositionMessage(currentSessionDragId,result.index,result.total);
+ currentSessionSuppressClickUntil=Date.now()+300;
+});
+currentSessionGrid.addEventListener('dragend',event=>{
+ event.target.closest('[data-current-session-id]')?.classList.remove('dragging');
+ clearCurrentSessionDropMarkers();
+ currentSessionDragId='';
+ currentSessionSuppressClickUntil=Date.now()+300;
+ renderCurrentSessions();
+});
+currentSessionGrid.addEventListener('keydown',event=>{
+ if(!event.altKey||event.ctrlKey||event.metaKey||event.shiftKey)return;
+ const card=event.target.closest('[data-current-session-id]');
+ if(!card)return;
+ const columns=Math.max(1,getComputedStyle(currentSessionGrid).gridTemplateColumns.trim().split(/\s+/).length);
+ const delta={ArrowLeft:-1,ArrowRight:1,ArrowUp:-columns,ArrowDown:columns}[event.key];
+ if(!delta)return;
+ event.preventDefault();
+ const id=card.dataset.currentSessionId,result=moveCurrentSessionCardBy(id,delta);
+ if(!result)return;
+ $('current-session-order-status').textContent=currentSessionPositionMessage(id,result.index,result.total);
+ renderCurrentSessions();
+ requestAnimationFrame(()=>focusCurrentSessionCard(id));
+});
+
diff --git a/dashboard/js/deck.js b/dashboard/js/deck.js
new file mode 100644
index 00000000..533df69b
--- /dev/null
+++ b/dashboard/js/deck.js
@@ -0,0 +1,379 @@
+// deck-pure-start: tour storage, slide copy, and frame markup. Nothing here touches the DOM, so tests run it in Node.
+const WELCOME_KEY='tm_welcome_v1';
+const LEGACY_ONBOARDING_KEY='tm_onboarding_v1';
+const LEARN_SLIDE_KEY='tm_learn_slide';
+// Reads one stored welcome record. Unreadable storage throws to the caller; corrupt JSON reads as absent.
+function readWelcomeStore(key){
+ const raw=localStorage.getItem(key);
+ if(!raw)return null;
+ try{const value=JSON.parse(raw);return value&&typeof value==='object'?value:null;}catch(error){return null;}
+}
+// First launch only. Anyone who used the retired checklist (a step done, finished, or collapsed) has already met the product.
+// When storage cannot be read, a dismissal could not be remembered either, so the welcome stays out of the way.
+function welcomeShouldAutoShow(){
+ try{
+  if(readWelcomeStore(WELCOME_KEY)?.seen===true)return false;
+  const legacy=readWelcomeStore(LEGACY_ONBOARDING_KEY);
+  if(legacy&&((Array.isArray(legacy.completed)&&legacy.completed.length>0)||legacy.completed===true||legacy.collapsed===true||Number(legacy.completed_at)>0))return false;
+  return true;
+ }catch(error){return false;}
+}
+// A stored slide index is trusted only when it names a real slide; anything else starts at the beginning.
+function deckSlideIndex(value){
+ if(typeof value!=='number'&&!(typeof value==='string'&&value.trim()))return 0;
+ const index=Number(value);
+ return Number.isInteger(index)&&index>=0&&index<DECK_SLIDES.length?index:0;
+}
+function readWelcomeProgress(){
+ try{return deckSlideIndex(readWelcomeStore(WELCOME_KEY)?.last_slide);}catch(error){return 0;}
+}
+// An explicit slide (Learn's full-screen button) always wins. Otherwise a tour left partway offers to resume.
+function welcomeStartSlide(requested=null){
+ if(requested!==null&&requested!==undefined)return {index:deckSlideIndex(requested),offer:false};
+ const index=readWelcomeProgress();
+ return {index,offer:index>0};
+}
+function recordWelcomeSlide(index){
+ try{
+  const previous=readWelcomeStore(WELCOME_KEY),slide=deckSlideIndex(index);
+  localStorage.setItem(WELCOME_KEY,JSON.stringify(previous?.seen===true?{seen:true,dismissed_at:Number(previous.dismissed_at)||Date.now(),last_slide:slide}:{seen:false,last_slide:slide}));
+ }catch(error){}
+}
+function markWelcomeSeen(lastSlide=0){
+ try{localStorage.setItem(WELCOME_KEY,JSON.stringify({seen:true,dismissed_at:Date.now(),last_slide:deckSlideIndex(lastSlide)}));}catch(error){}
+}
+function readLearnSlide(){
+ try{return deckSlideIndex(localStorage.getItem(LEARN_SLIDE_KEY));}catch(error){return 0;}
+}
+function saveLearnSlide(index){
+ try{localStorage.setItem(LEARN_SLIDE_KEY,String(deckSlideIndex(index)));}catch(error){}
+}
+const DECK_PLATFORM=(()=>{const platform=String(navigator.userAgentData?.platform||navigator.platform||navigator.userAgent||'');return /mac/i.test(platform)?'mac':/win/i.test(platform)?'windows':/linux|x11|cros/i.test(platform)?'linux':'other';})();
+const COMPANION_PLACE={mac:'menu bar',windows:'notification area',linux:'tray'}[DECK_PLATFORM]||'menu bar or tray';
+// The only live facts the tour reads change behavior, never what a frame shows: frames always carry sample values.
+function deckFacts(state=LATEST){
+ const budget=state?.xsession?.budget;
+ return {budgetConfigured:!!(budget?.configured&&Number(budget.budget)>0)};
+}
+const DECK_ARROW='<svg class=deckArrow viewBox="0 0 16 16" aria-hidden=true><path d="M3 8h9M9 4l4 4-4 4"/></svg>';
+function levelBarHtml(fill,{label='',tone='',mark=null}={}){
+ const at=value=>`${(100*Math.max(0,Math.min(1,value))).toFixed(1)}%`;
+ return `<span class=levelBar${tone?` data-tone=${tone}`:''} role=img aria-label="${esc(label)}" style="--fill:${at(fill)}${mark==null?'':`;--mark:${at(mark)}`}"><i></i>${mark==null?'':'<b></b>'}</span>`;
+}
+// A numbered marker placed on a frame. `at` pins it to a corner or side of its nearest [data-callout] parent; without it, it sits inline.
+const calloutHtml=(number,at='')=>`<mark class=frameCallout${at?` data-at=${at}`:''} aria-hidden=true>${number}</mark>`;
+// One explained frame: a real dashboard component filled with sample values, numbered markers on it, and a matching numbered legend.
+function conceptFrameHtml(frame,host){
+ const legend=frame.legend.map((text,index)=>`<li>${calloutHtml(index+1)}<span>${esc(text)}</span></li>`).join('');
+ return `<figure class=conceptFrame data-frame=${frame.kind}${frame.anchor?` id=${host}-${frame.anchor}`:''}><div class=conceptFrameHead><span>${esc(frame.label)}</span><span class=chip>Example</span></div><div class=conceptFrameStage role=img aria-label="${esc(frame.alt)}">${frame.html()}</div><figcaption><ol class=frameLegend role=list>${legend}</ol></figcaption></figure>`;
+}
+// Sample sessions and spend for the frames: round numbers that make each idea obvious. Never the user's data.
+const sampleCardHtml=({title,model,cost,metrics,status='working',heroCallout=''})=>`<div class="card currentSessionCard activity-${status}" style="--harness:${providerColor('claude')}"><div class=currentSessionTop><div class=currentSessionRuntime>${runtimeMarkSvg({provider:'claude'})}<span>Claude Code</span><span class=currentSessionProject>website</span></div><div class=currentSessionTopMeta><div class="currentSessionStatus ${status}">${status==='working'?'Working':'Recent'}</div></div></div><div class=currentSessionIdentity><h3>${esc(title)}</h3><span class="currentSessionCaps mono">${esc(model)}</span></div><div class=currentSessionHero><div class=currentSessionHeroCost><span class=currentSessionHeroLabel>Cost</span><b class="currentSessionHeroValue mono">${esc(cost)} ${heroCallout}</b></div></div><div class=currentSessionMetrics>${metrics.map(([label,value,extra='',callout='',labelCallout=''])=>`<div class="currentSessionMetric metric"><span>${esc(label)}${labelCallout?` ${labelCallout}`:''}</span>${extra?`<div class=currentSessionContextValue><b class=mono>${esc(value)}</b>${extra}</div>`:`<b class=mono>${esc(value)}${callout?` ${callout}`:''}</b>`}</div>`).join('')}</div></div>`;
+// The real context sparkline: one bar per turn, toned as the chat fills.
+const SAMPLE_PRICES=[
+ {label:'Re-reading (cache read)',price:.3,color:'var(--c-cache-read)'},
+ {label:'Reading new text (input)',price:3,color:'var(--c-input)'},
+ {label:'Saving to re-read (cache write)',price:3.75,color:'var(--c-cache-write)'},
+ {label:'Writing the answer (output)',price:15,color:'var(--c-output)'},
+];
+const SAMPLE_SPEND_DAYS=[12,18,9,24,0,0,16,21,14,30,19,22];
+const SAMPLE_MODELS=[{name:'Opus',share:.7,cost:'$210.00'},{name:'Sonnet',share:.2,cost:'$60.00'},{name:'Haiku',share:.1,cost:'$30.00'}];
+const SAMPLE_OUTPUT_PER_DOLLAR=[2.6,2.8,2.7,3.2,3.1,3.6,3.5,4.1,4.3,4.8,4.7,5.4,5.6,6];
+const SAMPLE_HELPER_COST=[6,5.4,4.8,4.1,3.2,2.6,2.1,1.6,1.3,1];
+// Frame markup, one function per frame. Each takes no arguments, so no live value can reach it.
+function priceFrameHtml(){
+ const max=SAMPLE_PRICES.at(-1).price,min=SAMPLE_PRICES[0].price;
+ return `<div class=priceLadder>${SAMPLE_PRICES.map((row,index)=>`<div class=priceRow><span class=priceType><i style="--seg:${row.color}"></i>${esc(row.label)}</span>${levelBarHtml(row.price/max)}<b class=mono>${money(row.price)}</b><small class=mono>${esc(`${+(row.price/min).toFixed(1)}×`)}</small>${index===0?calloutHtml(1):index===SAMPLE_PRICES.length-1?calloutHtml(2):''}</div>`).join('')}</div>`;
+}
+function menuFrameHtml(){
+ return `<div class=menuMock><div class=menuMockBar>${calloutHtml(1)}<span class=menuMockMark aria-hidden=true></span><b class=mono>$2.40 est</b><span class=mono>40%</span></div><dl class=menuMockRows><div><dt>This session</dt><dd class=mono>$2.40 est</dd></div><div data-callout><dt>Context</dt><dd class=mono>40%</dd>${calloutHtml(2,'r')}</div><div><dt>Spend today</dt><dd class=mono>$6.40</dd></div></dl></div>`;
+}
+const SAMPLE_TURN_COSTS=[.05,.07,.09,.12,.15,.19,.23,.28,.34,.41,.5,.62];
+function turnsFrameHtml(){
+ // Headroom keeps the callout markers above the tallest bars inside the plot.
+ const max=Math.max(...SAMPLE_TURN_COSTS)*1.3,last=SAMPLE_TURN_COSTS.length-1,first=SAMPLE_TURN_COSTS[0],end=SAMPLE_TURN_COSTS[last];
+ const bars=SAMPLE_TURN_COSTS.map((cost,index)=>`<div class=spendDay><span class="spendBarValue mono"></span><span class=spendDayTrack${index===6||index===last?` data-callout style="--bar-h:${(100*cost/max).toFixed(1)}%"`:''}><span class=spendDayStack style="--spend-height:${(100*cost/max).toFixed(1)}%"><i class=spendStackSegment style="--spend-color:${providerColor('claude')};--segment-share:100%"></i></span>${index===6?calloutHtml(1,'bar'):index===last?calloutHtml(2,'bar'):''}</span><span class=spendDayLabel></span></div>`).join('');
+ return `<div class=spendChart><div class=spendPlot><div class=spendChartInner>${bars}</div></div></div><div class=budgetMeterFoot><span>Turn 1 · <b class=mono>${money(first)}</b></span><span>Turn 40 · <b class=mono>${money(end)}</b></span></div><div class=budgetSpend><div class=budgetFigureLine><span class="budgetSpendValue mono">85%</span><span class=budgetOf>of what the AI can hold in mind</span></div><div class=budgetProgress><i style="width:85%"></i></div><div class=budgetMeterFoot><span>Context in use</span><span>${calloutHtml(3)} Nearly full</span></div></div>`;
+}
+function spendFrameHtml(){
+ const max=Math.max(...SAMPLE_SPEND_DAYS);
+ const bars=SAMPLE_SPEND_DAYS.map((cost,index)=>`<div class=spendDay><span class="spendBarValue mono"></span><span class=spendDayTrack${index===9?' data-callout':''}><span class=spendDayStack style="--spend-height:${cost?Math.max(3,100*cost/max).toFixed(1):0}%">${cost?`<i class=spendStackSegment style="--spend-color:${providerColor('claude')};--segment-share:100%"></i>`:''}</span>${index===9?calloutHtml(1,'t'):''}</span><span class=spendDayLabel>${index===0?'Oct 1':index===SAMPLE_SPEND_DAYS.length-1?'Oct 12':''}</span></div>`).join('');
+ return `<div class=spendChart><div class=spendPlot><div class=spendChartInner>${bars}</div></div></div><div class=budgetSpend><div class=budgetFigureLine><span class="budgetSpendValue mono">$310</span><span class=budgetOf>of <b class=mono>$600</b></span></div><div class=budgetProgress><i style="width:52%"></i><span class=budgetProgressMarkers><span style="left:90%"></span></span></div><div class=budgetMeterFoot><span>Monthly budget · 52% used</span><span>${calloutHtml(2)} Lands near $540</span></div></div>`;
+}
+function modelsFrameHtml(){
+ const colors=modelRankedColors(SAMPLE_MODELS.map(model=>({key:model.name,ids:[`${model.name}::Claude Code`]})));
+ return `<div class=modelSpendHead><h2>Where your spend goes</h2><span class=modelSpendTotal>≈ $300.00 est.</span></div><div class=modelSpendBar>${SAMPLE_MODELS.map((model,index)=>`<div class=modelSpendSeg style="flex:${model.share} 1 0;background:${colors.get(model.name)}">${index===0?`<span>${esc(model.name)}</span><b>${Math.round(100*model.share)}%</b>`:''}</div>`).join('')}</div><div class=modelSpendLegend>${SAMPLE_MODELS.map((model,index)=>`<span class=modelSpendChip>${index===0?calloutHtml(1):index===2?calloutHtml(2):''}<i style="background:${colors.get(model.name)}"></i><span class=modelSpendChipName>${esc(model.name)}</span><b class=mono>${esc(model.cost)}</b><em>${Math.round(100*model.share)}%</em></span>`).join('')}</div>`;
+}
+function efficiencyFrameHtml(){
+ const width=520,height=96,pad=8,max=6.6,points=SAMPLE_OUTPUT_PER_DOLLAR.map((value,index)=>[pad+index*(width-2*pad)/(SAMPLE_OUTPUT_PER_DOLLAR.length-1),pad+(height-2*pad)*(1-value/max)]);
+ const line=points.map(([x,y],index)=>`${index?'L':'M'}${x.toFixed(1)} ${y.toFixed(1)}`).join(' '),last=points.at(-1),floor=height-pad;
+ return `<div class="card efficiencyHeadline"><div class=efficiencyEyebrow>Output / $</div><div class="efficiencyValueRow valueWithDelta"><div class="v mono">6K / $</div><div class=trendDelta data-direction=up data-tone=improving data-callout><strong>↑ 50%</strong><span>vs prior 30 days</span>${calloutHtml(2,'r')}</div></div><div class=efficiencyChartWrap data-callout><svg class=efficiencyChart viewBox="0 0 ${width} ${height}" preserveAspectRatio=none aria-hidden=true><line class=efficiencyChartGrid x1="${pad}" x2="${width-pad}" y1="${floor}" y2="${floor}" vector-effect="non-scaling-stroke"/><path class=efficiencyChartArea d="${line} L${last[0].toFixed(1)} ${floor} L${pad} ${floor} Z"/><path class=efficiencyChartLine d="${line}" vector-effect="non-scaling-stroke"/></svg>${calloutHtml(1,'tr')}<div class=subagentRoleSparkDates><span>Sep 16</span><span>Oct 15</span></div></div></div>`;
+}
+function toolsFrameHtml(){
+ const rows=[['Browser tools','0','12K tokens'],['Design kit','0','4K tokens']];
+ return `<div class="card capReviewQueue warn"><div class=capQueueHead><h2>Needs review</h2><span class=capQueueCount>2 packs</span></div><div class=capReviewHead><span class=capReviewCols><span>Pack</span><span>Times used</span><span>Added to each request</span></span></div><div class=capReviewList>${rows.map(([name,use,load],index)=>`<div class=capReviewItem><div class=capReviewRow><div class=capReviewCols><span></span><span class=capReviewName><strong>${esc(name)}</strong></span><span class=capReviewNum>${esc(use)}${index?'':` ${calloutHtml(1)}`}</span><span class=capReviewNum>${esc(load)}${index?'':` ${calloutHtml(2)}`}</span></div></div></div>`).join('')}</div></div>`;
+}
+function helpersFrameHtml(){
+ const width=220,height=62,pad=5,max=Math.max(...SAMPLE_HELPER_COST),x=index=>pad+index*(width-2*pad)/(SAMPLE_HELPER_COST.length-1),y=value=>height-pad-(value/max)*(height-2*pad);
+ const line=SAMPLE_HELPER_COST.map((value,index)=>`${x(index).toFixed(1)},${y(value).toFixed(1)}`).join(' ');
+ return `<div class=subagentRoleTrendList><div class=subagentRoleTrendRow><div class=subagentRoleIdentity><strong>explorer ${calloutHtml(2)}</strong><small>Claude Code · helper · 20 runs</small></div><div class="subagentRolePrimary good"><span>Cost / run</span><b>$1.00</b><small>was $6.00</small></div><div class=subagentRoleSpark data-callout><svg viewBox="0 0 ${width} ${height}" preserveAspectRatio=none aria-hidden=true><path d="M ${x(0).toFixed(1)} ${height-pad} L ${line.replaceAll(' ',', ')} L ${x(SAMPLE_HELPER_COST.length-1).toFixed(1)} ${height-pad} Z" style="fill:rgb(var(--signal-rgb)/.08)"/><polyline points="${line}" fill=none stroke="var(--accent)" stroke-width="2.2" vector-effect="non-scaling-stroke"/></svg><div class=subagentRoleSparkDates><span>Week 1</span><span>Week 4</span></div>${calloutHtml(1,'tr')}</div></div></div>`;
+}
+function compareFrameHtml(){
+ const runs=[['A','Claude Opus','$0.40','12 steps · 4m'],['B','Claude Haiku','$0.10','11 steps · 3m']];
+ return `<div class=compareCards style="grid-template-columns:repeat(2,minmax(0,1fr))">${runs.map(([letter,model,cost,meta],index)=>`<div class="card compareCard" style="--compare-color:${compareColor(index)}"${index?' data-callout':''}><div class=compareCardTop><span class=compareLetter>${letter}</span><span class=compareCardTitle>Fix the login test</span></div><div class=compareCardMeta>${esc(model)}</div><div class="compareCardCost mono">${esc(cost)} est</div><div class=compareCardMeta>${esc(meta)}</div>${index?calloutHtml(1,'tr'):''}</div>`).join('')}</div><div class="card compareSection"><h3>Where the cost went</h3><div class=compareBreakdown>${runs.map(([letter,,cost],index)=>`<div class=compareBreakdownRow${index?' data-callout':''}><span class=compareLetter style="--compare-color:${compareColor(index)}">${letter}</span><div class=compareBreakdownBar style="width:${index?20:100}%"><i style="width:100%;background:${compareColor(index)}"></i></div><b class=mono>${esc(cost)}</b>${index?calloutHtml(2,'r'):''}</div>`).join('')}</div></div>`;
+}
+function agentFrameHtml(){
+ return `<div class=chatMock><p class=chatAsk data-callout>${calloutHtml(1,'l')}Am I on track this month?</p><p class=chatTool>Token Meter → numbers only ${calloutHtml(2)}</p><p class=chatAnswer>Yes. You've spent $310 of your $600 budget. At this pace the month lands near $540.</p><p class=chatTool>Change a session budget? → it asks you first ${calloutHtml(3)}</p></div>`;
+}
+// A frame-free visual for list slides: rows that each open the page where the habit is measured.
+const DECK_ICONS={
+ model:'<path d="M5 5h6v6H5zM8 1v4M8 11v4M1 8h4M11 8h4"/>',
+ load:'<path d="M2 5l6-3 6 3-6 3zM2 8l6 3 6-3M2 11l6 3 6-3"/>',
+ stable:'<path d="M8 2v9M5 5h6M3 10a5 4 0 0 0 10 0"/>',
+ done:'<circle cx="8" cy="8" r="6"/><path d="M5.5 8.2l1.8 1.8 3.4-3.6"/>',
+ fresh:'<path d="M13 8a5 5 0 1 1-1.5-3.6M13 2v3h-3"/>',
+};
+const HABITS=[
+ {icon:'model',title:'Pick the right model for the job',page:'Models',route:'models'},
+ {icon:'load',title:'Load only the tools you need',page:'Tools',route:'capabilities'},
+ {icon:'done',title:'Say what “done” looks like',page:'Compare',route:'sessions-compare'},
+ {icon:'fresh',title:'Start fresh instead of arguing',page:'All sessions',route:'sessions-all'},
+];
+function habitsListHtml(){
+ return `<ol class=leverList>${HABITS.map(habit=>`<li><button class=leverRow type=button data-deck-route=${habit.route}><svg class=leverIcon viewBox="0 0 16 16" aria-hidden=true>${DECK_ICONS[habit.icon]}</svg><span class=leverName><b>${esc(habit.title)}</b></span><small class=leverPage>${esc(habit.page)}<span class=srOnly>, opens this page</span></small>${DECK_ARROW}</button></li>`).join('')}</ol>`;
+}
+const TOKENOMICS_URL='https://www.splunk.com/en_us/products/tokenomics.html';
+function startListHtml(){
+ return `${habitsListHtml()}<div class=teamsRow><span><span class=label>For teams</span><b>Splunk Tokenomics</b></span><a class=tbtn href="${TOKENOMICS_URL}" target=_blank rel="noopener noreferrer">Read about Tokenomics<span aria-hidden=true> ↗</span><span class=srOnly> (opens in a new tab)</span></a></div>`;
+}
+const DECK_CHAPTERS=[
+ {id:'basics',title:'The basics'},
+ {id:'work',title:'While you work'},
+ {id:'review',title:'Review and find waste'},
+ {id:'better',title:'Do better'},
+];
+// One slide set, two hosts: the welcome overlay and the Learn page render these same entries.
+// Word budget per slide: headline ≤ 8, optional body ≤ 14, one to three legend lines of ≤ 12 each, at most one link.
+// A frame shows a real dashboard component with sample values and carries an Example chip; list slides show rows instead.
+const DECK_SLIDES=[
+ {id:'tokens',chapter:'basics',rail:'Tokens',kicker:'Current sessions',title:'You pay for every token the AI uses.',body:'Counted on your computer, never uploaded, and turned into dollars.',
+  frame:{kind:'session',label:'Session card',alt:'Example session card: Fix the login page, 1.2 million tokens, $2.40 estimated.',legend:['Tokens are small pieces of words. Every request is counted.','The cost is an estimate from public prices, not your bill.'],
+   html:()=>sampleCardHtml({title:'Fix the login page',model:'Claude Sonnet',cost:'$2.40 est',heroCallout:calloutHtml(2),metrics:[['Tokens','1.2M','',calloutHtml(1)],['Context in use','40%'],['Turns','12']]})},
+  links:[{label:'Open Current sessions',route:'sessions'}]},
+ {id:'prices',chapter:'basics',rail:'Model pricing',kicker:'Model pricing',title:'Not every token costs the same.',
+  frame:{kind:'prices',label:'Price per 1M tokens',alt:'Example prices per million tokens: re-reading $0.30, new text $3.00, saving to re-read $3.80, writing the answer $15.00.',legend:['Re-reading what it already saw is the cheapest.','Writing the answer costs about 50 times more.'],html:priceFrameHtml},
+  links:[{label:'Open Model pricing',route:'model-pricing'}]},
+ {id:'context',chapter:'work',rail:'Current sessions',kicker:'Current sessions',title:'Context in use: long chats cost more.',body:'Each turn, the AI re-reads the whole chat so far.',
+  frame:{kind:'context',label:'Cost per turn',alt:'Example chat of 40 turns: each turn costs more, from $0.10 for turn 1 to $0.60 for turn 40, and 85% of what the AI can hold in mind is in use.',legend:['The bars rise as the chat grows. Each turn costs more.','Turn 40 costs about 12 times turn 1.','Nearly full? Start fresh, or ask it to summarize.'],
+   html:()=>turnsFrameHtml()},
+  links:[{label:'Open Current sessions',route:'sessions'}]},
+ {id:'glance',chapter:'work',rail:'Menu bar',kicker:'Menu bar',title:'See the live cost while you work.',body:`It sits in your ${COMPANION_PLACE}, always on.`,
+  frame:{kind:'menu',label:`Companion in the ${COMPANION_PLACE}`,alt:'Example companion: this session $2.40 estimated, context 40%, spend today $6.40.',legend:['The live cost of the session you are running.','How much the AI is holding in mind right now.'],html:menuFrameHtml},
+  links:[{label:'Open Current sessions',route:'sessions'}]},
+ {id:'compare',chapter:'work',rail:'Compare',kicker:'Compare',title:'Compare: change one thing, run again.',body:'Pick two sessions of the same task and see what changed.',
+  frame:{kind:'compare',label:'Compare · two runs',alt:'Example comparison of the same task: run A with Claude Opus cost $0.40, run B with Claude Haiku cost $0.10.',legend:['Same task, one change: a lighter model.','B cost 80% less. Keep it if the result holds.'],html:compareFrameHtml},
+  links:[{label:'Open Compare',route:'sessions-compare'}]},
+ {id:'month',chapter:'review',rail:'Spend',kicker:'Spend',title:'Spend: your month and your budget.',body:'Each day, and where the month will land.',
+  frame:{kind:'spend',label:'Spend · this month',alt:'Example month: daily spend bars, $310 spent of a $600 budget, projected to land near $540.',legend:['Each bar is one day of spending.','Where the month should land at this pace.'],html:spendFrameHtml},
+  links:[{label:'Open Spend',route:'spend-budgets'}]},
+ {id:'models',chapter:'review',rail:'Models',kicker:'Models',title:'Models: one model is often most of it.',
+  frame:{kind:'models',label:'Models · spend by model',alt:'Example spend by model: Opus 70%, Sonnet 20%, Haiku 10%.',legend:['This one model is 70% of the spend.','A lighter model can do routine work for less.'],html:modelsFrameHtml},
+  links:[{label:'Open Models',route:'models'}]},
+ {id:'efficiency',chapter:'review',rail:'Efficiency',kicker:'Efficiency',title:'Efficiency: more work for each dollar.',
+  frame:{kind:'efficiency',label:'Efficiency · output per dollar',alt:'Example efficiency: output per dollar rose 50% over 30 days.',legend:['A rising line means more work for each dollar.','The change compared with the 30 days before.'],html:efficiencyFrameHtml},
+  links:[{label:'Open Efficiency',route:'efficiency'}]},
+ {id:'tools',chapter:'review',rail:'Tools',kicker:'Tools',title:'Tools: unused tools still cost you.',body:'Tool instructions ride along with every request.',
+  frame:{kind:'tools',label:'Tools · needs review',alt:'Example review list: Browser tools, used 0 times, adds 12 thousand tokens to every request.',legend:['Never used in your recent sessions.','Still sent with every request. Turn it off.'],html:toolsFrameHtml},
+  links:[{label:'Open Tools',route:'capabilities'}]},
+ {id:'helpers',chapter:'review',rail:'Subagents',kicker:'Subagents',title:'Subagents: small helper jobs are cheap.',body:'Your agent can hand side jobs to helpers called subagents.',
+  frame:{kind:'helpers',label:'Subagents · cost per run',alt:'Example helper: cost per run fell from $6.00 to $1.00 over four weeks.',legend:['Cost per helper run fell from $6.00 to $1.00.','Short, clear jobs keep each run small.'],html:helpersFrameHtml},
+  links:[{label:'Open Subagents',route:'subagents'}]},
+ {id:'agent',chapter:'better',rail:'Agent connection',kicker:'Agent connection',title:'Ask your AI agent about spending.',body:'Turn on Agent connection, and your agent can ask Token Meter (MCP).',
+  frame:{kind:'agent',anchor:'agent-access',label:'Chat with your agent',alt:'Example chat: Am I on track this month? Yes, $310 of $600, landing near $540.',legend:['Ask in plain words, in the chat you already use.','It gets numbers only, never your prompts or code.','Its AI provider sees those numbers; session-budget changes need your OK.'],html:agentFrameHtml},
+  links:[{label:'Open Agent connection',route:'settings',target:'agent-access'}]},
+ {id:'start',chapter:'better',rail:'Get started',kicker:'Get started',title:'Four habits that lower the bill.',body:'Each habit opens the page that measures it.',visual:startListHtml,
+  links:[{label:facts=>facts.budgetConfigured?'Review your budget':'Set a monthly budget',route:'spend-budgets',primary:true}]},
+];
+function deckCopyHtml(index,facts,host){
+ const slide=DECK_SLIDES[index];
+ const links=(slide.links||[]).map(link=>`<button class=${link.primary?'deckPrimary':'tbtn'} type=button data-deck-route=${link.route}${link.target?` data-deck-target=${link.target}`:''}>${esc(typeof link.label==='function'?link.label(facts):link.label)}${DECK_ARROW}</button>`).join('');
+ return `<span class=deckKicker>${esc(slide.kicker)}</span><h2 id=${host}-deck-title>${esc(slide.title)}</h2>${slide.body?`<p>${esc(slide.body)}</p>`:''}${links?`<div class=deckActions>${links}</div>`:''}`;
+}
+function deckVisualHtml(index,host){
+ const slide=DECK_SLIDES[index];
+ return slide.frame?conceptFrameHtml(slide.frame,host):`<div class=deckList>${slide.visual()}</div>`;
+}
+function deckRailHtml(index){
+ return `<ol class=deckChapters>${DECK_CHAPTERS.map((chapter,number)=>{
+  const slides=DECK_SLIDES.map((slide,i)=>({slide,i})).filter(row=>row.slide.chapter===chapter.id);
+  const first=slides[0].i,last=slides.at(-1).i,state=index>last?'done':index>=first?'current':'upcoming';
+  return `<li class=deckChapter data-state=${state}><h3><span class=mono>${number+1}</span>${esc(chapter.title)}</h3><ol>${slides.map(({slide,i})=>{
+   const step=i<index?'done':i===index?'current':'upcoming';
+   return `<li><button class=deckStep type=button data-deck-go=${i} data-state=${step}${step==='current'?' aria-current=step':''} aria-label="${esc(`${i+1} of ${DECK_SLIDES.length}: ${slide.rail}${step==='done'?', done':''}`)}"><i aria-hidden=true>${step==='done'?'✓':step==='current'?'●':'○'}</i><span>${esc(slide.rail)}</span></button></li>`;
+  }).join('')}</ol></li>`;
+ }).join('')}</ol>`;
+}
+// The first slide of the next chapter, or -1 in the last chapter.
+function deckChapterSkipTarget(index){
+ const chapter=DECK_SLIDES[index]?.chapter;
+ return DECK_SLIDES.findIndex((slide,i)=>i>index&&slide.chapter!==chapter);
+}
+const DECK_SECONDS_PER_SLIDE=18;
+function deckTimeLeft(index){
+ const seconds=(DECK_SLIDES.length-index)*DECK_SECONDS_PER_SLIDE;
+ if(index===0)return `about ${Math.round(seconds/60)} min`;
+ return seconds<=60?'under a minute left':`about ${Math.round(seconds/60)} min left`;
+}
+function deckResumeHtml(index,host){
+ return `<section class=deckSlide role=group aria-labelledby=${host}-deck-title><div class=deckCopy><span class=deckKicker>Welcome back</span><h2 id=${host}-deck-title>Pick up where you left off?</h2><p>${esc(`You stopped on slide ${index+1} of ${DECK_SLIDES.length}: ${DECK_SLIDES[index].rail}`)}</p><div class=deckActions><button class=deckPrimary type=button data-deck-action=resume>Resume where you left off${DECK_ARROW}</button><button class=tbtn type=button data-deck-action=restart>Start over</button></div></div></section>`;
+}
+// deck-pure-end
+// Writes preview markup only when it changes, and never while focus is inside it, so polling does not steal focus.
+function paintPreview(id,html){
+ const root=$(id);
+ if(!root||root.dataset.signature===html||root.contains(document.activeElement))return;
+ root.dataset.signature=html;
+ root.innerHTML=html;
+}
+let welcomeReturnFocus=null,welcomeAutoChecked=false,welcomeLeaving=false,welcomeFromLearn=false;
+const deckHosts={welcome:{index:0,offer:false},learn:{index:readLearnSlide(),offer:false}};
+function deckShellHtml(host){
+ return `<nav class=deckRail id=${host}-deck-rail aria-label="Tour chapters"></nav><div class=deckMain><div class=deckStage id=${host}-deck-stage></div><footer class=deckFoot id=${host}-deck-foot><button class=deckSkip id=${host}-deck-skip-chapter type=button data-deck-action=skip-chapter>Skip chapter</button><span class="deckCount mono" id=${host}-deck-count aria-hidden=true></span><div class=deckNav><button class=tbtn id=${host}-deck-back type=button data-deck-action=back>Back</button><button class=deckPrimary id=${host}-deck-next type=button data-deck-action=next>Next</button></div></footer><p class=srOnly id=${host}-deck-status aria-live=polite></p></div>`;
+}
+function ensureDeck(host){
+ const root=$(`${host}-deck`);
+ if(root.dataset.mounted)return true;
+ root.innerHTML=deckShellHtml(host);
+ root.dataset.mounted='true';
+ return false;
+}
+function paintDeck(host,state=LATEST){
+ const current=deckHosts[host];
+ if(current.offer||!$(`${host}-deck-copy`))return;
+ paintPreview(`${host}-deck-copy`,deckCopyHtml(current.index,deckFacts(state),host));
+ paintPreview(`${host}-deck-visual`,deckVisualHtml(current.index,host));
+}
+function showDeckSlide(host,index,{animate=true,offer=false}={}){
+ ensureDeck(host);
+ const current=deckHosts[host],total=DECK_SLIDES.length,rail=$(`${host}-deck-rail`),stage=$(`${host}-deck-stage`);
+ const railFocused=rail.contains(document.activeElement),stageFocused=stage.contains(document.activeElement);
+ current.index=Math.max(0,Math.min(total-1,Math.trunc(Number(index))||0));
+ current.offer=offer;
+ const slide=DECK_SLIDES[current.index],last=current.index===total-1;
+ rail.innerHTML=deckRailHtml(current.index);
+ stage.innerHTML=offer?deckResumeHtml(current.index,host):`<section class="deckSlide${animate?' deckEnter':''}" role=group aria-roledescription=slide aria-labelledby=${host}-deck-title><div class=deckCopy id=${host}-deck-copy></div><div class=deckVisual id=${host}-deck-visual></div></section>`;
+ stage.scrollTop=0;
+ $(`${host}-deck-foot`).hidden=offer;
+ $(`${host}-deck-count`).textContent=`${current.index+1} / ${total} · ${deckTimeLeft(current.index)}`;
+ $(`${host}-deck-status`).textContent=offer?`You stopped at slide ${current.index+1} of ${total}. Resume or start over.`:`Slide ${current.index+1} of ${total}: ${slide.rail}`;
+ $(`${host}-deck-back`).disabled=current.index===0;
+ $(`${host}-deck-skip-chapter`).disabled=deckChapterSkipTarget(current.index)<0;
+ const next=$(`${host}-deck-next`);
+ next.textContent=last?(host==='welcome'?'Done':'Back to start'):'Next';
+ next.className=last?'tbtn':'deckPrimary';
+ if(railFocused)rail.querySelector('[aria-current=step]')?.focus();
+ else if(stageFocused)next.focus();
+ if(offer)return;
+ paintDeck(host);
+ if(host==='welcome')recordWelcomeSlide(current.index);else saveLearnSlide(current.index);
+}
+function openDeckRoute(route,target=''){
+ openTopLevelRoute(route);
+ if(target)requestAnimationFrame(()=>$(target)?.scrollIntoView({block:'start'}));
+}
+function deckAction(host,action){
+ const current=deckHosts[host],last=DECK_SLIDES.length-1;
+ if(action==='back')showDeckSlide(host,current.index-1);
+ else if(action==='next'){if(current.index<last)showDeckSlide(host,current.index+1);else if(host==='welcome')closeWelcome();else showDeckSlide(host,0);}
+ else if(action==='skip-chapter'){const target=deckChapterSkipTarget(current.index);if(target>=0)showDeckSlide(host,target);}
+ else if(action==='resume'||action==='restart'){showDeckSlide(host,action==='resume'?current.index:0);$(`${host}-deck-next`).focus();}
+}
+function renderWelcome(state=LATEST){paintDeck('welcome',state);}
+function renderLearn(state=LATEST){
+ if(ensureDeck('learn'))paintDeck('learn',state);
+ else showDeckSlide('learn',deckHosts.learn.index,{animate:false});
+}
+function openWelcome(index=null,{auto=false,returnFocus=null,fromLearn=false}={}){
+ const dialog=$('welcome-dialog'),other=document.querySelector('dialog[open]');
+ if(other&&other!==dialog){if(auto)return false;other.close();}
+ showTourReturn(null);
+ const start=welcomeStartSlide(index);
+ welcomeFromLearn=fromLearn;
+ showDeckSlide('welcome',start.index,{animate:false,offer:start.offer});
+ if(!dialog.open){welcomeReturnFocus=returnFocus||document.activeElement;dialog.showModal();}
+ requestAnimationFrame(()=>(start.offer?dialog.querySelector('[data-deck-action=resume]'):$('welcome-deck-next'))?.focus());
+ return true;
+}
+// Leaving the tour through one of its links keeps a way back to the same slide.
+let tourReturn=null;
+const TOUR_RETURN_KEY='tm_tour_return';
+function showTourReturn(value){
+ tourReturn=value;
+ $('tour-return').hidden=!value;
+ if(value)$('tour-return-label').textContent=value.host==='learn'?'Back to Learn':'Back to the tour';
+ try{if(value)sessionStorage.setItem(TOUR_RETURN_KEY,JSON.stringify(value));else sessionStorage.removeItem(TOUR_RETURN_KEY);}catch(error){}
+}
+// Survives a reload, so the way back is still there after the page refreshes.
+function restoreTourReturn(){
+ try{const value=JSON.parse(sessionStorage.getItem(TOUR_RETURN_KEY)||'null');if(value&&Number.isInteger(value.index)&&value.index>=0&&value.index<DECK_SLIDES.length)showTourReturn({index:value.index,hash:String(value.hash||''),host:value.host==='learn'?'learn':'welcome'});}catch(error){}
+}
+function returnToTour(){
+ const value=tourReturn;
+ showTourReturn(null);
+ if(!value)return;
+ if(value.host==='learn'){openTopLevelRoute('learn');showDeckSlide('learn',value.index,{animate:false});return;}
+ openWelcome(value.index);
+}
+function closeWelcome({route='',target=''}={}){
+ const dialog=$('welcome-dialog');
+ welcomeLeaving=!!route;
+ const from=dialog.open&&route?{index:deckHosts.welcome.index,hash:location.hash,host:'welcome'}:null;
+ if(dialog.open)dialog.close();
+ if(route){openDeckRoute(route,target);if(from)showTourReturn(from);}
+}
+function maybeAutoShowWelcome(){
+ if(welcomeAutoChecked)return;
+ welcomeAutoChecked=true;
+ if(welcomeShouldAutoShow())openWelcome(null,{auto:true});
+}
+function deckKey(host,event){
+ if(event.target?.closest?.('input,select,textarea,[contenteditable]')||event.metaKey||event.ctrlKey||event.altKey)return;
+ const current=deckHosts[host];
+ if(current.offer)return;
+ if(event.key==='ArrowRight'&&current.index<DECK_SLIDES.length-1){event.preventDefault();showDeckSlide(host,current.index+1);}
+ else if(event.key==='ArrowLeft'&&current.index>0){event.preventDefault();showDeckSlide(host,current.index-1);}
+}
+function handleWelcomeKey(event){deckKey('welcome',event);}
+// Learn pages with ←/→ only when focus is on the page itself or inside the deck.
+function handleLearnDeckKey(event){
+ if(!$('view-learn').classList.contains('on')||document.querySelector('dialog[open]'))return;
+ const active=document.activeElement;
+ if(active&&active!==document.body&&!$('learn-deck').contains(active))return;
+ deckKey('learn',event);
+}
+['welcome','learn'].forEach(host=>$(`${host}-deck`).addEventListener('click',event=>{
+ const control=event.target.closest('[data-deck-go],[data-deck-action],[data-deck-route]');
+ if(!control)return;
+ if(control.dataset.deckGo!==undefined){showDeckSlide(host,Number(control.dataset.deckGo));return;}
+ if(control.dataset.deckAction){deckAction(host,control.dataset.deckAction);return;}
+ if(host==='welcome')closeWelcome({route:control.dataset.deckRoute,target:control.dataset.deckTarget||''});
+ else{const from={index:deckHosts.learn.index,hash:location.hash,host:'learn'};openDeckRoute(control.dataset.deckRoute,control.dataset.deckTarget||'');showTourReturn(from);}
+}));
+$('welcome-close').onclick=()=>closeWelcome();
+$('welcome-skip').onclick=()=>closeWelcome();
+$('welcome-dialog').addEventListener('cancel',event=>{event.preventDefault();closeWelcome();});
+$('welcome-dialog').addEventListener('close',()=>{
+ const index=deckHosts.welcome.index;
+ markWelcomeSeen(index>=DECK_SLIDES.length-1?0:index);
+ if(welcomeFromLearn&&!welcomeLeaving&&!deckHosts.welcome.offer)showDeckSlide('learn',index,{animate:false});
+ welcomeFromLearn=false;
+ const target=welcomeReturnFocus;
+ welcomeReturnFocus=null;
+ if(!welcomeLeaving&&target?.focus&&target.isConnected&&target.offsetParent!==null)target.focus();
+ welcomeLeaving=false;
+});
+$('tour-return').onclick=returnToTour;
+restoreTourReturn();
+window.addEventListener('popstate',()=>{if(tourReturn&&location.hash===tourReturn.hash)returnToTour();});
+$('learn-play').onclick=()=>openWelcome(deckHosts.learn.index,{fromLearn:true});
+
diff --git a/dashboard/js/efficiency.js b/dashboard/js/efficiency.js
new file mode 100644
index 00000000..eadd7ba3
--- /dev/null
+++ b/dashboard/js/efficiency.js
@@ -0,0 +1,385 @@
+const MODEL_COUNTER_KEYS=['input_tokens','output_tokens','io_covered_input_tokens','io_covered_output_tokens','cost_covered_output_tokens','cost_covered_cost','executions','token_covered_executions','io_covered_executions','cost_covered_executions','cost','cache_read_tokens','cache_write_tokens','cache_covered_input_tokens','reasoning_tokens','reasoning_output_tokens','reasoning_executions','reasoning_unavailable_executions','thinking_executions','thinking_covered_executions','attempts','retries','failed_attempts','attempt_samples','timed_output_tokens','timed_seconds','timed_samples','tool_free_output_tokens','tool_free_seconds','tool_free_samples','ttft_total_s','ttft_samples','wait_seconds','wait_samples','user_pause_seconds'];
+const MODEL_ARRAY_KEYS=['wait_durations_s','workload_peak_inputs','workload_outputs','workload_tool_calls','workload_model_calls','workload_cache_ratios'];
+const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all'];
+function loadEfficiencyFilters(project=''){
+ if(project){
+  const stored=localStorage.getItem('tm_efficiency_project_filters');
+  try{const scoped=JSON.parse(stored||'{}'),values=scoped?.[project];return Array.isArray(values)?[...new Set(values.filter(value=>typeof value==='string'&&value))]:[];}catch(error){return [];}
+ }
+ try{const stored=JSON.parse(localStorage.getItem('tm_efficiency_filters')||'[]');return Array.isArray(stored)?[...new Set(stored.filter(value=>typeof value==='string'&&value))]:[];}catch(error){return [];}
+}
+function saveActiveEfficiencyFilters(){
+ if(!efficiencyProject)localStorage.setItem('tm_efficiency_filters',JSON.stringify(efficiencyFilters));
+ else{
+  let scoped={};try{const stored=JSON.parse(localStorage.getItem('tm_efficiency_project_filters')||'{}');if(stored&&typeof stored==='object'&&!Array.isArray(stored))scoped=stored;}catch(error){}
+  scoped[efficiencyProject]=efficiencyFilters;localStorage.setItem('tm_efficiency_project_filters',JSON.stringify(scoped));
+ }
+}
+let efficiencyProject=migrateStoredProjectFilters('tm_efficiency_project');
+let efficiencyFilters=loadEfficiencyFilters(efficiencyProject);
+let efficiencyRange=localStorage.getItem('tm_efficiency_range')||'30';
+if(!EFFICIENCY_RANGES.includes(efficiencyRange))efficiencyRange='30';
+let efficiencySort={key:'cost',direction:'desc'};
+let activeEfficiencyStats=null,activeEfficiencyScope='',activeEfficiencyGeneration=0;
+let efficiencyProjectRequest=0,efficiencyProjectLoadingKey='';
+const efficiencyProjectCache=new Map();
+// model-color-logic-start
+const MODEL_COLORS={
+ codex:['#6F9CFF','#8EC5FF','#4C86F0','#B6CFFF','#647DB4'],
+ claude:['#E3825C','#F4A26E','#B55332','#FBC6A6','#CF8B76'],
+ 'claude-3p':['#A46AF4','#AD88F0','#7459F0','#B799E5','#9A35F6'],
+ cursor:['#3CC6C0','#65D6A6','#A0D56E','#2E9C8E','#BEE0D4'],
+ kiro:['#E3CC5C','#C9A43A','#EFE0A0','#B8B850','#CCE236'],
+ opencode:['#FF8FB8','#FF5E93','#FFC2D8','#E86FA0','#E236A9'],
+ fallback:['#A9B8C7','#8FB1C5','#B3A8D8','#83C8BD','#7D8AA0'],
+};
+const MODEL_RUNTIME_COLOR_FAMILIES={
+ codex:'codex','claude code':'claude','claude-3p':'claude-3p',cursor:'cursor',kiro:'kiro',opencode:'opencode',
+};
+const MODEL_OUTPUT_BAR_FILL='#536879',MODEL_OUTPUT_BAR_STROKE='#7890A3';
+function modelRuntimeColorFamily(identity){
+ const parts=String(identity||'').split('::'),runtime=(parts.length>1?parts[1]:parts[0]).trim().toLowerCase();
+ return MODEL_RUNTIME_COLOR_FAMILIES[runtime]||'fallback';
+}
+function modelColor(name,names){
+ const family=modelRuntimeColorFamily(name),palette=MODEL_COLORS[family]||MODEL_COLORS.fallback;
+ const siblings=[...new Set((names||[]).filter(identity=>modelRuntimeColorFamily(identity)===family))].sort((a,b)=>a.localeCompare(b));
+ return palette[Math.max(0,siblings.indexOf(name))%palette.length];
+}
+// Ranked groups (top five) take shades in rank order per runtime, so the visible top five never share a color.
+function modelRankedColors(groups){
+ const used=new Map();
+ return new Map(groups.map(group=>{const family=modelRuntimeColorFamily(group.ids?.[0]||group.key),palette=MODEL_COLORS[family]||MODEL_COLORS.fallback,index=used.get(family)||0;used.set(family,index+1);return [group.key,palette[index%palette.length]];}));
+}
+function modelTrendPaint(seriesColor){return {barFill:MODEL_OUTPUT_BAR_FILL,barStroke:MODEL_OUTPUT_BAR_STROKE,line:seriesColor};}
+// model-color-logic-end
+function localDateKey(date){return `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;}
+function dateKeyAgo(days,now=new Date()){const date=new Date(now);date.setHours(12,0,0,0);date.setDate(date.getDate()-days);return localDateKey(date);}
+function calendarMonthWindow(monthsAgo,now=new Date()){
+ const start=new Date(now.getFullYear(),now.getMonth()-monthsAgo,1,12,0,0,0),days=[];
+ for(const date=new Date(start);date.getMonth()===start.getMonth();date.setDate(date.getDate()+1))days.push(localDateKey(date));
+ return {days,daySet:new Set(days)};
+}
+function monthToDateWindow(now=new Date()){
+ const days=Array.from({length:now.getDate()},(_,index)=>dateKeyAgo(now.getDate()-1-index,now));
+ return {days,daySet:new Set(days)};
+}
+function modelRangeWindow(range,now=new Date()){
+ if(range==='all')return {days:null,daySet:null};
+ if(range==='month')return monthToDateWindow(now);
+ if(range==='last_month')return calendarMonthWindow(1,now);
+ if(range==='today'||range==='yesterday'){
+  const day=dateKeyAgo(range==='today'?0:1,now);
+  return {days:[day],daySet:new Set([day])};
+ }
+ const count=Number(range),days=Array.from({length:count},(_,index)=>dateKeyAgo(count-1-index,now));
+ return {days,daySet:new Set(days)};
+}
+function modelDayInRange(day,window){return !window.daySet||window.daySet.has(day);}
+function modelRangeLabel(range){return range==='today'?'Today':range==='yesterday'?'Yesterday':range==='month'?'Month':range==='last_month'?'Last month':range==='all'?'all history':`${range}d`;}
+function modelWaitDistribution(values){
+ const sorted=(values||[]).map(Number).filter(value=>value>0).sort((a,b)=>a-b),count=sorted.length;
+ if(!count)return {median_wait_s:0,p95_wait_s:0};
+ const middle=Math.floor(count/2),median=count%2?sorted[middle]:(sorted[middle-1]+sorted[middle])/2;
+ return {median_wait_s:median,p95_wait_s:sorted[Math.min(count-1,Math.max(0,Math.ceil(count*.95)-1))]};
+}
+function modelMedian(values){
+ const sorted=(values||[]).map(Number).filter(value=>Number.isFinite(value)&&value>=0).sort((a,b)=>a-b),count=sorted.length;
+ if(!count)return 0;const middle=Math.floor(count/2);return count%2?sorted[middle]:(sorted[middle-1]+sorted[middle])/2;
+}
+function aggregateModelDays(rows){
+	 const total=MODEL_COUNTER_KEYS.reduce((out,key)=>(out[key]=0,out),{});
+	 rows=rows||[];const tokenCovered=rows.filter(row=>metricAvailable(row,'tokens')).length,inputCovered=rows.filter(row=>metricAvailable(row,'input_tokens')).length,outputCovered=rows.filter(row=>metricAvailable(row,'output_tokens')).length,costCovered=rows.filter(row=>metricAvailable(row,'cost')).length,cacheCovered=rows.filter(row=>metricAvailable(row,'cache')).length,reasoningCovered=rows.filter(row=>row.availability?.reasoning_tokens===true).length,attemptCovered=rows.filter(row=>row.availability?.attempts===true).length,tokenPartial=rows.some(row=>metricPartial(row,'tokens')),costPartial=rows.some(row=>metricPartial(row,'cost')||(row.cost_covered_executions!==undefined&&Number(row.cost_covered_executions||0)<Number(row.executions||0))),cachePartial=rows.some(row=>metricPartial(row,'cache')),reasoningPartial=rows.some(row=>row.coverage?.reasoning_tokens?.complete===false),attemptPartial=rows.some(row=>row.coverage?.attempts?.complete===false);
+	 const estimated=rows.some(hasLocalEstimate),reported=rows.some(row=>['reported','mixed'].includes(usageBasis(row)));total.usage_basis=estimated?(reported?'mixed':'local_estimate'):'reported';total.provenance={usage_basis:total.usage_basis};
+	 total.availability={tokens:tokenCovered>0,input_tokens:inputCovered>0,output_tokens:outputCovered>0,cost:costCovered>0,cache:cacheCovered>0,reasoning_tokens:reasoningCovered>0,attempts:attemptCovered>0,throughput:outputCovered>0};
+	 total.coverage={tokens:{complete:tokenCovered===rows.length&&!tokenPartial,covered_rows:tokenCovered,total_rows:rows.length},cost:{complete:costCovered===rows.length&&!costPartial,covered_rows:costCovered,total_rows:rows.length},cache:{complete:cacheCovered===rows.length&&!cachePartial,covered_rows:cacheCovered,total_rows:rows.length},reasoning_tokens:{complete:reasoningCovered===rows.length&&!reasoningPartial,covered_rows:reasoningCovered,total_rows:rows.length},attempts:{complete:attemptCovered===rows.length&&!attemptPartial,covered_rows:attemptCovered,total_rows:rows.length}};
+	 rows.forEach(row=>MODEL_COUNTER_KEYS.forEach(key=>total[key]+=Number(row[key]||0)));
+	 total.reasoning_efforts=[...new Set(rows.flatMap(row=>row.reasoning_efforts||[]))].sort((a,b)=>String(a).localeCompare(String(b))).slice(0,8);
+	 MODEL_ARRAY_KEYS.forEach(key=>total[key]=rows.flatMap(row=>(row[key]||[]).map(Number).filter(value=>Number.isFinite(value)&&value>=0)));
+	 total.max_wait_s=Math.max(0,...rows.map(row=>Number(row.max_wait_s||0)));
+ const toolFree=total.tool_free_samples>0&&total.tool_free_seconds>0;
+ const timed=total.timed_samples>0&&total.timed_seconds>0;
+ const seconds=toolFree?total.tool_free_seconds:total.timed_seconds;
+ const speedOutput=toolFree?total.tool_free_output_tokens:total.timed_output_tokens;
+ total.available=Boolean((toolFree||timed)&&seconds>0&&speedOutput>0);
+ total.output_tps=total.available?speedOutput/seconds:0;
+ total.throughput_basis=toolFree?'tool_free':timed?'end_to_end':'unavailable';
+ total.throughput_samples=toolFree?total.tool_free_samples:total.timed_samples;
+ total.timing_coverage=total.output_tokens?Math.min(1,speedOutput/total.output_tokens):0;
+	 total.avg_ttft_ms=total.ttft_samples?total.ttft_total_s*1000/total.ttft_samples:0;
+	 total.avg_wait_s=total.wait_samples?total.wait_seconds/total.wait_samples:0;
+	 Object.assign(total,modelWaitDistribution(total.wait_durations_s));
+	 total.median_peak_input_tokens=modelMedian(total.workload_peak_inputs);
+	 total.median_workload_output_tokens=modelMedian(total.workload_outputs);
+	 total.median_tool_calls=modelMedian(total.workload_tool_calls);
+	 total.median_model_calls=modelMedian(total.workload_model_calls);
+	 total.median_cache_ratio=modelMedian(total.workload_cache_ratios);
+ return total;
+}
+function mergeModelDays(models,window){
+ const days=new Map();
+ (models||[]).forEach(model=>(model.daily||[]).forEach(day=>{
+  if(!modelDayInRange(day.day,window))return;
+	  const target=days.get(day.day)||{day:day.day};
+	  MODEL_COUNTER_KEYS.forEach(key=>target[key]=Number(target[key]||0)+Number(day[key]||0));
+	  MODEL_ARRAY_KEYS.forEach(key=>target[key]=[...(target[key]||[]),...(day[key]||[])]);
+	  target._metricRows=Number(target._metricRows||0)+1;target._tokenCovered=Number(target._tokenCovered||0)+(metricAvailable(day,'tokens')?1:0);target._inputCovered=Number(target._inputCovered||0)+(metricAvailable(day,'input_tokens')?1:0);target._outputCovered=Number(target._outputCovered||0)+(metricAvailable(day,'output_tokens')?1:0);target._costCovered=Number(target._costCovered||0)+(metricAvailable(day,'cost')?1:0);target._cacheCovered=Number(target._cacheCovered||0)+(metricAvailable(day,'cache')?1:0);target._reasoningCovered=Number(target._reasoningCovered||0)+(day.availability?.reasoning_tokens===true?1:0);target._attemptCovered=Number(target._attemptCovered||0)+(day.availability?.attempts===true?1:0);target._tokenComplete=target._tokenComplete!==false&&day.coverage?.tokens?.complete!==false;target._costComplete=target._costComplete!==false&&day.coverage?.cost?.complete!==false;target._cacheComplete=target._cacheComplete!==false&&day.coverage?.cache?.complete!==false;target._reasoningComplete=target._reasoningComplete!==false&&day.coverage?.reasoning_tokens?.complete!==false;target._attemptComplete=target._attemptComplete!==false&&day.coverage?.attempts?.complete!==false;
+	  target._estimated=Boolean(target._estimated||hasLocalEstimate(day));target._reported=Boolean(target._reported||['reported','mixed'].includes(usageBasis(day)));target.usage_basis=target._estimated?(target._reported?'mixed':'local_estimate'):'reported';target.provenance={usage_basis:target.usage_basis};
+	  target.availability={tokens:target._tokenCovered>0,input_tokens:target._inputCovered>0,output_tokens:target._outputCovered>0,cost:target._costCovered>0,cache:target._cacheCovered>0,reasoning_tokens:target._reasoningCovered>0,attempts:target._attemptCovered>0,throughput:target._outputCovered>0};target.coverage={tokens:{complete:target._tokenCovered===target._metricRows&&target._tokenComplete},cost:{complete:target._costCovered===target._metricRows&&target._costComplete},cache:{complete:target._cacheCovered===target._metricRows&&target._cacheComplete},reasoning_tokens:{complete:target._reasoningCovered===target._metricRows&&target._reasoningComplete},attempts:{complete:target._attemptCovered===target._metricRows&&target._attemptComplete}};
+	  target.max_wait_s=Math.max(Number(target.max_wait_s||0),Number(day.max_wait_s||0));
+  days.set(day.day,target);
+ }));
+ return [...days.values()].sort((a,b)=>a.day.localeCompare(b.day));
+}
+function efficiencyMetrics(row){
+ const data=row||{},availability=data.availability||{},input=Math.max(0,Number(data.input_tokens)||0),output=Math.max(0,Number(data.output_tokens)||0),coveredOutput=data.cost_covered_output_tokens===undefined?output:Math.max(0,Number(data.cost_covered_output_tokens)||0),cost=Math.max(0,Number(data.cost)||0),coveredCost=data.cost_covered_cost===undefined?cost:Math.max(0,Number(data.cost_covered_cost)||0),executions=Math.max(0,Number(data.executions)||0),coveredExecutions=data.token_covered_executions===undefined?executions:Math.max(0,Number(data.token_covered_executions)||0),ioCoveredExecutions=data.io_covered_executions===undefined?coveredExecutions:Math.max(0,Number(data.io_covered_executions)||0),costCoveredExecutions=data.cost_covered_executions===undefined?executions:Math.max(0,Number(data.cost_covered_executions)||0),reasoning=Math.max(0,Number(data.reasoning_tokens)||0),reasoningOutput=Math.max(0,Number(data.reasoning_output_tokens)||0),cacheRead=Math.max(0,Number(data.cache_read_tokens)||0),cacheInput=data.cache_covered_input_tokens===undefined?input:Math.max(0,Number(data.cache_covered_input_tokens)||0),attempts=Math.max(0,Number(data.attempts)||0),retries=Math.max(0,Number(data.retries)||0),failed=Math.max(0,Number(data.failed_attempts)||0),tokensAvailable=availability.tokens===true,inputAvailable=availability.input_tokens===true||(availability.input_tokens===undefined&&tokensAvailable),outputAvailable=availability.output_tokens===true||(availability.output_tokens===undefined&&tokensAvailable),reasoningAvailable=availability.reasoning_tokens===true,cacheAvailable=availability.cache===true,attemptsAvailable=availability.attempts===true,ioComplete=ioCoveredExecutions>=executions&&data.coverage?.tokens?.complete!==false,pairedTotals=data.io_covered_input_tokens!==undefined&&data.io_covered_output_tokens!==undefined,pairedInput=Math.max(0,Number(data.io_covered_input_tokens)||0),pairedOutput=Math.max(0,Number(data.io_covered_output_tokens)||0);
+ return {output_per_dollar:outputAvailable&&availability.cost===true&&costCoveredExecutions>0&&coveredCost>0?coveredOutput/coveredCost:null,reasoning_ratio:reasoningAvailable&&reasoningOutput>0?Math.min(1,reasoning/reasoningOutput):null,context_load:inputAvailable&&outputAvailable?(pairedTotals?(ioCoveredExecutions>0&&pairedOutput>0?pairedInput/pairedOutput:null):(ioComplete&&output>0?input/output:null)):null,cache_hit_ratio:tokensAvailable&&cacheAvailable&&cacheInput>0?Math.min(1,cacheRead/cacheInput):null,retry_waste:attemptsAvailable&&attempts>0?Math.min(1,retries/attempts):null,failure_rate:attemptsAvailable&&attempts>0?Math.min(1,failed/attempts):null};
+}
+function thinkingUnavailableExecutions(row){
+ const data=row||{},observed=Math.max(0,Number(data.thinking_executions)||0),covered=data.thinking_covered_executions===undefined?Math.min(observed,Math.max(0,Number(data.reasoning_executions)||0)):Math.max(0,Number(data.thinking_covered_executions)||0);
+ return Math.max(0,observed-covered);
+}
+function efficiencyRangeWindow(){return modelRangeWindow(efficiencyRange);}
+function filterEfficiencyModels(models,filters){
+ const allSelected=!(filters||[]).length;
+ return (models||[]).filter(model=>allSelected||(filters||[]).includes(model.id));
+}
+function efficiencyModelRows(models,window){
+ return (models||[]).map(row=>{const daily=window.daySet?(row.daily||[]).filter(day=>modelDayInRange(day.day,window)):[row];return {...row,window:aggregateModelDays(daily)};}).filter(row=>Number(row.window.executions||0)>0||Number(row.window.input_tokens||0)>0||Number(row.window.output_tokens||0)>0||Number(row.window.cost||0)>0).sort((a,b)=>Number(b.window.cost||0)-Number(a.window.cost||0)||Number(b.window.output_tokens||0)-Number(a.window.output_tokens||0)||modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b)));
+}
+function efficiencySortValue(row,key){
+ const data=row?.window||{},metric=efficiencyMetrics(data);
+ if(key==='model')return modelRuntimeLabel(row);
+ if(key==='cost')return data.availability?.cost===true?Number(data.cost)||0:null;
+ const value=metric[key];return value===null||!Number.isFinite(value)?null:value;
+}
+function sortEfficiencyRows(rows,sort=efficiencySort){
+ const direction=sort.direction==='asc'?1:-1;
+ return [...(rows||[])].sort((a,b)=>{const left=efficiencySortValue(a,sort.key),right=efficiencySortValue(b,sort.key);if(left===null&&right===null)return modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b));if(left===null)return 1;if(right===null)return -1;const compared=typeof left==='string'?left.localeCompare(right):left-right;return compared?compared*direction:modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b));});
+}
+function efficiencyTrendDays(rows,window){
+ const grouped=new Map((window.days||[]).map(day=>[day,[]]));
+ (rows||[]).forEach(row=>(row.daily||[]).forEach(day=>{if(!modelDayInRange(day.day,window))return;if(!grouped.has(day.day))grouped.set(day.day,[]);grouped.get(day.day).push(day);}));
+ return [...grouped].sort(([a],[b])=>a.localeCompare(b)).map(([day,items])=>({day,metrics:efficiencyMetrics(aggregateModelDays(items))}));
+}
+function efficiencyTrendDelta(trend,key){
+ const values=(trend||[]).map(row=>row?.metrics?.[key]).filter(value=>value!==null&&value!==undefined&&Number.isFinite(Number(value))).map(Number);
+ if(values.length<2||values.at(-2)<=0)return {text:'No comparable prior day',direction:''};
+ const change=(values.at(-1)-values.at(-2))/values.at(-2);
+ if(!Number.isFinite(change))return {text:'No comparable prior day',direction:''};
+ const direction=change>0?'up':change<0?'down':'flat',symbol=direction==='up'?'↑':direction==='down'?'↓':'→';
+ return {text:`${symbol} ${Math.abs(change*100).toFixed(1)}% vs prior covered day`,direction};
+}
+function efficiencyComparisonWindows(range,now=new Date()){
+ if(range==='today')return {current:modelRangeWindow('today',now),prior:modelRangeWindow('yesterday',now),label:'yesterday'};
+ if(range==='yesterday')return {current:modelRangeWindow('yesterday',now),prior:{days:[dateKeyAgo(2,now)],daySet:new Set([dateKeyAgo(2,now)])},label:'the day before'};
+ if(range==='month')return {current:monthToDateWindow(now),prior:calendarMonthWindow(1,now),label:'last month'};
+ if(range==='last_month')return {current:calendarMonthWindow(1,now),prior:calendarMonthWindow(2,now),label:'the month before'};
+ const count=Number(range);
+ if(!Number.isInteger(count)||count<=0)return null;
+ const priorDays=Array.from({length:count},(_,index)=>dateKeyAgo(count*2-1-index,now));
+ return {current:modelRangeWindow(String(count),now),prior:{days:priorDays,daySet:new Set(priorDays)},label:`prior ${count} days`};
+}
+function efficiencyPeriodDelta(current,prior,key,label){
+ if(current?.[key]==null||prior?.[key]==null)return {text:'No comparable prior period',direction:''};
+ const latest=Number(current[key]),baseline=Number(prior[key]);
+ if(!Number.isFinite(latest)||!Number.isFinite(baseline)||latest<0||baseline<=0)return {text:'No comparable prior period',direction:''};
+ const change=(latest-baseline)/baseline;
+ if(!Number.isFinite(change))return {text:'No comparable prior period',direction:''};
+ const direction=change>0?'up':change<0?'down':'flat',symbol=direction==='up'?'↑':direction==='down'?'↓':'→';
+ return {text:`${symbol} ${Math.abs(change*100).toFixed(1)}% vs ${label}`,direction};
+}
+// Shared rise/fall readout under a number: <div class=trendDelta><strong>↑ 8.5%</strong><span>vs prior 30 days</span></div>
+function percentTrendDelta(percent,label){
+ const value=Number(percent);
+ if(percent===null||percent===undefined||percent===''||!Number.isFinite(value))return {text:'No comparable prior period',direction:''};
+ const direction=Math.abs(value)<.05?'flat':value>0?'up':'down',symbol=direction==='up'?'↑':direction==='down'?'↓':'→';
+ return {text:`${symbol} ${Math.abs(value).toFixed(1)}% vs ${label}`,direction};
+}
+function trendTone(delta,improvingDirection=''){
+ const direction=delta?.direction||'';
+ return direction&&improvingDirection?(direction===improvingDirection?'improving':'degrading'):'';
+}
+function renderTrendDelta(target,delta,improvingDirection='',hidden=false){
+ const change=typeof target==='string'?$(target):target,parts=delta.direction?delta.text.split(' vs '):[delta.text,''];
+ change.hidden=hidden;change.querySelector('strong').textContent=parts[0];change.querySelector('span').textContent=parts[1]?`vs ${parts[1]}`:'';change.dataset.direction=delta.direction;change.dataset.tone=trendTone(delta,improvingDirection);
+}
+function efficiencyChartPointerIndex(clientX,rect,count){
+ if(count<=1)return 0;
+ const rectWidth=Math.max(1,Number(rect?.width)||0),localX=Math.max(0,Math.min(rectWidth,Number(clientX)-(Number(rect?.left)||0))),viewX=localX/rectWidth*520;
+ return Math.max(0,Math.min(count-1,Math.round((viewX-9)/502*(count-1))));
+}
+function efficiencyChartKeyIndex(key,index,count){
+ const last=Math.max(0,count-1),current=Math.max(0,Math.min(last,index));
+ if(key==='Home')return 0;
+ if(key==='End')return last;
+ if(key==='ArrowLeft')return Math.max(0,current-1);
+ if(key==='ArrowRight')return Math.min(last,current+1);
+ return current;
+}
+function efficiencyChartMetricPresentation(value,key){
+ if(key==='reasoning_ratio')return {axis:pct(value),detail:`${pct(value)} reasoning`};
+ if(key==='context_load')return {axis:efficiencyDecimal(value),detail:`${efficiencyDecimal(value)} context / output`};
+ if(key==='cache_hit_ratio')return {axis:pct(value),detail:`${pct(value)} input from cache`};
+ return {axis:compactNumber(value),detail:`${Math.round(value).toLocaleString('en-US')} output tokens / $`};
+}
+function efficiencyChartInspection(sample,key){
+ const parts=String(sample?.day||'').split('-').map(Number),months=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],date=parts.length===3&&months[parts[1]-1]?`${months[parts[1]-1]} ${parts[2]}`:String(sample?.day||'Unknown day'),value=sample?.value;
+ if(value===null||!Number.isFinite(value))return {date,value:'No data'};
+ return {date,value:efficiencyChartMetricPresentation(value,key).detail};
+}
+function efficiencyChartAnnouncement(detail,announce){
+ return announce?`${detail.date} · ${detail.value}`:'';
+}
+function chartGapRuns(points){
+ const segments=[];let segment=[];
+ (points||[]).forEach(point=>{if(segment.length&&point.index!==segment.at(-1).index+1){segments.push(segment);segment=[];}segment.push(point);});
+ if(segment.length)segments.push(segment);
+ return {segments,bridges:segments.slice(1).map((run,index)=>[segments[index].at(-1),run[0]])};
+}
+function chartGapBridge(x1,y1,x2,y2,color=''){return `<line class=chartGapBridge x1="${x1.toFixed(1)}" y1="${y1.toFixed(1)}" x2="${x2.toFixed(1)}" y2="${y2.toFixed(1)}"${color?` style="stroke:${color};stroke-opacity:.55"`:''}/>`;}
+function efficiencyChartSmoothPath(rows,x,y){
+ const points=(rows||[]).map(row=>({x:Number(x(row)),y:Number(y(row.value))})),format=value=>value.toFixed(1);
+ if(!points.length)return '';
+ if(points.length===1)return `M${format(points[0].x)} ${format(points[0].y)}`;
+ if(points.length===2)return `M${format(points[0].x)} ${format(points[0].y)} L${format(points[1].x)} ${format(points[1].y)}`;
+ const intervals=points.slice(1).map((point,index)=>point.x-points[index].x),slopes=points.slice(1).map((point,index)=>(point.y-points[index].y)/intervals[index]),tangents=points.map((point,index)=>index===0?slopes[0]:index===points.length-1?slopes.at(-1):0);
+ for(let index=1;index<points.length-1;index++){const previous=slopes[index-1],next=slopes[index],previousWidth=intervals[index-1],nextWidth=intervals[index];if(previous===0||next===0||previous*next<=0)tangents[index]=0;else{const left=2*nextWidth+previousWidth,right=nextWidth+2*previousWidth;tangents[index]=(left+right)/(left/previous+right/next);}}
+ let path=`M${format(points[0].x)} ${format(points[0].y)}`;
+ for(let index=0;index<points.length-1;index++){const start=points[index],end=points[index+1],width=intervals[index];path+=` C${format(start.x+width/3)} ${format(start.y+tangents[index]*width/3)} ${format(end.x-width/3)} ${format(end.y-tangents[index+1]*width/3)} ${format(end.x)} ${format(end.y)}`;}
+ return path;
+}
+function renderEfficiencyChart(id,trend,key,label){
+ const svg=$(id),tip=svg.parentElement?.querySelector('.efficiencyChartTip'),status=svg.parentElement?.querySelector('.efficiencyChartStatus'),hoverRatio=Number(svg.dataset.efficiencyHoverRatio),width=Math.max(120,Math.round(svg.clientWidth||520)),height=Math.max(40,Math.round(svg.clientHeight||96)),pad={left:9,right:9,top:10,bottom:16},samples=(trend||[]).map((row,index)=>({day:row.day,index,value:row.metrics?.[key]})),valid=samples.filter(row=>row.value!==null&&Number.isFinite(row.value));
+ if(tip)tip.hidden=true;
+ if(status)status.textContent='';
+ if(!samples.length){delete svg.dataset.efficiencyHoverRatio;svg.setAttribute('viewBox',`0 0 ${width} ${height}`);svg.innerHTML=`<text class=efficiencyChartEmpty x=10 y="${Math.round(height/2+4)}">No daily evidence</text>`;svg.setAttribute('aria-label',`${label}: unavailable`);svg.onpointermove=null;svg.onpointerleave=null;svg.onfocus=null;svg.onkeydown=null;svg.onblur=null;return;}
+ const maxValue=key==='reasoning_ratio'||key==='cache_hit_ratio'?1:valid.length?Math.max(1,...valid.map(row=>row.value)):1,plotWidth=width-pad.left-pad.right,plotHeight=height-pad.top-pad.bottom,x=row=>pad.left+(samples.length<=1?plotWidth/2:row.index*plotWidth/(samples.length-1)),y=value=>pad.top+plotHeight-(Math.max(0,value)/maxValue)*plotHeight;
+ const last=valid.at(-1),{segments,bridges}=chartGapRuns(valid);
+ const paths=bridges.map(([from,to])=>chartGapBridge(x(from),y(from.value),x(to),y(to.value))).join('')+segments.map(rows=>{if(rows.length===1)return rows[0]===last?'':`<circle class=efficiencyChartDot cx="${x(rows[0]).toFixed(1)}" cy="${y(rows[0].value).toFixed(1)}" r="2.5"/>`;const line=efficiencyChartSmoothPath(rows,x,y),area=`${line} L${x(rows.at(-1)).toFixed(1)} ${(pad.top+plotHeight).toFixed(1)} L${x(rows[0]).toFixed(1)} ${(pad.top+plotHeight).toFixed(1)} Z`;return `<path class=efficiencyChartArea d="${area}"/><path class=efficiencyChartLine d="${line}"/>`;}).join('');
+ const format=value=>efficiencyChartMetricPresentation(value,key).axis,firstDay=samples[0]?.day?.slice(5)||'',lastDay=samples.at(-1)?.day?.slice(5)||'',latest=last?`<circle class=efficiencyChartDot cx="${x(last).toFixed(1)}" cy="${y(last.value).toFixed(1)}" r="3.5"/>`:'',empty=valid.length?'':`<text class=efficiencyChartEmpty x=10 y="${Math.round(height/2+4)}">No daily evidence</text>`,maxLabel=valid.length?`<text class=efficiencyChartLabel x="${width-pad.right}" y="${pad.top+8}" text-anchor=end>${esc(format(maxValue))}</text>`:'';
+ svg.setAttribute('viewBox',`0 0 ${width} ${height}`);
+ svg.innerHTML=`<line class=efficiencyChartGrid x1="${pad.left}" x2="${width-pad.right}" y1="${pad.top}" y2="${pad.top}"/><line class=efficiencyChartGrid x1="${pad.left}" x2="${width-pad.right}" y1="${pad.top+plotHeight}" y2="${pad.top+plotHeight}"/>${paths}${latest}${empty}<text class=efficiencyChartLabel x="${pad.left}" y="${height-2}">${esc(firstDay)}</text><text class=efficiencyChartLabel x="${width-pad.right}" y="${height-2}" text-anchor=end>${esc(lastDay)}</text>${maxLabel}<g class=efficiencyChartInspect visibility=hidden><line class=efficiencyChartInspectLine y1="${pad.top}" y2="${pad.top+plotHeight}"/><circle class=efficiencyChartInspectDot r="4"/></g>`;
+ const instruction='Use Left and Right arrow keys to inspect daily values.',summaryLabel=`${last?`${label}: ${valid.length} daily values, latest ${format(last.value)}`:`${label}: unavailable`}. ${instruction}`;
+ svg.setAttribute('aria-label',summaryLabel);
+ let activeIndex=samples.length-1;
+ const inspect=svg.querySelector('.efficiencyChartInspect'),line=inspect?.querySelector('line'),dot=inspect?.querySelector('circle'),hideInspection=()=>{inspect?.setAttribute('visibility','hidden');if(tip)tip.hidden=true;};
+ const showInspection=(index,localX,announce=false)=>{const sample=samples[index],detail=efficiencyChartInspection(sample,key),pointX=x(sample);inspect?.setAttribute('visibility','visible');line?.setAttribute('x1',pointX.toFixed(1));line?.setAttribute('x2',pointX.toFixed(1));if(dot){if(sample.value===null||!Number.isFinite(sample.value))dot.setAttribute('visibility','hidden');else{dot.setAttribute('visibility','visible');dot.setAttribute('cx',pointX.toFixed(1));dot.setAttribute('cy',y(sample.value).toFixed(1));}}const text=`${detail.date} · ${detail.value}`;if(tip){const rect=svg.getBoundingClientRect(),edge=Math.min(105,rect.width/2);tip.textContent=text;tip.style.left=`${Math.max(edge,Math.min(rect.width-edge,localX))}px`;tip.hidden=false;}if(status)status.textContent=efficiencyChartAnnouncement(detail,announce);};
+ svg.onpointermove=event=>{const rect=svg.getBoundingClientRect(),localX=Math.max(0,Math.min(rect.width,event.clientX-rect.left));svg.dataset.efficiencyHoverRatio=String(localX/Math.max(1,rect.width));activeIndex=efficiencyChartPointerIndex(event.clientX,rect,samples.length);showInspection(activeIndex,localX);};
+ svg.onpointerleave=()=>{delete svg.dataset.efficiencyHoverRatio;hideInspection();svg.setAttribute('aria-label',summaryLabel);};
+ svg.onfocus=()=>{const rect=svg.getBoundingClientRect();activeIndex=samples.length-1;showInspection(activeIndex,rect.width*x(samples[activeIndex])/width,true);};
+ svg.onkeydown=event=>{if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;event.preventDefault();activeIndex=efficiencyChartKeyIndex(event.key,activeIndex,samples.length);const rect=svg.getBoundingClientRect();showInspection(activeIndex,rect.width*x(samples[activeIndex])/width,true);};
+ svg.onblur=()=>{hideInspection();svg.setAttribute('aria-label',summaryLabel);if(status)status.textContent='';};
+ if(svg.matches(':hover')&&Number.isFinite(hoverRatio)){const rect=svg.getBoundingClientRect(),localX=Math.max(0,Math.min(rect.width,rect.width*hoverRatio));activeIndex=efficiencyChartPointerIndex(rect.left+localX,rect,samples.length);showInspection(activeIndex,localX);}
+}
+function updateEfficiencySortHeaders(){
+ document.querySelectorAll('[data-efficiency-sort]').forEach(button=>{const active=button.dataset.efficiencySort===efficiencySort.key,th=button.closest('th'),mark=button.querySelector('.efficiencySortMark');th?.setAttribute('aria-sort',active?(efficiencySort.direction==='asc'?'ascending':'descending'):'none');if(mark)mark.textContent=active?(efficiencySort.direction==='asc'?'↑':'↓'):'';});
+}
+function efficiencyDecimal(value,suffix='x'){
+ if(value===null||!Number.isFinite(value))return '--';
+ const digits=value>=100?0:value>=10?1:2;
+ return value.toFixed(digits).replace(/\.0+$/,'')+suffix;
+}
+function efficiencyCoverageNote(overall,metric,label){
+ const coverage=overall.coverage?.[metric]||{},covered=Number(coverage.covered_rows||0),total=Number(coverage.total_rows||0);
+ if(!covered)return `${label} unavailable`;
+ return `${label} · ${f(covered)} / ${f(total)} models${coverage.complete?'':' · partial'}`;
+}
+function efficiencyEstimateNote(row){
+ const basis=usageBasis(row);
+ return basis==='mixed'?' · includes local estimates':basis==='local_estimate'?' · local estimate':'';
+}
+function efficiencyReasoningPresentation(data,metric){
+ const executions=Math.max(0,Number(data?.executions)||0),reasoningExecutions=Math.max(0,Number(data?.reasoning_executions)||0),thinkingExecutions=Math.min(executions,Math.max(0,Number(data?.thinking_executions)||0));
+ if(metric?.reasoning_ratio!==null&&Number.isFinite(metric?.reasoning_ratio))return {value:pct(metric.reasoning_ratio),note:`${f(reasoningExecutions)} / ${f(executions)} exec`};
+ if(thinkingExecutions>0&&executions>0)return {value:`${pct(thinkingExecutions/executions)} thinking execs`,note:'token ratio unavailable'};
+ return {value:'--',note:'unavailable'};
+}
+function efficiencySummaryPresentation(data){
+ const metric=efficiencyMetrics(data),reasoning=efficiencyReasoningPresentation(data,metric),estimate=hasLocalEstimate(data)?' · local est':'';
+ const outputAvailable=metric.output_per_dollar!==null&&Number.isFinite(metric.output_per_dollar),outputNote=outputAvailable?(data?.coverage?.cost?.complete===false?'partial':'covered'):'unavailable';
+ return {output:{value:outputAvailable?`${compactNumber(metric.output_per_dollar)} / $`:'--',note:outputNote+(outputAvailable?estimate:'')},reasoning:{value:reasoning.value,note:reasoning.note+(reasoning.value!=='--'?estimate:'')}};
+}
+function sessionEfficiencySource(s){
+ if(Array.isArray(s?.selected_stats?.model_stats))return s.selected_stats;
+ const id=stateSessionId(s),key=String(s?.source?.key||''),rows=s?.xsession?.sessions||[];
+ const summary=key?rows.find(row=>String(row?.key||'')===key):rows.find(row=>String(row?.id||'')===String(id||''));
+ return summary||s||{};
+}
+function normalizeSessionEfficiencyAggregate(overall){
+ const data=overall||{},reasoningAvailable=Number(data.reasoning_executions||0)>0&&Number(data.reasoning_output_tokens||0)>0;
+ return {...data,availability:{...(data.availability||{}),reasoning_tokens:reasoningAvailable}};
+}
+function renderSessionEfficiency(s){
+ const source=sessionEfficiencySource(s),overall=normalizeSessionEfficiencyAggregate(aggregateModelDays(source.model_stats||[]));
+ if(hasLocalEstimate(source)||hasLocalEstimate(s)){overall.usage_basis=usageBasis(source)||usageBasis(s);overall.provenance={usage_basis:overall.usage_basis};}
+ const presentation=efficiencySummaryPresentation(overall);
+ $('session-output-dollar').textContent=presentation.output.value;
+ $('session-output-dollar-note').textContent=presentation.output.note;
+ $('session-reasoning-ratio').textContent=presentation.reasoning.value;
+ $('session-reasoning-ratio-note').textContent=presentation.reasoning.note;
+}
+function renderEfficiency(stats){
+ const allModels=(stats?.models||[]).map(row=>({...row,id:row.id||row.model,runtime:row.runtime||(row.providers||[]).join(' + ')||'unknown runtime'})),window=efficiencyRangeWindow();
+ efficiencyFilters=migrateModelRuntimeFilters(efficiencyFilters,allModels);saveActiveEfficiencyFilters();
+ const allSelected=!efficiencyFilters.length,selected=filterEfficiencyModels(allModels,efficiencyFilters),options=allModels.slice().sort((a,b)=>modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b))),rows=efficiencyModelRows(selected,window),efficiencyModelRowsForRange=rows.map(row=>row.window),overall=aggregateModelDays(efficiencyModelRowsForRange),metrics=efficiencyMetrics(overall),rangeLabel=modelRangeLabel(efficiencyRange);
+ const pickerOptions=`<label class="modelOption all"><input type=checkbox data-efficiency-model-choice=all ${allSelected?'checked':''}><span>All model/runtime/budget rows</span></label>`+options.map(row=>{const label=modelRuntimeLabel(row);return `<label class=modelOption title="${esc(label)}"><input type=checkbox data-efficiency-model-choice=model value="${esc(row.id)}" ${efficiencyFilters.includes(row.id)?'checked':''}><span>${esc(label)}</span></label>`;}).join('');
+ setLogHtml($('e-model-options'),pickerOptions);
+ if($('e-model-picker').open)requestAnimationFrame(positionEfficiencyPickerMenu);
+ const selectionLabel=allSelected?'All model runtimes':selected.length===1?modelRuntimeLabel(selected[0]):`${selected.length} model runtimes selected`;
+ $('e-model-summary').textContent=selectionLabel;$('e-model-summary').title=allSelected?'All model runtimes':selected.map(modelRuntimeLabel).join(', ');
+ $('e-range').value=efficiencyRange;
+ $('e-output-dollar').textContent=metrics.output_per_dollar===null?'--':`${compactNumber(metrics.output_per_dollar)} / $`;
+ $('e-output-dollar-coverage').textContent=efficiencyCoverageNote(overall,'cost','Coverage')+efficiencyEstimateNote(overall);
+ $('e-reasoning-ratio').textContent=metrics.reasoning_ratio===null?'--':pct(metrics.reasoning_ratio);
+ const reasoningCovered=Number(overall.reasoning_executions||0),reasoningTotal=Number(overall.executions||0),thinkingUnavailable=efficiencyModelRowsForRange.reduce((total,row)=>total+thinkingUnavailableExecutions(row),0),thinkingNote=thinkingUnavailable?` · ${f(thinkingUnavailable)} thinking exec · token split unavailable`:'';
+ $('e-reasoning-coverage').textContent=(reasoningCovered?`Thinking / reasoning coverage · ${f(reasoningCovered)} / ${f(reasoningTotal)} exec${thinkingNote}`:thinkingUnavailable?`${f(thinkingUnavailable)} thinking exec · token split unavailable`:'Thinking / reasoning coverage unavailable')+efficiencyEstimateNote(overall);
+ const comparison=efficiencyComparisonWindows(efficiencyRange),priorOverall=comparison?aggregateModelDays(efficiencyModelRows(selected,comparison.prior).map(row=>row.window)):null,priorMetrics=priorOverall?efficiencyMetrics(priorOverall):null,comparisonDelta=key=>comparison?efficiencyPeriodDelta(metrics,priorMetrics,key,comparison.label):{text:'No comparable prior period',direction:''},trend=efficiencyTrendDays(rows,window),outputDelta=comparisonDelta('output_per_dollar'),reasoningDelta=comparisonDelta('reasoning_ratio'),contextDelta=comparisonDelta('context_load'),cacheHitDelta=comparisonDelta('cache_hit_ratio');
+ renderTrendDelta('e-output-dollar-change',outputDelta,'up',!comparison);renderTrendDelta('e-reasoning-change',reasoningDelta,'down',!comparison);renderTrendDelta('e-context-load-change',contextDelta,'down',!comparison);renderTrendDelta('e-cache-hit-change',cacheHitDelta,'up',!comparison);
+ renderEfficiencyChart('e-output-dollar-chart',trend,'output_per_dollar','Output per covered dollar');renderEfficiencyChart('e-reasoning-chart',trend,'reasoning_ratio','Reasoning ratio');renderEfficiencyChart('e-context-load-chart',trend,'context_load','Context load');renderEfficiencyChart('e-cache-hit-chart',trend,'cache_hit_ratio','Cache hit ratio');
+ $('e-context-load').textContent=efficiencyDecimal(metrics.context_load);
+ const ioCovered=Number(overall.io_covered_executions||0),ioTotal=Number(overall.executions||0);
+ $('e-context-load-note').textContent=metrics.context_load===null?(overall.availability?.input_tokens===true&&overall.availability?.output_tokens===true?'no executions with paired input/output':'input/output evidence unavailable'):ioCovered<ioTotal?`input per output token · paired coverage ${f(ioCovered)} / ${f(ioTotal)} exec`:'input tokens per output token';
+ $('e-cache-hit').textContent=metrics.cache_hit_ratio===null?'--':pct(metrics.cache_hit_ratio);
+ $('e-cache-hit-note').textContent=metrics.cache_hit_ratio===null?'cache evidence unavailable':`${compactNumber(overall.cache_read_tokens||0)} cached of ${compactNumber(overall.cache_covered_input_tokens??overall.input_tokens??0)} input`+efficiencyEstimateNote(overall);
+ $('e-model-meta').textContent=`${f(rows.length)} models${efficiencyEstimateNote(overall)}`;updateEfficiencySortHeaders();
+	 const sortedRows=sortEfficiencyRows(rows);$('e-model-table').querySelector('tbody').innerHTML=sortedRows.length?sortedRows.map(row=>{const data=row.window,metric=efficiencyMetrics(row.window),reasoning=efficiencyReasoningPresentation(data,metric),tokenExecutions=Number(data.token_covered_executions===undefined?data.executions:data.token_covered_executions)||0,ioExecutions=Number(data.io_covered_executions===undefined?tokenExecutions:data.io_covered_executions)||0,contextCoverage=ioExecutions>=Number(data.executions||0)&&data.coverage?.tokens?.complete!==false?'covered':'partial',estimate=hasLocalEstimate(row)?' · local est':'',effort=efficiencyEffortLabel(row);return `<tr><td><div class=modelName title="${esc(row.model)}">${esc(row.model)}</div></td><td>${esc(row.runtime)}${estimate}</td><td>${esc(effort)}</td><td class="num efficiencyMetric"><strong class=mono>${data.availability?.cost===false?'--':money(data.cost)}</strong><span>${data.availability?.cost===false?'unavailable':data.coverage?.cost?.complete?'covered':'partial'}</span></td><td class="num efficiencyMetric"><strong class=mono>${metric.output_per_dollar===null?'--':compactNumber(metric.output_per_dollar)+' / $'}</strong><span>${metric.output_per_dollar===null?'unavailable':data.coverage?.cost?.complete?'covered':'partial'}</span></td><td class="num efficiencyMetric"><strong class=mono>${reasoning.value}</strong><span>${reasoning.note}</span></td><td class="num efficiencyMetric"><strong class=mono>${efficiencyDecimal(metric.context_load)}</strong><span>${contextCoverage}</span></td><td class="num efficiencyMetric"><strong class=mono>${metric.cache_hit_ratio===null?'--':pct(metric.cache_hit_ratio)}</strong><span>${metric.cache_hit_ratio===null?'unavailable':'cache read'}</span></td></tr>`;}).join(''):'<tr><td colspan=8><div class="modelEmpty emptyState">No model activity in this range</div></td></tr>';
+}
+function paintEfficiencyProjects(stats){
+ const projects=(stats?.projects||[]).filter(project=>typeof project==='string'&&project);
+ if(efficiencyProject&&!projects.includes(efficiencyProject)){efficiencyProject='';efficiencyFilters=loadEfficiencyFilters('');localStorage.removeItem('tm_efficiency_project');}
+ setLogSelectOptions($('e-project'),'<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(projectFilterLabel(project))}</option>`).join(''),efficiencyProject);
+ $('e-project').title=stats?.projects_truncated?'Showing the first 500 discovered projects.':'';
+}
+function setEfficiencyProjectLoading(loading){if(loading)$('e-project').setAttribute('aria-busy','true');else $('e-project').removeAttribute('aria-busy');}
+function commitEfficiencyStats(stats,scope,generation){activeEfficiencyStats=stats;activeEfficiencyScope=scope;activeEfficiencyGeneration=generation;setEfficiencyProjectLoading(false);renderEfficiency(stats);}
+async function renderActiveEfficiency(){
+ if(!LATEST)return;
+ const machine=LATEST.xsession?.model_stats||{models:[],projects:[]},generation=Number(LATEST.xsession?.generated_at||0);paintEfficiencyProjects(machine);
+ if(!efficiencyProject){efficiencyProjectRequest++;efficiencyProjectLoadingKey='';setEfficiencyProjectLoading(false);commitEfficiencyStats(machine,'',generation);return;}
+ const project=efficiencyProject,key=`${generation}\n${project}`,cached=efficiencyProjectCache.get(key);
+ if(cached){commitEfficiencyStats(cached,project,generation);return;}
+ if(efficiencyProjectLoadingKey===key)return;
+ setEfficiencyProjectLoading(true);efficiencyProjectLoadingKey=key;const request=++efficiencyProjectRequest;
+ try{
+  const response=await fetch('/model-stats?project='+encodeURIComponent(project),{cache:'no-store'}),payload=await response.json();
+  if(!response.ok||!payload.ok)throw new Error('Project model stats are unavailable.');
+  if(request!==efficiencyProjectRequest||project!==efficiencyProject)return;
+  const responseGeneration=Number(payload.generated_at||generation);efficiencyProjectCache.set(key,payload.model_stats);efficiencyProjectCache.set(`${responseGeneration}\n${project}`,payload.model_stats);commitEfficiencyStats(payload.model_stats,project,responseGeneration);
+ }catch(error){if(request===efficiencyProjectRequest&&project===efficiencyProject)setEfficiencyProjectLoading(false);}
+ finally{if(efficiencyProjectLoadingKey===key){efficiencyProjectLoadingKey='';setEfficiencyProjectLoading(false);}}
+}
+function rerenderActiveEfficiency(){
+ if(activeEfficiencyStats&&activeEfficiencyScope===efficiencyProject)renderEfficiency(activeEfficiencyStats);
+ else renderActiveEfficiency();
+}
+$('e-range').value=efficiencyRange;
+$('e-range').onchange=event=>{efficiencyRange=EFFICIENCY_RANGES.includes(event.target.value)?event.target.value:'30';localStorage.setItem('tm_efficiency_range',efficiencyRange);if(LATEST)renderActiveEfficiency();};
+$('e-project').addEventListener('change',event=>{efficiencyProject=event.target.value;efficiencyFilters=loadEfficiencyFilters(efficiencyProject);if(efficiencyProject)localStorage.setItem('tm_efficiency_project',efficiencyProject);else localStorage.removeItem('tm_efficiency_project');efficiencyProjectRequest++;efficiencyProjectLoadingKey='';renderActiveEfficiency();});
+$('e-model-options').addEventListener('change',event=>{const input=event.target.closest('input[data-efficiency-model-choice]');if(!input)return;if(input.dataset.efficiencyModelChoice==='all')efficiencyFilters=[];else if(input.checked)efficiencyFilters=[...new Set([...efficiencyFilters,input.value])];else efficiencyFilters=efficiencyFilters.filter(id=>id!==input.value);saveActiveEfficiencyFilters();rerenderActiveEfficiency();});
+$('e-model-picker').addEventListener('keydown',event=>{if(event.key==='Escape')$('e-model-picker').removeAttribute('open');});
+document.addEventListener('pointerdown',event=>{const picker=$('e-model-picker');if(picker.open&&!picker.contains(event.target))picker.removeAttribute('open');});
+function positionEfficiencyPickerMenu(){const picker=$('e-model-picker'),menu=$('e-model-options');if(!picker.open){picker.classList.remove('opensUp');menu.style.maxHeight='';return;}const trigger=picker.querySelector('summary'),rect=trigger.getBoundingClientRect(),margin=12,above=Math.max(0,rect.top-margin),below=Math.max(0,window.innerHeight-rect.bottom-margin),preferred=Math.min(360,menu.scrollHeight||360),opensUp=below<preferred&&above>below,available=opensUp?above:below;picker.classList.toggle('opensUp',opensUp);menu.style.maxHeight=`${Math.min(360,available)}px`;}
+$('e-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionEfficiencyPickerMenu));
+window.addEventListener('resize',()=>{if($('e-model-picker').open)positionEfficiencyPickerMenu();});
+document.querySelectorAll('[data-efficiency-sort]').forEach(button=>button.onclick=()=>{const key=button.dataset.efficiencySort;if(efficiencySort.key===key)efficiencySort={key,direction:efficiencySort.direction==='desc'?'asc':'desc'};else efficiencySort={key,direction:key==='model'?'asc':'desc'};if(activeEfficiencyStats)renderEfficiency(activeEfficiencyStats);});
diff --git a/dashboard/js/git.js b/dashboard/js/git.js
new file mode 100644
index 00000000..ad97f41f
--- /dev/null
+++ b/dashboard/js/git.js
@@ -0,0 +1,419 @@
+function deliveryProjectName(value){return String(value||'').split(' · ')[0]||'Local project';}
+function deliveryPercent(value){
+ const number=Number(value);
+ return Number.isFinite(number)?`${Math.abs(number).toFixed(Math.abs(number)>=10?0:1)}%`:'';
+}
+function deliveryComparisonText(comparison){
+ const code=Number(comparison?.code_pushed_pct),intensity=Number(comparison?.spend_per_1k_pct);
+ if(!comparison?.available||!Number.isFinite(code)||!Number.isFinite(intensity))return 'No comparable prior period';
+ const codeText=Math.abs(code)<.05?'the same code volume':`${deliveryPercent(code)} ${code>0?'more':'less'} code`;
+ const costText=Math.abs(intensity)<.05?'unchanged cost intensity':`${deliveryPercent(intensity)} ${intensity<0?'lower':'higher'} cost intensity`;
+ return `<span>${esc(codeText)}</span><span class=deliveryComparisonDivider aria-hidden=true>&middot;</span><span>${esc(costText)}</span>`;
+}
+function deliveryRatio(value){
+ if(value===null||value===undefined||value==='')return '--';
+ const number=Number(value);
+ if(!Number.isFinite(number))return '--';
+ if(number>=1000)return compactNumber(number);
+ return number.toFixed(number>=10?1:2).replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');
+}
+function deliveryMultiple(value){
+ const number=Number(value);
+ return Number.isFinite(number)?`${number.toFixed(number>=10?0:1)}×`:'--';
+}
+function deliveryQuantile(sorted,share){
+ if(!sorted.length)return null;
+ if(sorted.length===1)return sorted[0];
+ const position=(sorted.length-1)*share,lower=Math.floor(position),upper=Math.ceil(position);
+ return lower===upper?sorted[lower]:sorted[lower]+(sorted[upper]-sorted[lower])*(position-lower);
+}
+function deliveryDistribution(values){
+ const sorted=(values||[]).map(Number).filter(value=>Number.isFinite(value)).sort((a,b)=>a-b);
+ if(!sorted.length)return null;
+ return {count:sorted.length,min:sorted[0],max:sorted[sorted.length-1],p25:deliveryQuantile(sorted,.25),median:deliveryQuantile(sorted,.5),p75:deliveryQuantile(sorted,.75)};
+}
+function deliveryShapeRange(distribution){
+ if(!distribution)return null;
+ const stable=distribution.count>=5;
+ return {label:stable?'Middle half':'Observed range',low:stable?distribution.p25:distribution.min,high:stable?distribution.p75:distribution.max};
+}
+const DELIVERY_MIN_RATIO_LINES=50;
+const DELIVERY_SHAPE_METRICS=[
+ {key:'spend_per_1k',label:'Spend / 1K',format:value=>money(value)},
+ {key:'changed_lines',label:'Lines / push day',format:value=>compactNumber(value)},
+ {key:'delivery_yield',label:'Push yield',format:value=>deliveryRatio(value)},
+];
+function deliveryRatioDay(row){
+ return (Number(row?.comparable_changed_lines)||0)>=DELIVERY_MIN_RATIO_LINES;
+}
+function deliveryIntensityDays(payload){
+ const days=Array.isArray(payload?.days)?payload.days:[];
+ return days.filter(row=>row?.availability?.spend_per_1k===true&&deliveryRatioDay(row)&&Number.isFinite(Number(row.spend_per_1k)));
+}
+function deliveryDaySeries(payload,key){
+ const days=Array.isArray(payload?.days)?payload.days:[];
+ if(key==='changed_lines')return days.filter(row=>row?.availability?.code_pushed===true&&(Number(row.changed_lines)||0)>0).map(row=>Number(row.changed_lines));
+ if(key==='delivery_yield')return days.filter(row=>row?.efficiency?.availability?.delivery_yield===true&&deliveryRatioDay(row)).map(row=>Number(row.efficiency.delivery_yield));
+ return deliveryIntensityDays(payload).map(row=>Number(row.spend_per_1k));
+}
+function deliveryShapeRows(payload){
+ return DELIVERY_SHAPE_METRICS.map(metric=>({...metric,distribution:deliveryDistribution(deliveryDaySeries(payload,metric.key))}));
+}
+function deliverySignals(payload){
+ const overall=payload?.overall||{},comparison=payload?.comparison||{},coverage=payload?.coverage||{};
+ const days=Array.isArray(payload?.days)?payload.days:[],available=overall?.availability||{};
+ const efficiency=overall?.efficiency||{},efficiencyAvailable=efficiency?.availability||{};
+ const rows=[];
+ const intensityChange=Number(comparison?.spend_per_1k_pct),codeChange=Number(comparison?.code_pushed_pct);
+ if(comparison?.available===true&&Number.isFinite(intensityChange)&&Number.isFinite(codeChange)){
+  const flat=Math.abs(intensityChange)<.05;
+  rows.push({key:'intensity_trend',kind:'neutral',priority:10,
+   title:flat?'Cost intensity held steady':`Cost intensity ${intensityChange<0?'fell':'rose'} ${deliveryPercent(intensityChange)}`,
+   text:''});
+ }
+ const yieldValue=Number(efficiency?.delivery_yield),yieldChange=Number(comparison?.delivery_yield_pct);
+ if(efficiencyAvailable?.delivery_yield===true&&Number.isFinite(yieldValue)){
+  const known=Number.isFinite(yieldChange);
+  rows.push({key:'push_yield',kind:'neutral',priority:20,
+   title:`${deliveryRatio(yieldValue)} pushed lines per 1K output tokens`,
+   text:known?'':'No prior period to compare.'});
+ }
+ const intensityDays=deliveryIntensityDays(payload);
+ if(intensityDays.length>=4){
+  const distribution=deliveryDistribution(intensityDays.map(row=>Number(row.spend_per_1k)));
+  const peak=intensityDays.reduce((top,row)=>Number(row.spend_per_1k)>Number(top.spend_per_1k)?row:top);
+  const multiple=distribution.median>0?Number(peak.spend_per_1k)/distribution.median:null;
+	  if(multiple&&multiple>=1.6)rows.push({key:'peak_day',kind:'warn',priority:30,action:'day',value:peak.day,
+	   title:`${deliveryDateLabel(peak.day)}: ${deliveryMultiple(multiple)} the typical Spend / 1K`,
+	   text:`${money(peak.spend_per_1k)} vs a ${money(distribution.median)} median over ${distribution.count} ${countWord(distribution.count,'day')}.`});
+ }
+ const quiet=days.filter(row=>Number(row?.covered_cost)>0&&(Number(row?.changed_lines)||0)===0);
+ if(quiet.length&&days.length){
+  const quietCost=quiet.reduce((total,row)=>total+(Number(row.covered_cost)||0),0);
+  rows.push({key:'quiet_days',kind:quiet.length>=Math.max(2,Math.round(days.length*.4))?'warn':'neutral',priority:35,
+   title:`${quiet.length} of ${days.length} ${countWord(days.length,'day')} had spend but no pushes`,
+   text:`${money(quietCost)} spent. Work may land in a later push.`});
+ }
+ const added=Number(overall?.added),deleted=Number(overall?.deleted),changed=Number(overall?.changed_lines);
+ if(available?.code_pushed===true&&Number.isFinite(changed)&&changed>0&&Number.isFinite(deleted)&&Number.isFinite(added)){
+  rows.push({key:'deleted_share',kind:'neutral',priority:40,
+   title:`${deliveryPercent(100*deleted/changed)} of pushed lines were deletions`,
+   text:`${f(added)} added, ${f(deleted)} deleted. Normal editing, not defects.`});
+ }
+ const projectRows=Array.isArray(payload?.project_rows)?payload.project_rows:[];
+ const costed=projectRows.filter(row=>row?.availability?.cost===true&&Number(row?.covered_cost)>0);
+ if(costed.length>1){
+  const total=costed.reduce((sum,row)=>sum+Number(row.covered_cost),0);
+  const top=costed.reduce((best,row)=>Number(row.covered_cost)>Number(best.covered_cost)?row:best);
+  const share=total>0?Number(top.covered_cost)/total:0;
+	  if(share>=.6)rows.push({key:'concentration',kind:'neutral',priority:50,action:'project',value:top.project,
+	   title:`${deliveryPercent(100*share)} of covered spend sits in ${deliveryProjectName(top.project)}`,
+	   text:`${money(top.covered_cost)} of ${money(total)} across ${costed.length} ${countWord(costed.length,'project')}.`});
+ }
+ const selectedCount=Number(coverage?.selected_repositories)||0,comparable=Number(coverage?.comparable_repositories)||0;
+ if(selectedCount&&comparable<selectedCount){
+	  rows.push({key:'coverage',kind:'neutral',priority:60,action:'coverage',value:'',
+	   title:`${comparable} of ${selectedCount} ${countWord(selectedCount,'project')} have both spend and Git`,
+	   text:'Ratios use only these; the rest may shift them.'});
+ }
+ const ranked=rows.sort((left,right)=>left.priority-right.priority||left.key.localeCompare(right.key));
+ const coverageRow=ranked.find(row=>row.key==='coverage');
+ if(!coverageRow)return ranked.slice(0,5);
+	 return ranked.filter(row=>row.key!=='coverage').slice(0,4).concat(coverageRow);
+}
+function deliveryProjectEvidence(row){
+ const cost=row?.availability?.cost===true,code=row?.availability?.code_pushed===true;
+ if(cost&&code)return {key:'comparable',label:'Comparable',detail:'Spend + Git'};
+ if(cost)return {key:'spend_only',label:'Spend only',detail:'Git unavailable'};
+ if(code)return {key:'git_only',label:'Git only',detail:'Spend unavailable'};
+ return {key:'unavailable',label:'No period evidence',detail:'Spend + Git unavailable'};
+}
+function deliveryFilteredProjectRows(rows,filter=deliveryEvidenceFilter){
+ const normalized=DELIVERY_EVIDENCE_FILTERS.includes(filter)?filter:'all';
+ return (rows||[]).filter(row=>normalized==='all'||deliveryProjectEvidence(row).key===normalized);
+}
+function selectDeliveryProject(project){
+ const projects=Array.isArray(deliveryPayload?.projects)?deliveryPayload.projects:[];
+ if(!projects.includes(project))return;
+	 deliveryProject=project;deliverySelectedDay='';deliveryEvidenceFilter='all';localStorage.setItem('tm_delivery_project',deliveryProject);
+ const select=$('d-project');if(select)select.value=deliveryProject;
+ loadDelivery();
+}
+function deliverySortValue(row,key){
+ if(key==='project')return deliveryProjectName(row?.project).toLowerCase();
+ const value=Number(row?.[key]);
+ if(key==='changed_lines'&&row?.availability?.code_pushed!==true)return null;
+ if(key==='covered_cost'&&row?.availability?.cost!==true)return null;
+ if(key==='spend_per_1k'&&row?.availability?.spend_per_1k!==true)return null;
+ return Number.isFinite(value)?value:null;
+}
+function sortedDeliveryRows(rows){
+ const direction=deliverySort.direction==='asc'?1:-1;
+ return [...(rows||[])].sort((left,right)=>{
+  const a=deliverySortValue(left,deliverySort.key),b=deliverySortValue(right,deliverySort.key);
+  if(a===null&&b===null)return deliveryProjectName(left.project).localeCompare(deliveryProjectName(right.project));
+  if(a===null)return 1;if(b===null)return -1;
+  const compared=typeof a==='string'?a.localeCompare(b):a-b;
+  return compared?compared*direction:deliveryProjectName(left.project).localeCompare(deliveryProjectName(right.project));
+ });
+}
+function renderDeliveryTable(rows){
+	 rows=rows||[];
+	 const visible=deliveryFilteredProjectRows(rows),body=$('d-project-table').querySelector('tbody'),sorted=sortedDeliveryRows(visible);
+	 const totalCost=rows.filter(row=>row?.availability?.cost===true).reduce((total,row)=>total+(Number(row.covered_cost)||0),0);
+	 const evidenceCounts={comparable:0,spend_only:0,git_only:0,unavailable:0};
+	 rows.forEach(row=>{evidenceCounts[deliveryProjectEvidence(row).key]++;});
+	 const evidenceSelect=$('d-evidence-filter');
+	 if(evidenceSelect){
+	  const labels={all:'All projects',comparable:'Comparable',spend_only:'Spend only',git_only:'Git only',unavailable:'No period evidence'};
+	  [...evidenceSelect.options].forEach(option=>{const count=option.value==='all'?rows.length:evidenceCounts[option.value];option.textContent=`${labels[option.value]} (${count})`;});
+	  evidenceSelect.value=deliveryEvidenceFilter;
+	 }
+	 body.innerHTML=sorted.length?sorted.map(row=>{
+	  const codeAvailable=row?.availability?.code_pushed===true,costAvailable=row?.availability?.cost===true,ratioAvailable=row?.availability?.spend_per_1k===true;
+	  const project=deliveryProjectName(row.project);
+	  const cost=Number(row.covered_cost)||0,share=costAvailable&&totalCost>0?Math.max(0,Math.min(100,100*cost/totalCost)):0;
+	  const shareBar=costAvailable&&totalCost>0?`<span class=deliverySpendShare style="--share:${share.toFixed(2)}" title="${esc(`${deliveryPercent(share)} of covered spend in this period`)}"><i aria-hidden=true></i></span>`:'';
+	  const added=Number(row.added)||0,deleted=Number(row.deleted)||0,changed=added+deleted;
+	  const composition=codeAvailable&&changed>0?`<span class=deliveryComposition title="${esc(`${f(added)} added · ${f(deleted)} deleted`)}"><i aria-hidden=true style="width:${(100*added/changed).toFixed(2)}%"></i><i class=deleted aria-hidden=true style="width:${(100*deleted/changed).toFixed(2)}%"></i></span>`:'';
+	  return `<tr><td title="${esc(row.project)}" data-label="Project"><button class=deliveryProjectLink type=button data-delivery-project="${esc(row.project)}">${esc(project)}</button></td><td class=num data-label="Spend">${costAvailable?money(cost):'--'}${shareBar}</td><td class="num mono" data-label="Pushed lines">${codeAvailable?f(row.changed_lines):'--'}${composition}</td><td class="num mono" data-label="Spend / 1K">${ratioAvailable?money(row.spend_per_1k):'--'}</td></tr>`;
+	 }).join(''):'<tr><td colspan=4><div class="deliveryEmpty emptyState">No projects match this filter.</div></td></tr>';
+	 body.querySelectorAll('[data-delivery-project]').forEach(button=>button.addEventListener('click',()=>selectDeliveryProject(button.dataset.deliveryProject)));
+ $('d-project-table').querySelectorAll('th').forEach(header=>{
+  const button=header.querySelector('[data-delivery-sort]'),active=button?.dataset.deliverySort===deliverySort.key;
+  header.setAttribute('aria-sort',active?(deliverySort.direction==='asc'?'ascending':'descending'):'none');
+  const mark=button?.querySelector('.deliverySortMark');if(mark)mark.textContent=active?(deliverySort.direction==='asc'?'↑':'↓'):'';
+ });
+ const mobileSort=$('d-mobile-sort'),mobileChoice=`${deliverySort.key}:${deliverySort.direction}`;
+ if(mobileSort&&[...mobileSort.options].some(option=>option.value===mobileChoice))mobileSort.value=mobileChoice;
+}
+function deliveryModelSortValue(row,key){
+ if(key==='model')return String(row?.model||'').toLowerCase();
+ const value=row?.[key];
+ if(value===null||value===undefined)return null;
+ const number=Number(value);
+ return Number.isFinite(number)?number:null;
+}
+function sortedDeliveryModelRows(rows){
+ const direction=deliveryModelSort.direction==='asc'?1:-1;
+ return [...(rows||[])].sort((left,right)=>{
+  const a=deliveryModelSortValue(left,deliveryModelSort.key),b=deliveryModelSortValue(right,deliveryModelSort.key);
+  if(a===null&&b===null)return String(left.model).localeCompare(String(right.model));
+  if(a===null)return 1;if(b===null)return -1;
+  const compared=typeof a==='string'?a.localeCompare(b):a-b;
+  return compared?compared*direction:String(left.model).localeCompare(String(right.model));
+ });
+}
+function renderDeliveryModelTable(rows,coverage){
+ rows=Array.isArray(rows)?rows:[];
+ const body=$('d-model-table').querySelector('tbody'),sorted=sortedDeliveryModelRows(rows);
+ const comparableLines=Number(coverage?.comparable_lines)||0,attributedLines=Number(coverage?.attributed_lines)||0;
+ $('d-model-note').textContent=coverage?.available?`${f(attributedLines)} / ${f(comparableLines)} lines attributed${coverage?.truncated?' · top 50':''}`:'No model lines in this period.';
+ body.innerHTML=sorted.length?sorted.map(row=>`<tr><td data-label="Model"><div class=modelName title="${esc(row.model)}">${esc(row.model)}</div></td><td data-label="App">${esc(row.runtime||'unknown runtime')}</td><td data-label="Effort">${esc(modelEffortLabel(row))}</td><td class="num mono" data-label="Spend">${money(Number(row.covered_cost)||0)}</td><td class="num mono" data-label="Est. lines">${f(Math.round(Number(row.attributed_lines)||0))}</td></tr>`).join(''):`<tr><td colspan=5><div class="deliveryEmpty emptyState">${comparableLines>0?'No model spend in comparable projects.':'Needs a project with both pushes and spend.'}</div></td></tr>`;
+ $('d-model-table').querySelectorAll('th').forEach(header=>{
+  const button=header.querySelector('[data-delivery-model-sort]'),active=button?.dataset.deliveryModelSort===deliveryModelSort.key;
+  header.setAttribute('aria-sort',active?(deliveryModelSort.direction==='asc'?'ascending':'descending'):'none');
+  const mark=button?.querySelector('.deliverySortMark');if(mark)mark.textContent=active?(deliveryModelSort.direction==='asc'?'↑':'↓'):'';
+ });
+}
+function deliveryDateLabel(day,compact=false){
+ const date=new Date(`${day}T12:00:00`);
+ if(Number.isNaN(date.getTime()))return day;
+ return date.toLocaleDateString(undefined,compact?{weekday:'short'}:{month:'short',day:'numeric'});
+}
+function deliveryFreshnessLabel(timestamp){
+ const value=Number(timestamp),date=new Date(value*1000);
+ if(!value||Number.isNaN(date.getTime()))return 'Git scan pending.';
+ return `Last Git scan ${date.toLocaleString(undefined,{month:'short',day:'numeric',hour:'numeric',minute:'2-digit'})}`;
+}
+function setDeliveryEvidencePanel(open){
+ const panel=$('d-evidence-panel'),trigger=$('d-coverage');if(!panel||!trigger)return;
+ panel.hidden=!open;trigger.setAttribute('aria-expanded',open?'true':'false');
+ if(open)panel.scrollIntoView({block:'nearest'});
+}
+function setDeliveryEvidenceFilter(filter,{scroll=true}={}){
+ deliveryEvidenceFilter=DELIVERY_EVIDENCE_FILTERS.includes(filter)?filter:'all';
+ renderDeliveryTable(deliveryPayload?.project_rows||[]);
+ if(scroll)$('d-project-table')?.scrollIntoView({block:'start'});
+}
+function setDeliveryEvidenceRatio(text,detail){
+ const ratio=$('d-evidence-ratio');ratio.textContent=text;ratio.dataset.tip=detail;ratio.setAttribute('aria-description',detail);
+}
+function renderDeliveryEvidence(payload){
+ const coverage=payload?.coverage||{},rows=Array.isArray(payload?.project_rows)?payload.project_rows:[];
+ const counts={comparable:0,spend_only:0,git_only:0,unavailable:0};
+ rows.forEach(row=>{counts[deliveryProjectEvidence(row).key]++;});
+ const spendCoverage=Number(coverage.spend_coverage),available=coverage.spend_coverage!==null&&coverage.spend_coverage!==undefined&&Number.isFinite(spendCoverage);
+ $('d-evidence-spend').textContent=available?`${Math.round(100*Math.max(0,Math.min(1,spendCoverage)))}%`:'--';
+ $('d-evidence-count-comparable').textContent=f(counts.comparable);
+ $('d-evidence-count-spend').textContent=f(counts.spend_only);
+ $('d-evidence-count-git').textContent=f(counts.git_only);
+ $('d-evidence-count-unavailable').textContent=f(counts.unavailable);
+ const selected=Number(coverage.selected_repositories)||rows.length,comparable=Number(coverage.comparable_repositories)||0;
+ const ratioDetail=selected?`${comparable} of ${selected} ${countWord(selected,'project')} can compare ratios; every ratio on this page uses only that overlap.`:'No selected projects have period evidence yet.';
+ setDeliveryEvidenceRatio(selected?`${comparable} / ${selected} comparable`:'No comparable projects',ratioDetail);
+ $('d-evidence-freshness').textContent=deliveryFreshnessLabel(coverage.last_checked);
+}
+function deliveryCommitsMeasured(row){
+ const value=row?.commits;
+ return typeof value==='number'&&Number.isFinite(value)&&value>=0;
+}
+function renderDeliveryDayInspector(row,index,rows){
+ const inspector=$('d-day-inspector');if(!inspector)return;
+ const ratioAvailable=row?.availability?.spend_per_1k===true,rollingAvailable=row?.availability?.rolling_spend_per_1k===true,costAvailable=row?.availability?.cost===true,codeAvailable=row?.availability?.code_pushed===true;
+ const lowVolume=ratioAvailable&&(Number(row?.comparable_changed_lines)||0)<DELIVERY_MIN_RATIO_LINES;
+ $('d-day-title').textContent=deliveryDateLabel(row.day);
+ $('d-day-note').textContent=lowVolume?'Under 50 lines · ratio is noisy.':'';
+ const dayCommitsAvailable=codeAvailable&&deliveryCommitsMeasured(row);
+ $('d-day-metrics').innerHTML=`<div class="deliveryDayMetric metric"><span>Pushed lines</span><b>${codeAvailable?f(row.changed_lines):'--'}</b></div><div class="deliveryDayMetric metric"><span>Commits</span><b>${dayCommitsAvailable?f(row.commits):'--'}</b></div><div class="deliveryDayMetric metric"><span>Covered spend</span><b>${costAvailable?money(row.covered_cost):'--'}</b></div><div class="deliveryDayMetric metric"><span>Day spend / 1K</span><b>${ratioAvailable?money(row.spend_per_1k):'--'}</b></div><div class="deliveryDayMetric metric"><span>7-day spend / 1K</span><b>${rollingAvailable?money(row.rolling_spend_per_1k):'--'}</b></div>`;
+ $('d-day-prev').disabled=index<=0;$('d-day-next').disabled=index>=rows.length-1;
+ inspector.hidden=false;
+}
+function selectAdjacentDeliveryDay(offset){
+ const rows=deliveryPayload?.days||[],index=rows.findIndex(row=>row.day===deliverySelectedDay),next=index+offset;
+ if(index<0||next<0||next>=rows.length)return;
+ selectDeliveryDay(rows[next].day);
+}
+function dismissGitChartInspector(){
+ deliverySelectedDay='';
+ const tip=$('d-chart-tip');if(tip)tip.hidden=true;
+ $('d-chart-hits')?.querySelectorAll('button[aria-pressed=true]').forEach(button=>button.setAttribute('aria-pressed','false'));
+ const inspector=$('d-day-inspector');if(inspector)inspector.hidden=true;
+}
+function hideDeliveryChartTip(){
+ const tip=$('d-chart-tip');if(tip)tip.hidden=true;
+}
+function selectDeliveryDay(day,button){
+ const rows=deliveryPayload?.days||[],index=rows.findIndex(row=>row.day===day);
+ if(index<0)return;
+ deliverySelectedDay=day;
+ const row=rows[index];
+ const tip=$('d-chart-tip');
+	 tip.innerHTML=`<strong>${esc(deliveryDateLabel(day))}</strong><div class=deliveryTipRow><span>Pushed lines</span><b>${f(row.changed_lines)}</b></div><div class=deliveryTipRow><span>Added</span><b>+${f(row.added)}</b></div><div class=deliveryTipRow><span>Deleted</span><b>-${f(row.deleted)}</b></div><div class=deliveryTipRow><span>Commits</span><b>${deliveryCommitsMeasured(row)?f(row.commits):'--'}</b></div>`;
+ const width=$('d-daily-chart')?.viewBox?.baseVal?.width||1040,count=Math.max(1,rows.length),{left,right}=DELIVERY_CHART_INSET,center=100*(left+((width-left-right)/count)*(index+.5))/width;
+ tip.style.left=`${Math.max(11,Math.min(89,center)).toFixed(2)}%`;tip.style.top='66px';tip.hidden=false;
+	 $('d-chart-hits').querySelectorAll('button').forEach(item=>item.setAttribute('aria-pressed',item.dataset.deliveryDay===day?'true':'false'));
+	 renderDeliveryDayInspector(row,index,rows);
+ if(button?.focus&&document.activeElement===button)button.scrollIntoView({block:'nearest',inline:'nearest'});
+}
+function selectDeliveryDayFromPointer(day,button){
+ if(deliveryIgnorePointerSelection)return;
+ selectDeliveryDay(day,button);
+}
+const DELIVERY_CHART_INSET={left:58,right:40,top:38,bottom:40};
+function drawDeliveryChart(rows){
+ rows=Array.isArray(rows)?rows:[];
+ const svg=$('d-daily-chart'),hits=$('d-chart-hits'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(200,Math.round(svg.clientHeight||310));
+ svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+	 if(!rows.length){svg.innerHTML=`<text class=axis x=${Math.round(VW/2)} y=${Math.round(VH/2)} text-anchor=middle>No Git evidence in this period</text>`;hits.innerHTML='';dismissGitChartInspector();return;}
+ const left=DELIVERY_CHART_INSET.left,right=VW-DELIVERY_CHART_INSET.right,barTop=DELIVERY_CHART_INSET.top,barBottom=VH-DELIVERY_CHART_INSET.bottom,plotWidth=right-left;
+ const lineMax=Math.max(1,...rows.map(row=>Number(row.changed_lines)||0));
+ const step=plotWidth/Math.max(rows.length,1);
+ const x=index=>left+step*(index+.5);
+ const barWidth=Math.max(3,Math.min(34,step*.42));
+ const labelEvery=Math.max(1,Math.ceil(rows.length/7));
+ let markup='';
+ [0,.5,1].forEach(share=>{const y=barBottom-share*(barBottom-barTop),value=lineMax*share;markup+=`<line class=grid x1=${left} y1=${y} x2=${right} y2=${y} /><text class=axis x=${left-9} y=${y+3} text-anchor=end>${esc(compactNumber(value))}</text>`;});
+ rows.forEach((row,index)=>{
+  const center=x(index),added=Number(row.added)||0,deleted=Number(row.deleted)||0,total=Math.max(0,added+deleted),height=total/lineMax*(barBottom-barTop),deletedHeight=total?height*(deleted/total):0,addedHeight=height-deletedHeight;
+  if(deletedHeight>0)markup+=`<rect class=deleted x=${(center-barWidth/2).toFixed(1)} y=${(barBottom-deletedHeight).toFixed(1)} width=${barWidth.toFixed(1)} height=${deletedHeight.toFixed(1)} rx=1 />`;
+  if(addedHeight>0)markup+=`<rect class=added x=${(center-barWidth/2).toFixed(1)} y=${(barBottom-height).toFixed(1)} width=${barWidth.toFixed(1)} height=${addedHeight.toFixed(1)} rx=2 />`;
+  if(index%labelEvery===0||index===rows.length-1)markup+=`<text class=axis x=${center.toFixed(1)} y=${VH-11} text-anchor=middle>${esc(deliveryDateLabel(row.day,rows.length<=7))}</text>`;
+ });
+ svg.innerHTML=markup;
+ hits.style.left=`${left}px`;hits.style.right=`${VW-right}px`;hits.style.top=`${barTop}px`;hits.style.bottom='9px';hits.style.setProperty('--delivery-days',rows.length);
+ hits.innerHTML=rows.map(row=>`<button type=button data-delivery-day="${esc(row.day)}" aria-pressed=false aria-label="${esc(`${deliveryDateLabel(row.day)}, ${f(row.changed_lines)} pushed text lines, ${f(row.added)} added and ${f(row.deleted)} deleted`)}"></button>`).join('');
+ hits.querySelectorAll('button').forEach(button=>{
+  button.addEventListener('pointerenter',()=>selectDeliveryDayFromPointer(button.dataset.deliveryDay,button));
+  button.addEventListener('focus',()=>selectDeliveryDay(button.dataset.deliveryDay,button));
+  button.addEventListener('click',()=>selectDeliveryDay(button.dataset.deliveryDay,button));
+ });
+	 if(deliverySelectedDay&&rows.some(row=>row.day===deliverySelectedDay))selectDeliveryDay(deliverySelectedDay);else dismissGitChartInspector();
+}
+function renderDeliverySignals(payload){
+ const list=$('d-signals'),rows=deliverySignals(payload);
+	 list.innerHTML=rows.length?rows.map(row=>{
+	  const body=`<i aria-hidden=true></i><div class=deliverySignalBody><b>${esc(row.title)}</b>${row.text?`<span>${esc(row.text)}</span>`:''}</div>`;
+	  const classes=`deliverySignal ${row.kind==='warn'?'warn':row.kind==='good'?'good':''}`;
+	  return row.action?`<button class="${classes}" type=button data-delivery-signal-action="${esc(row.action)}" data-delivery-signal-value="${esc(row.value||'')}">${body}</button>`:`<div class="${classes}">${body}</div>`;
+	 }).join(''):'<div class="deliverySignalEmpty emptyState">No overlapping Git and spend in this period.</div>';
+	 list.querySelectorAll('[data-delivery-signal-action]').forEach(button=>button.addEventListener('click',event=>{
+	  event.stopPropagation();
+	  const action=button.dataset.deliverySignalAction,value=button.dataset.deliverySignalValue;
+	  if(action==='day'){deliveryIgnorePointerSelection=true;$('d-chart-wrap')?.scrollIntoView({block:'center'});selectDeliveryDay(value);}
+	  else if(action==='project')selectDeliveryProject(value);
+	  else if(action==='coverage')setDeliveryEvidencePanel(true);
+	 }));
+}
+function renderDeliveryShape(payload){
+ const host=$('d-shape'),rows=deliveryShapeRows(payload);
+ if(!rows.some(row=>row.distribution)){host.innerHTML='<div class="deliveryShapeEmpty emptyState">No daily data in this period.</div>';return;}
+ const header='<div class=deliveryShapeHeader><span></span><span></span><span><span>Median</span><span>Range</span><span>High</span></span></div>';
+ host.innerHTML=header+rows.map(row=>{
+  const distribution=row.distribution;
+  if(!distribution)return `<div class=deliveryShapeRow><span class=deliveryShapeIdentity><b>${esc(row.label)}</b><small>No data</small></span><span class=deliveryShapeRail></span><span class=deliveryShapeValues><span>--</span><span>--</span><span>--</span></span></div>`;
+  const range=deliveryShapeRange(distribution),stable=range.label==='Middle half';
+  const fence=stable?Math.max(distribution.p75+1.5*(distribution.p75-distribution.p25),distribution.median*1.25,distribution.p75):distribution.max;
+  const span=Math.min(distribution.max,fence)||1,beyond=stable&&distribution.max>span*1.0001;
+  const percent=value=>`${Math.max(0,Math.min(100,100*value/span)).toFixed(2)}%`;
+  const rail=`<span class=deliveryShapeRail role=img aria-label="${esc(`${row.label}: median ${row.format(distribution.median)}, ${range.label.toLowerCase()} ${row.format(range.low)} to ${row.format(range.high)}, high day ${row.format(distribution.max)}${beyond?' beyond the rail scale':''} across ${distribution.count} ${countWord(distribution.count,'day')}`)}"><i class=deliveryShapeIqr style="--p25:${percent(range.low)};--p75:${percent(range.high)}"></i><i class=deliveryShapeMedian style="--median:${percent(distribution.median)}"></i><i class="deliveryShapeHigh${beyond?' beyond':''}" style="--p90:${percent(distribution.max)}"></i></span>`;
+  return `<div class=deliveryShapeRow><span class=deliveryShapeIdentity><b>${esc(row.label)}</b><small>${distribution.count} ${countWord(distribution.count,'day')} · ${esc(range.label.toLowerCase())}</small></span>${rail}<span class=deliveryShapeValues><span data-label="Median">${esc(row.format(distribution.median))}</span><span data-label="${esc(range.label)}">${esc(`${row.format(range.low)}–${row.format(range.high)}`)}</span><span data-label="High day">${esc(row.format(distribution.max))}</span></span></div>`;
+ }).join('');
+}
+document.addEventListener('click',event=>{
+ const target=event.target instanceof Element?event.target:null;
+	 if(!target?.closest('#d-chart-wrap')&&!target?.closest('#d-day-inspector'))dismissGitChartInspector();
+});
+document.addEventListener('pointermove',()=>{deliveryIgnorePointerSelection=false;},{passive:true});
+document.addEventListener('keydown',event=>{
+ if(event.key==='Escape')dismissGitChartInspector();
+});
+function renderDelivery(payload){
+ deliveryPayload=payload||{};
+ const projects=Array.isArray(payload?.projects)?payload.projects:[],select=$('d-project');
+ const selected=projects.includes(deliveryProject)?deliveryProject:'';
+ if(selected!==deliveryProject){deliveryProject=selected;localStorage.setItem('tm_delivery_project',deliveryProject);}
+ select.innerHTML='<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(deliveryProjectName(project))}</option>`).join('');select.value=deliveryProject;
+ const rangeSelect=$('d-range');rangeSelect.value=deliveryRange;
+ $('d-period-label').textContent=rangeSelect.selectedOptions[0]?.textContent||'Selected period';
+ const overall=payload?.overall||{},available=overall?.availability||{},coverage=payload?.coverage||{};
+ $('d-code-pushed').textContent=available.code_pushed===true?compactNumber(overall.changed_lines):'--';
+ $('d-added').textContent=available.code_pushed===true?`+${f(overall.added)}`:'--';
+ $('d-deleted').textContent=available.code_pushed===true?`-${f(overall.deleted)}`:'--';
+ $('d-spend-lines').textContent=available.spend_per_1k===true?money(overall.spend_per_1k):'--';
+ $('d-spend-note').innerHTML=available.cost===true?`<b>${money(overall.covered_cost)}</b> covered spend`:'Waiting for coverage.';
+ const efficiency=overall?.efficiency||{},yieldAvailable=efficiency?.availability?.delivery_yield===true;
+ // The Git service compares month-to-date with the same days of last month, not the whole month.
+ const comparison=payload?.comparison||{},comparisonLabel=deliveryRange==='month'?'same days last month':efficiencyComparisonWindows(deliveryRange)?.label||'prior period';
+ const gitDelta=key=>comparison.available?percentTrendDelta(comparison[key],comparisonLabel):{text:'No comparable prior period',direction:''};
+ // Git deltas stay neutral: pushed-code evidence is never scored as better or worse.
+ renderTrendDelta('d-code-pushed-change',gitDelta('code_pushed_pct'),'',available.code_pushed!==true);
+ renderTrendDelta('d-spend-lines-change',gitDelta('spend_per_1k_pct'),'',available.spend_per_1k!==true);
+ $('d-push-yield').textContent=yieldAvailable?deliveryRatio(efficiency.delivery_yield):'--';
+ $('d-push-yield-note').textContent=yieldAvailable?'lines / 1K output':'Waiting for output tokens.';
+ renderTrendDelta('d-push-yield-change',gitDelta('delivery_yield_pct'),'',!yieldAvailable);
+ const changedLines=Number(overall?.changed_lines)||0;
+ $('d-rework').textContent=available.code_pushed===true&&changedLines>0?deliveryPercent(100*(Number(overall.deleted)||0)/changedLines):'--';
+ $('d-comparison').innerHTML=deliveryComparisonText(payload?.comparison||{});
+ const selectedCount=Number(coverage.selected_repositories)||0,measured=Number(coverage.measured_repositories)||0,comparable=Number(coverage.comparable_repositories)||0,checked=Number(coverage.last_checked)||0,days=Array.isArray(payload?.days)?payload.days:[];
+ const coverageNode=$('d-coverage');
+ const spendCoverage=Number(coverage.spend_coverage),spendCoverageAvailable=coverage.spend_coverage!==null&&coverage.spend_coverage!==undefined&&Number.isFinite(spendCoverage);
+ const coveragePercent=spendCoverageAvailable?Math.max(0,Math.min(100,Math.round(100*spendCoverage))):0,coverageBar=$('d-coverage-bar');
+ const evidencePartial=!spendCoverageAvailable||coveragePercent<100||comparable<selectedCount||available.partial===true;
+ coverageBar.style.setProperty('--delivery-coverage',coveragePercent);
+ coverageBar.classList.toggle('partial',evidencePartial);
+ if(spendCoverageAvailable){coverageBar.setAttribute('aria-valuenow',coveragePercent);coverageBar.removeAttribute('aria-valuetext');}
+ else{coverageBar.removeAttribute('aria-valuenow');coverageBar.setAttribute('aria-valuetext','Spend coverage unavailable');}
+ $('d-coverage-percent').textContent=spendCoverageAvailable?`${coveragePercent}%`:'--';
+ const activeDays=days.filter(row=>(Number(row?.changed_lines)||0)>0).length;
+ $('d-active-days').textContent=checked&&available.code_pushed===true&&days.length?`${activeDays} / ${days.length}`:'--';
+ const commitsAvailable=available.code_pushed===true&&deliveryCommitsMeasured(overall);
+ $('d-commits').textContent=commitsAvailable?f(overall.commits):'--';
+ $('d-repo-evidence').textContent=checked&&selectedCount?`${measured} / ${selectedCount}`:'--';
+ $('d-comparable-evidence').textContent=checked?`${comparable} ${countWord(comparable,'project')}`:'--';
+ coverageNode.classList.toggle('partial',evidencePartial||!checked);
+ coverageNode.textContent=!checked?'Scanning local Git':selectedCount?(evidencePartial?'Partial evidence':'Evidence ready'):'No Git projects found';
+	 drawDeliveryChart(days);renderDeliveryModelTable(payload?.model_rows||[],payload?.model_coverage);renderDeliveryTable(payload?.project_rows||[]);
+	 renderDeliveryEvidence(payload);renderDeliverySignals(payload);renderDeliveryShape(payload);
+}
+let deliveryRetryTimer=0,deliveryLoadRetries=0;
diff --git a/dashboard/js/goals.js b/dashboard/js/goals.js
new file mode 100644
index 00000000..f40837d5
--- /dev/null
+++ b/dashboard/js/goals.js
@@ -0,0 +1,535 @@
+let GOALS=null,goalsLoading=null,goalsLoadedAt=0,goalDraft=null,goalPreviewRequest=0,goalsListModes={},goalModelRequest=0,goalModelTimer=0;
+const GOAL_STATUS_LABELS={on_track:'On track',at_risk:'At risk',met:'Met',missed:'Missed',no_result:'No result',ended:'Ended'};
+const GOAL_CONFIDENCE={complete:'Complete data',partial:'Partial data',estimated:'Estimated'};
+const GOAL_METRIC_HELP={
+ tokens:'Processed input plus output tokens, including cache and reasoning once. Usage volume is not a productivity or quality score. Set At most for a cap or At least for a milestone.',
+ spend:'Estimated cost of agent work in the period. Lower it with cheaper models, less reasoning, and shorter sessions.',
+ output_per_dollar:'Output tokens for each dollar spent. It rises with cheaper models and better cache use. More output is not always better work.',
+ cost_per_1k_lines:'What 1,000 pushed lines cost in agent spend, in the repositories your sessions ran in. Lower means more code shipped per dollar. Delivery evidence, not a quality score. Needs at least 50 lines.',
+ context_load:'Tokens the agent reads for each token it writes. Lower it by starting fresh sessions and trimming the context you load.',
+ reasoning_ratio:'Share of output spent on reasoning. Lower it by choosing a lower reasoning effort when a task does not need it. Sessions from runtimes that do not report reasoning tokens are left out.',
+ frontier_share:'Share of spend on frontier models. Lower it by using mid range or efficient models for routine work. Spend on unrecognized models is shown separately.',
+ work_pushback:'Share of labeled follow-ups where your next message pushed back, for one kind of work or all, and all models or chosen ones. Lower means the agent got it right more often. Local-model labels, so an estimate; a result needs 20 labeled follow-ups.',
+ agent_per_human:'Agent turns (model calls) per message you typed, kept inside a range, for one kind of work or all, and all models or chosen ones. It counts only while pushback stays under the pushback goal with the same kind of work and models, so long runs that needed correcting never count as progress.',
+};
+const GOAL_PUSHED_SCOPE='All projects includes discovered repositories with both spend and measured Git coverage, across all apps and models. Lines pushed counts additions plus deletions. Sessions outside repository folders are not attributed.';
+function goalRepoText(count,names){
+ if(!count)return 'no repositories';
+ const shown=(names||[]).slice(0,3).join(', '),more=count-Math.min(count,3);
+ return `${count} ${count===1?'repository':'repositories'}${shown?` (${shown}${more>0?`, +${more} more`:''})`:''}`;
+}
+function goalCoverageText(share){return share===null||share===undefined?'':`${share<1&&share>0?'under 1':Math.round(share)}% of your agent spend`;}
+function goalUnit(metric){return GOALS?.metrics?.[metric]?.unit||'';}
+function goalLabel(metric){return GOALS?.metrics?.[metric]?.label||metric;}
+function goalIsWork(metric){return (GOALS?.metrics?.[metric]?.scopes||[]).includes('work_type');}
+function goalTargetText(t,metric){
+ if(t.comparison!=='between')return `${t.comparison==='at_most'?'≤':'≥'} ${goalValue(t.target,metric)}`;
+ // A ratio range shares its ": 1", so it reads "32–48 : 1" rather than repeating it.
+ const ratio=v=>Number(v).toLocaleString(undefined,{maximumFractionDigits:1});
+ return goalUnit(metric)==='agent_ratio'?`${ratio(t.target)}–${ratio(t.target_high)} : 1`:`${goalValue(t.target,metric)} – ${goalValue(t.target_high,metric)}`;
+}
+function goalValue(value,metric){
+ const v=Number(value);
+ if(value===null||value===undefined||!Number.isFinite(v))return '--';
+ const unit=goalUnit(metric);
+ if(unit==='usd')return money(v);
+ if(unit==='tokens')return `${compactNumber(v)} tokens`;
+ if(unit==='tokens_per_usd')return `${compactNumber(v)} / $`;
+ if(unit==='usd_per_1k_lines')return `${money(v)} / 1K lines`;
+ if(unit==='percent')return `${v.toFixed(1)}%`;
+ if(unit==='agent_ratio')return `${v.toLocaleString(undefined,{maximumFractionDigits:1})} : 1`;
+ return efficiencyDecimal(v);
+}
+const GOAL_HOMES={spend:{route:'spend',section:'spend-goals',back:'Spend'},tokens:{route:'spend',section:'spend-goals',back:'Spend'},cost_per_1k_lines:{route:'git',section:'git-goals',back:'Git'},work_pushback:{route:'work',section:'work-goals',back:'Work'},agent_per_human:{route:'work',section:'work-goals',back:'Work'}};
+function goalHome(metric){return GOAL_HOMES[metric]||{route:'efficiency-goals',section:'efficiency-goals',back:'goals'};}
+function goalTitle(g){return g.title||`${goalLabel(g.metric)} for ${g.scope_label}`;}
+function goalIsCurrent(g){return !g.ended_at&&g.end>=(GOALS?.today||'');}
+function goalNotice(text,warn=false){
+ document.querySelectorAll('.goalsNotice').forEach(el=>{
+ el.textContent=text||'';
+ el.hidden=!text;el.classList.toggle('tone-warn',warn);});
+}
+function goalHistory(g){
+ if(!(g.history||[]).length)return '';
+ const label=h=>new Date(h.start+'T12:00:00').toLocaleDateString(undefined,g.period==='week'?{month:'short',day:'numeric'}:{month:'short'});
+ return `<div class=goalHistory aria-label="Previous periods">${g.history.map(h=>`<span class="chip goalStatus ${esc(h.status)}" title="${esc(goalValue(h.value,g.metric))}">${esc(label(h))} · ${esc(GOAL_STATUS_LABELS[h.status]||h.status)}</span>`).join('')}</div>`;
+}
+function goalGuardrail(g){
+ const r=g.guardrail;
+ if(!r||r.value===null||r.value===undefined)return '';
+ const open=goalIsCurrent(g)&&r.metric==='spend';
+ return `${goalLabel(r.metric)} ${goalValue(r.value,r.metric)}${open?' so far':''}${r.baseline!==null&&r.baseline!==undefined?` (${(r.baseline_label||'last period').toLowerCase()} ${goalValue(r.baseline,r.metric)})`:''}`;
+}
+function goalNotes(g){
+ const m=g.measurement||{};
+ return [g.metric==='cost_per_1k_lines'?`Across ${goalRepoText(m.projects||0,m.project_names)}`:'',
+  g.metric==='cost_per_1k_lines'&&m.observations?`${f(m.added)} added · ${f(m.deleted)} deleted`:'',
+  g.metric==='cost_per_1k_lines'&&m.counted_share!==null&&m.counted_share!==undefined?`Counts ${goalCoverageText(m.counted_share)}`:'',
+  m.unclassified_share?`Unrecognized models ${m.unclassified_share.toFixed(1)}% of spend`:'',
+  m.reasoning_excluded?`${m.reasoning_excluded} session${m.reasoning_excluded===1?'':'s'} without reported reasoning left out`:'',
+  m.cost_excluded?`${m.cost_excluded} session${m.cost_excluded===1?'':'s'} without reported cost left out`:'',
+  g.budget_reference?`Monthly budget ${money(g.budget_reference)}`:'',
+  m.guard?`Pushback ${goalValue(m.guard.value,'work_pushback')} vs its goal ≤ ${goalValue(m.guard.target,'work_pushback')}`:''].filter(Boolean);
+}
+function goalDateRange(g){
+ const s=new Date(g.start+'T12:00:00'),e=new Date(g.end+'T12:00:00'),year=new Date((GOALS?.today||g.end)+'T12:00:00').getFullYear();
+ const opts=d=>d.getFullYear()===year?{month:'short',day:'numeric'}:{month:'short',day:'numeric',year:'numeric'};
+ const end=s.getMonth()===e.getMonth()&&s.getFullYear()===e.getFullYear()?String(e.getDate()):e.toLocaleDateString(undefined,opts(e));
+ return `${s.toLocaleDateString(undefined,s.getFullYear()===e.getFullYear()&&s.getFullYear()===year?{month:'short',day:'numeric'}:opts(s))} – ${end}`;
+}
+function goalHistoryDots(g){
+ if(!(g.history||[]).length)return '';
+ const label=h=>new Date(h.start+'T12:00:00').toLocaleDateString(undefined,g.period==='week'?{month:'short',day:'numeric'}:{month:'short'});
+ return `<span class=goalDots>${g.history.map(h=>{const t=`${label(h)}: ${GOAL_STATUS_LABELS[h.status]||h.status}, ${goalValue(h.value,g.metric)}`;return `<i class="goalStatus ${esc(h.status)}" role=img aria-label="${esc(t)}" title="${esc(t)}"></i>`;}).join('')}</span>`;
+}
+function goalCard(g){
+ const m=g.measurement||{},value=m.value,range=g.comparison==='between',target=range?(Number(g.target)+Number(g.target_high))/2:Number(g.target),hasValue=value!==null&&value!==undefined;
+ const top=Math.max(hasValue?Number(value):0,target,range?Number(g.target_high):0,Number(m.projected)||0)*1.15||1;
+ const at=hasValue?Math.min(100,Number(value)/top*100):0,typ=Math.min(100,target/top*100);
+ const tone=g.status==='at_risk'||g.status==='missed'?'high':'';
+ const detail=g.status_reason||(m.projected!==undefined?`On pace for ${goalValue(m.projected,g.metric)}`:'');
+ const targetText=goalTargetText(g,g.metric);
+ const progressLabel=range?`${goalValue(value,g.metric)}, target ${targetText}`:`${goalValue(value,g.metric)} of ${g.comparison==='at_most'?'at most':'at least'} ${goalValue(target,g.metric)}`;
+ const confidence=m.confidence&&m.confidence!=='complete'?GOAL_CONFIDENCE[m.confidence]||'':'';
+ const meta=[g.title?g.scope_label:'',goalDateRange(g),g.repeat?`Repeats ${g.period==='week'?'weekly':g.period==='today'?'daily':'monthly'}`:''].filter(Boolean).join(' · ');
+ const menu=`<details class=goalMenu><summary class=tbtn aria-label="More actions for ${esc(goalTitle(g))}">⋯</summary><div class="modelPickerMenu goalMenuList" role=group><button type=button data-goal-duplicate="${esc(g.id)}">Duplicate</button>${goalIsCurrent(g)?`<button type=button data-goal-end="${esc(g.id)}">End goal</button>`:''}<button type=button class=goalMenuDanger data-goal-delete="${esc(g.id)}">Delete</button></div></details>`;
+ return `<article class="card goalCard" data-status="${esc(g.status)}"><div class=goalCardHead><h4><a class=goalTitleLink href="#efficiency-goals/${esc(g.id)}">${esc(goalTitle(g))}</a></h4><span class="chip goalStatus ${esc(g.status)}">${esc(GOAL_STATUS_LABELS[g.status]||g.status)}</span></div>`
+  +`<p class=goalMeta>${esc(meta)}</p>`
+  +`<div class=goalNumbers><strong class=mono>${esc(goalValue(value,g.metric))}</strong><span>Target ${esc(targetText)}</span>${confidence?`<span class=goalConfidence title="${esc(m.reason||'')}">${esc(confidence)}</span>`:''}</div>`
+  +`<span class=readoutScale role=img aria-label="${esc(progressLabel)}" data-tone="${tone}" style="--at:${at.toFixed(1)}%;--typ:${typ.toFixed(1)}%"><i class=readoutScaleFill></i><i class=readoutScaleTypical></i><i class=readoutScaleMark></i></span>`
+  +`<div class=goalFoot>${detail?`<span class=readoutCaption>${esc(detail)}</span>`:'<span></span>'}${goalHistoryDots(g)}<span class=goalActions><button class=tbtn type=button data-goal-edit="${esc(g.id)}">Edit</button>${menu}</span></div>`
+  +`</article>`;
+}
+const GOAL_SECTIONS={'spend-goals':'spend','git-goals':'delivery cost','efficiency-goals':'efficiency','work-goals':'work'};
+function renderGoalSection(section){
+ const root=$(section),mode=goalsListModes[section]||'current',noun=GOAL_SECTIONS[section];
+ const goals=(GOALS?.goals||[]).filter(g=>goalHome(g.metric).section===section),current=goals.filter(goalIsCurrent),previous=goals.filter(g=>!goalIsCurrent(g));
+ root.querySelector('[data-goals-current]').innerHTML=current.length?current.map(goalCard).join(''):`<p class="emptyState goalsEmpty">No current ${esc(noun)} goals.</p>`;
+ root.querySelector('[data-goals-previous]').innerHTML=previous.length?previous.map(goalCard).join(''):`<p class="emptyState goalsEmpty">No previous ${esc(noun)} goals.</p>`;
+ root.querySelector('[data-goals-current]').hidden=mode!=='current';
+ root.querySelector('[data-goals-previous]').hidden=mode!=='previous';
+ root.querySelector('[data-goals-toggle]').textContent=mode==='previous'?'Current goals':`Previous goals${previous.length?` (${previous.length})`:''}`;
+}
+function renderGoals(){
+ if(!GOALS)return;
+ if(GOALS.dropped&&document.querySelector('.goalsNotice')?.hidden)goalNotice(`${GOALS.dropped} goal${GOALS.dropped===1?'':'s'} from an earlier version can no longer be shown and will be removed the next time you save a goal.`);
+ Object.keys(GOAL_SECTIONS).forEach(renderGoalSection);
+}
+let goalSeedSent=false;
+async function seedDefaultGoals(){
+ if(goalSeedSent||!GOALS?.seed_pending||!agentActionToken())return;
+ goalSeedSent=true;
+ const result=await postGoalAction({operation:'seed'});
+ if(result.ok)acceptGoalResult(result);
+}
+async function loadGoals(force=false){
+ if(!force&&GOALS&&Date.now()-goalsLoadedAt<30000){renderGoals();return GOALS;}
+ if(goalsLoading)return goalsLoading;
+ goalsLoading=(async()=>{
+  try{
+   const data=await (await fetch('/goals',{cache:'no-store'})).json();
+   if(data.ok){GOALS=data;goalsLoadedAt=Date.now();renderGoals();seedDefaultGoals();}
+   else goalNotice(data.error||'Goals are unavailable right now.',true);
+  }catch{goalNotice('Goals are unavailable right now.',true);}
+  finally{goalsLoading=null;}
+  return GOALS;
+ })();
+ return goalsLoading;
+}
+function goalSelectedScope(){
+ const work=goalIsWork($('goals-metric').value),chosen=[...(goalDraft?.modelKeys||[])].sort();
+ if(work)return {kind:'work_type',key:$('goals-work-type').value,...(chosen.length?{keys:chosen}:{})};
+ const keys=[...(goalDraft?.modelKeys||[])].sort();
+ if(keys.length===1)return {kind:'model',key:keys[0]};
+ if(keys.length)return {kind:'models',key:'',keys};
+ return $('goals-app').value?{kind:'agent',key:$('goals-app').value}:{kind:'all',key:''};
+}
+function renderGoalModelPicker(){
+ if(!goalDraft)return;
+ const keys=goalDraft.modelKeys||[],enabled=(GOALS.metrics?.[$('goals-metric').value]?.scopes||[]).includes('model')||goalIsWork($('goals-metric').value),picker=$('goals-model-picker'),summary=picker.querySelector('summary');
+ summary.setAttribute('aria-disabled',String(!enabled));summary.tabIndex=enabled?0:-1;
+ if(!enabled)picker.open=false;
+ $('goals-model-summary').textContent=keys.length===0?'All models':keys.length===1?(goalDraft.models.find(m=>m.key===keys[0])?.label||'Model unavailable'):`${keys.length} models selected`;
+ const choices=goalDraft.models||[],focused=document.activeElement?.closest('[data-goal-model]')?.dataset.goalModel;
+ $('goals-model-options').innerHTML=`<label class="modelOption all"><input type=checkbox data-goal-model=all ${keys.length?'':'checked'} ${enabled?'':'disabled'}><span>All models</span></label>`+choices.map(m=>`<label class=modelOption title="${esc(m.label)}"><input type=checkbox data-goal-model="${esc(m.key)}" ${keys.includes(m.key)?'checked':''} ${enabled?'':'disabled'}><span>${esc(m.label)}</span></label>`).join('');
+ if(focused)$('goals-model-options').querySelector(`[data-goal-model="${focused}"]`)?.focus();
+ $('goals-model-search-field').hidden=!enabled;
+ if(picker.open)requestAnimationFrame(positionGoalModelPicker);
+}
+function fillGoalScopes(metric,scope={kind:'all',key:''}){
+ const work=goalIsWork(metric);
+ $('goals-app-field').hidden=work;$('goals-work-field').hidden=!work;
+ $('goals-work-type').innerHTML=(GOALS.work_types||[]).map(w=>`<option value="${esc(w.id)}">${esc(w.label)}</option>`).join('');
+ if(scope.kind==='work_type'&&scope.key)$('goals-work-type').value=scope.key;
+ const scopes=GOALS.metrics?.[metric]?.scopes||['all'],keys=scope.kind==='models'||scope.kind==='work_type'?scope.keys||[]:scope.kind==='model'?[scope.key]:[],known=[...(GOALS.models||[]),...(goalDraft.models||[])],model=known.find(m=>m.key===scope.key),app=scope.kind==='agent'?scope.key:scope.kind==='model'?model?.runtime||'':'';
+ $('goals-app').innerHTML='<option value="">All apps</option>'+(scopes.includes('agent')?(GOALS.agents||[]).map(a=>`<option value="${esc(a.id)}">${esc(a.label)}</option>`).join(''):'');
+ $('goals-app').value=app;$('goals-app').disabled=!scopes.includes('agent');
+ goalDraft.modelKeys=scopes.includes('model')||work?[...keys]:[];
+ goalDraft.models=(GOALS.models||[]).filter(m=>!app||m.runtime===app);
+ for(const key of goalDraft.modelKeys)if(!goalDraft.models.some(m=>m.key===key))goalDraft.models.push(known.find(m=>m.key===key)||{key,runtime:'',label:'Model unavailable — remove to choose another'});
+ $('goals-model-search').value='';renderGoalModelPicker();refreshGoalModels();
+}
+async function refreshGoalModels(){
+ const request=++goalModelRequest;
+ if(!goalDraft||!((GOALS.metrics?.[$('goals-metric').value]?.scopes||[]).includes('model')||goalIsWork($('goals-metric').value)))return;
+ const params=new URLSearchParams({models:'1',runtime:$('goals-app').value,query:$('goals-model-search').value});
+ $('goals-model-note').textContent='Reading observed models…';
+ let data;try{data=await(await fetch(`/goals?${params}`,{cache:'no-store'})).json();}catch{data={ok:false};}
+ if(request!==goalModelRequest||!goalDraft)return;
+ if(!data.ok){$('goals-model-note').textContent='Model choices are unavailable. Existing selection is preserved.';return;}
+ const previous=goalDraft.models||[],choices=[...(data.models||[])];
+ for(const key of goalDraft.modelKeys||[])if(!choices.some(m=>m.key===key))choices.push(previous.find(m=>m.key===key)||{key,runtime:'',label:'Model unavailable — remove to choose another'});
+ goalDraft.models=choices;renderGoalModelPicker();
+ $('goals-model-note').textContent=`${data.models.length} of ${data.total} models, by recent spend · up to ${GOALS.max_selected_models||32}`;
+}
+function positionGoalModelPicker(){
+ const picker=$('goals-model-picker'),menu=$('goals-model-menu');if(!picker.open){picker.classList.remove('opensUp');menu.style.maxHeight='';return;}
+ const rect=picker.querySelector('summary').getBoundingClientRect(),margin=12,above=Math.max(0,rect.top-margin),below=Math.max(0,window.innerHeight-rect.bottom-margin),preferred=Math.min(360,menu.scrollHeight||360),opensUp=below<preferred&&above>below;
+ picker.classList.toggle('opensUp',opensUp);menu.style.maxHeight=`${Math.min(360,opensUp?above:below)}px`;
+}
+function goalPeriodFields(){
+ const choice=$('goals-period').value;
+ if(choice==='week'||choice==='month')return {period:choice,start:goalDraft?.anchor||'',end:''};
+ if(choice==='custom')return {period:'custom',start:$('goals-start').value,end:$('goals-end').value};
+ const count={today:1,next7:7,next30:30,next90:90}[choice]||1;
+ return {period:'custom',start:GOALS.today,end:spendShiftDay(GOALS.today,count-1)};
+}
+function openGoalForm(preset={},duplicate=false,section=goalHome(preset.metric).section){
+ if(!GOALS)return;
+ const metrics=Object.entries(GOALS.metrics).filter(([id])=>goalHome(id).section===section),metric=preset.metric||metrics[0]?.[0]||'spend';
+ goalDraft={id:duplicate?'':preset.id||'',option:'',wantedOption:duplicate?'custom':preset.target_option||'',autoTitle:preset.id?'':(preset.title||''),saved:preset.id?{comparison:preset.comparison,target:preset.target,target_high:preset.target_high}:null,anchor:!duplicate&&preset.id&&preset.period!=='custom'?preset.start:'',returnMode:goalsListModes[section]||'current',section};
+ $('goals-metric').disabled=metrics.length<2;
+ $('goals-metric').innerHTML=metrics.map(([id,m])=>`<option value="${esc(id)}">${esc(m.label)}</option>`).join('');
+ $('goals-metric').value=metric;
+ $('goals-metric-options').innerHTML=metrics.map(([id,m])=>`<button class=goalOption type=button data-goal-metric="${esc(id)}" title="${esc(GOAL_METRIC_HELP[id]||'')}">${esc(m.label)}</button>`).join('');
+ fillGoalScopes(metric,preset.scope);
+ $('goals-period').value=preset.period||'month';
+ $('goals-repeat').checked=!!preset.repeat;
+ const today=GOALS.today,length=duplicate&&preset.period==='custom'?Math.round((Date.parse(preset.end+'T12:00:00Z')-Date.parse(preset.start+'T12:00:00Z'))/864e5):29;
+ $('goals-start').value=duplicate?today:preset.start||today;$('goals-end').value=duplicate?spendShiftDay(today,length):preset.end||spendShiftDay(today,29);
+ $('goals-title').value=preset.title||'';
+ $('goals-comparison').value='';$('goals-target').value='';$('goals-target-high').value='';
+ $('goals-form-heading').textContent=duplicate?'Duplicate goal':preset.id?'Edit goal':'New goal';
+ goalFormError('');
+ if(!$('goals-dialog').open)$('goals-dialog').showModal();
+ updateGoalFormFields();
+ refreshGoalPreview();
+ $('goals-form-heading').focus({preventScroll:true});
+}
+function clearAutoTitle(){if(goalDraft?.autoTitle&&$('goals-title').value===goalDraft.autoTitle){$('goals-title').value='';goalDraft.autoTitle='';}}
+function updateGoalFormFields(){
+ const metric=$('goals-metric').value,{period}=goalPeriodFields(),locked=$('goals-metric').disabled;
+ $('goals-metric-options').querySelectorAll('[data-goal-metric]').forEach(button=>{button.setAttribute('aria-pressed',String(button.dataset.goalMetric===metric));button.disabled=locked&&button.dataset.goalMetric!==metric;});
+ $('goals-metric').title=`${GOAL_METRIC_HELP[metric]||''}${metric==='cost_per_1k_lines'?` ${GOAL_PUSHED_SCOPE}`:''}`;
+ $('goals-dates').hidden=$('goals-period').value!=='custom';
+ $('goals-repeat-field').hidden=period==='custom';
+ $('goals-repeat-unit').textContent=period==='week'?'weekly':'monthly';
+ $('goals-target').max=goalUnit(metric)==='percent'?'100':goalUnit(metric)==='tokens'?String(Number.MAX_SAFE_INTEGER):'';
+ $('goals-target').step=goalUnit(metric)==='tokens'?'1':'any';
+ renderGoalPreview();
+}
+function goalPreviewScope(metric){
+ if(metric==='cost_per_1k_lines')return 'All projects';
+ if(goalIsWork(metric))return `${$('goals-work-type').selectedOptions[0]?.textContent||'All kinds of work'}${goalDraft?.modelKeys?.length?` · ${$('goals-model-summary').textContent}`:''}`;
+ const app=$('goals-app'),appLabel=app.value?app.selectedOptions[0]?.textContent||'':'All apps';
+ return goalDraft?.modelKeys?.length?`${app.value?`${appLabel} · `:''}${$('goals-model-summary').textContent}`:appLabel;
+}
+function goalDraftTarget(){
+ if(goalDraft?.option==='custom'){
+  const comparison=$('goals-comparison').value,raw=$('goals-target').value,target=Number(raw),high=Number($('goals-target-high').value);
+  if(comparison==='between')return raw!==''&&$('goals-target-high').value!==''&&Number.isFinite(target)&&Number.isFinite(high)?{comparison,target,target_high:high,label:'Custom'}:null;
+  return comparison&&raw!==''&&Number.isFinite(target)?{comparison,target,label:'Custom'}:null;
+ }
+ return (goalDraft?.options||[]).find(o=>o.id===goalDraft.option)||null;
+}
+function renderGoalPreview(){
+ if(!goalDraft)return;
+ const metric=$('goals-metric').value,p=goalDraft.preview||{loading:true},b=p.baseline||{},t=goalDraftTarget(),{period}=goalPeriodFields(),{kind,key}=goalSelectedScope();
+ const now=p.ok?b.value:null,hasNow=now!==null&&now!==undefined;
+ const scope=goalPreviewScope(metric),auto=`${goalLabel(metric)} for ${scope}`,title=$('goals-title').value.trim()||auto;
+ $('goals-title').placeholder=auto;
+ const repeat=period!=='custom'&&$('goals-repeat').checked;
+ const meta=[title!==auto?scope:'',p.start&&p.end?goalDateRange({start:p.start,end:p.end}):'',repeat?`Repeats ${period==='week'?'weekly':'monthly'}`:''].filter(Boolean).join(' · ');
+ const cumulative=GOALS.metrics?.[metric]?.cumulative;
+ const nowNote=p.loading?'Checking…':!p.ok?(p.error||'Unavailable'):hasNow?[`${b.label||'Previous period'}${cumulative?(b.source==='so_far'?', projected':', scaled'):''}`,b.estimated?'estimated':'',b.complete===false?'partial':''].filter(Boolean).join(' · '):'No data yet';
+ const aim=t?(t.comparison==='between'?(t.target+t.target_high)/2:t.target):null,change=hasNow&&t&&now>0?(aim-now)/now*100:null;
+ const readout=(label,value,note,extra='')=>`<div class="metric goalPreviewReadout"${extra}><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
+ const help=$('goals-metric').title,lead=(GOAL_METRIC_HELP[metric]||'').split(/(?<=\.)\s/)[0];
+ const allocations=GOALS?.budget_allocations||{},allocation=metric!=='spend'||period!=='month'?0:kind==='all'?Object.values(allocations).reduce((a,v)=>a+v,0):kind==='agent'?Number(allocations[key]||0):0;
+ const notes=[];
+ if(allocation>0)notes.push(`Your ${money(allocation)} monthly budget keeps its own alerts`);
+ if(metric==='cost_per_1k_lines'&&p.ok){const coverage=goalCoverageText(b.counted_share);notes.push(`Across ${goalRepoText(b.project_count||0,b.projects)}${coverage?` · covers ${coverage}`:''}`);if(!b.project_count||b.counted_share!==null&&b.counted_share!==undefined&&b.counted_share<50)notes.push('Low coverage: check Repository evidence after saving');}
+ if(p.ok&&!hasNow)notes.push('No current value, so choose Custom to set a target');
+ if(metric==='agent_per_human'){// Same rule as the server: the newest pushback goal, not ended, with the same scope, whose dates overlap.
+const models=JSON.stringify(goalSelectedScope().keys||[]),ceiling=(GOALS?.goals||[]).filter(g=>g.metric==='work_pushback'&&!g.ended_at&&g.scope?.key===key&&JSON.stringify(g.scope?.keys||[])===models&&(!p.start||g.series_start<=p.end&&(g.repeat||g.end>=p.start))).sort((a,b)=>String(b.created_at).localeCompare(String(a.created_at)))[0];notes.push(ceiling?`Counts while pushback stays ${goalTargetText(ceiling,'work_pushback')} (its pushback goal)`:'Counts only with a pushback goal for the same kind of work and models: add one too');}
+ $('goals-preview').innerHTML=`<span class=goalPreviewKicker>Preview</span><div><h4>${esc(title)}</h4>${meta?`<p class=goalMeta>${esc(meta)}</p>`:''}</div>`
+  +`<div class=goalPreviewLedger>${readout('Now',hasNow?goalValue(now,metric):'--',nowNote,!hasNow&&b.reason?` title="${esc(b.reason)}"`:'')}${readout('Target',t?goalTargetText(t,metric).replace(/ : 1$/,''):'--',t?t.label:'Choose below')}${readout('Change',change===null?'--':`${change>0?'+':change<0?'−':''}${Math.abs(change).toFixed(0)}%`,'vs now')}</div>`
+  +(hasNow&&t?readoutScaleHtml({value:now,typical:aim,label:`Now ${goalValue(now,metric)}, target ${goalTargetText(t,metric)}`,toned:false}):'')
+  +(lead?`<span class=readoutCaption title="${esc(help)}">${esc(lead)}</span>`:'')
+  +notes.map(n=>`<span class="goalsHelp goalPreviewNote">${esc(n)}</span>`).join('');
+}
+async function refreshGoalPreview(){
+ const request=++goalPreviewRequest,metric=$('goals-metric').value,{kind,key,keys}=goalSelectedScope(),{period,start,end}=goalPeriodFields();
+ const params=new URLSearchParams({preview:'1',metric,scope_kind:kind,scope_key:key||'',period});
+ if(keys?.length)params.set('scope_keys',JSON.stringify(keys));
+ goalDraft.start='';goalDraft.end='';$('goals-save').disabled=true;
+ if(period==='custom'){params.set('start',start);params.set('end',end);}
+ else if(goalDraft.anchor)params.set('start',goalDraft.anchor);
+ goalDraft.preview={loading:true};renderGoalPreview();
+ let data;
+ try{data=await (await fetch(`/goals?${params}`,{cache:'no-store'})).json();}catch{data={ok:false,error:'The previous period is unavailable.'};}
+ if(request!==goalPreviewRequest||!goalDraft)return;
+ goalDraft.options=data.ok?data.options:[];
+ goalDraft.start=data.start||'';goalDraft.end=data.end||'';
+ $('goals-save').disabled=false;
+ const b=data.baseline||{};
+ goalDraft.current=data.ok?b.value:null;
+ goalDraft.preview=data;
+ if(goalDraft.wantedOption){
+  const wanted=goalDraft.options.find(o=>o.id===goalDraft.wantedOption),saved=goalDraft.saved;
+  // Editing keeps the saved number; an option is reselected only if it still produces that number.
+  if(wanted&&(!saved||wanted.target===saved.target&&wanted.comparison===saved.comparison&&wanted.target_high===saved.target_high))goalDraft.option=wanted.id;
+  else if(saved){goalDraft.option='custom';$('goals-comparison').value=saved.comparison;$('goals-target').value=saved.target;$('goals-target-high').value=saved.target_high??'';}
+  goalDraft.wantedOption='';
+ }
+ if(goalDraft.option&&goalDraft.option!=='custom'&&!goalDraft.options.some(o=>o.id===goalDraft.option))goalDraft.option='';
+ renderGoalOptions();
+}
+function renderGoalOptions(focus=false){
+ const metric=$('goals-metric').value,direction=GOALS.metrics?.[metric]?.direction||'';
+ const chip=(id,label,detail)=>`<button class=goalOption type=button aria-pressed=${goalDraft.option===id?'true':'false'} data-goal-option="${esc(id)}">${esc(label)}<small>${esc(detail)}</small></button>`;
+ $('goals-options').innerHTML=goalDraft.options.map(o=>chip(o.id,o.label,goalTargetText(o,metric))).join('')+chip('custom','Custom',direction==='between'?'Your own range':'Your own number');
+ $('goals-custom').hidden=goalDraft.option!=='custom';
+ // Metrics with only one sensible direction fix Custom's direction too.
+ if(!direction&&$('goals-comparison').disabled)$('goals-comparison').value='';
+ $('goals-comparison').disabled=!!direction;
+ if(direction)$('goals-comparison').value=direction;
+ $('goals-target-high').hidden=direction!=='between';
+ $('goals-target').setAttribute('aria-label',direction==='between'?'Lower end of the range':'Target value');
+ updateGoalTargetNote();
+ $('goals-comparison').title=direction==='between'?`Keep ${goalLabel(metric)} inside a range`:direction?`${direction==='at_most'?'Lower':'Higher'} is better for ${goalLabel(metric)}`:'';
+ if(focus)$('goals-options').querySelector(`[data-goal-option="${goalDraft.option}"]`)?.focus();
+ renderGoalPreview();
+}
+function chooseGoalOption(id,focus=false){
+ if(!goalDraft)return;
+ if(id!==goalDraft.option)clearAutoTitle();
+ goalDraft.option=id;goalFormError('');renderGoalOptions(focus);
+}
+function updateGoalTargetNote(){
+ const note=$('goals-target-note'),raw=$('goals-target').value,value=Number(raw);
+ note.hidden=goalUnit($('goals-metric').value)!=='tokens'||goalDraft?.option!=='custom';
+ note.textContent=raw!==''&&Number.isSafeInteger(value)&&value>=0?`= ${compactNumber(value)} tokens`:'Whole tokens, e.g. 1000000000 for 1B';
+}
+function goalFormError(text){$('goals-form-error').textContent=text;$('goals-form-error').hidden=!text;}
+async function postGoalAction(payload){
+ const token=agentActionToken();
+ if(!token)return {ok:false,error:'Token Meter is still loading. Try again in a moment.'};
+ try{
+  const response=await fetch('/goals',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify(payload)});
+  return await response.json();
+ }catch{return {ok:false,error:'Token Meter could not save goals.'};}
+}
+function acceptGoalResult(result){GOALS=result;goalsLoadedAt=Date.now();renderGoals();}
+async function saveGoalForm(){
+ const metric=$('goals-metric').value,scope=goalSelectedScope(),option=goalDraft.option,{period}=goalPeriodFields();
+ let comparison,target,targetHigh;
+ if(!option)return goalFormError('Choose a target.');
+ if(option==='custom'){
+  comparison=$('goals-comparison').value;target=Number($('goals-target').value);
+  if(!comparison)return goalFormError('Choose At most or At least.');
+  if(comparison==='between'){targetHigh=Number($('goals-target-high').value);if($('goals-target').value===''||$('goals-target-high').value===''||!(target>0)||!(targetHigh>target))return goalFormError('Enter a range whose upper end is above its lower end, both above zero.');}
+  if($('goals-target').value===''||!Number.isFinite(target)||target<0||(goalUnit(metric)==='percent'&&target>100))return goalFormError('Enter a valid target.');
+  if(goalUnit(metric)==='tokens'&&!Number.isSafeInteger(target))return goalFormError('Enter a whole-token count within the supported range.');
+ }else{
+  const chosen=goalDraft.options.find(o=>o.id===option);
+  if(!chosen)return goalFormError('Choose a target.');
+  comparison=chosen.comparison;target=chosen.target;targetHigh=chosen.target_high;
+ }
+ if(!goalDraft.start)return goalFormError('Choose a valid period.');
+ $('goals-save').disabled=true;
+ const edited=!!goalDraft.id,returnMode=goalDraft.returnMode,before=new Set((GOALS?.goals||[]).map(g=>g.id));
+ const result=await postGoalAction({operation:'save',id:goalDraft.id||undefined,goal:{metric,scope,comparison,target,...(comparison==='between'?{target_high:targetHigh}:{}),target_option:option,period,start:goalDraft.start,end:goalDraft.end,repeat:period!=='custom'&&$('goals-repeat').checked,title:$('goals-title').value.trim()||null}});
+ $('goals-save').disabled=false;
+ if(!result.ok)return goalFormError(result.error||'Token Meter could not save this goal.');
+ const id=edited?goalDraft.id:result.goals.find(g=>!before.has(g.id))?.id||'',saved=result.goals.find(g=>g.id===id);
+ const home=goalHome(saved?.metric);
+ goalsListModes[home.section]=saved?(goalIsCurrent(saved)?'current':'previous'):edited?returnMode:'current';
+ goalDraft=null;$('goals-dialog').close();goalNotice('Goal saved.');acceptGoalResult(result);
+ if(edited&&location.hash===`#efficiency-goals/${id}`){loadGoalDetail(id);return;}
+ if(location.hash!==`#${home.route}`)setHashRoute(home.route);
+ loadGoals().then(()=>requestAnimationFrame(()=>requestAnimationFrame(()=>revealSavedGoal(id,home.section))));
+}
+function revealSavedGoal(id,section){
+ const box=$(section),link=[...box.querySelectorAll('.goalTitleLink')].find(a=>a.getAttribute('href')===`#efficiency-goals/${id}`),card=link?.closest('.goalCard');
+ if(!card)return box.scrollIntoView({block:'start'});
+ card.scrollIntoView({block:'center'});link.focus({preventScroll:true});
+ card.classList.add('is-saved');setTimeout(()=>card.classList.remove('is-saved'),2400);
+}
+async function goalAction(operation,id,message){
+ const result=await postGoalAction({operation,id});
+ if(!result.ok)return goalNotice(result.error||'Token Meter could not update this goal.',true);
+ acceptGoalResult(result);goalNotice(message);
+}
+$('goals-cancel').onclick=()=>$('goals-dialog').close();
+$('goals-dialog').addEventListener('close',()=>{$('goals-model-picker').open=false;if(!goalDraft)return;goalsListModes[goalDraft.section]=goalDraft.returnMode;goalDraft=null;++goalModelRequest;++goalPreviewRequest;renderGoals();});
+$('goals-form').addEventListener('submit',event=>{event.preventDefault();saveGoalForm();});
+$('goals-metric').addEventListener('change',()=>{const app=$('goals-app').value;fillGoalScopes($('goals-metric').value,goalSelectedScope());if(!$('goals-app').disabled)$('goals-app').value=app;refreshGoalModels();clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();});
+$('goals-app').addEventListener('change',()=>{
+ const app=$('goals-app').value,before=goalDraft.modelKeys.length;
+ if(app)goalDraft.modelKeys=goalDraft.modelKeys.filter(key=>goalDraft.models.find(m=>m.key===key)?.runtime===app);
+ goalFormError(before!==goalDraft.modelKeys.length?'Selections from other apps were removed. Review the model selection before saving.':'');
+ goalDraft.models=goalDraft.models.filter(m=>!app||m.runtime===app||goalDraft.modelKeys.includes(m.key));
+ renderGoalModelPicker();clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();refreshGoalModels();
+});
+$('goals-model-picker').querySelector('summary').addEventListener('click',event=>{if(event.currentTarget.getAttribute('aria-disabled')==='true')event.preventDefault();});
+$('goals-model-picker').addEventListener('keydown',event=>{if(event.key==='Escape'){$('goals-model-picker').open=false;$('goals-model-picker').querySelector('summary').focus();}});
+$('goals-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionGoalModelPicker));
+window.addEventListener('resize',()=>{if($('goals-model-picker').open)positionGoalModelPicker();});
+document.addEventListener('pointerdown',event=>{const picker=$('goals-model-picker');if(picker.open&&!picker.contains(event.target))picker.open=false;});
+$('goals-model-options').addEventListener('change',event=>{
+ const input=event.target.closest('[data-goal-model]');if(!input||!goalDraft)return;
+ const key=input.dataset.goalModel,keys=new Set(goalDraft.modelKeys);
+ if(key==='all')keys.clear();else if(input.checked){if(keys.size>=(GOALS.max_selected_models||32)){input.checked=false;goalFormError(`Select at most ${GOALS.max_selected_models||32} models.`);return;}keys.add(key);}else keys.delete(key);
+ goalDraft.modelKeys=[...keys].sort();
+ const all=$('goals-model-options').querySelector('[data-goal-model="all"]');all.checked=keys.size===0;
+ $('goals-model-options').querySelectorAll('[data-goal-model]').forEach(option=>{if(option!==all)option.checked=keys.has(option.dataset.goalModel);});
+ $('goals-model-summary').textContent=keys.size===0?'All models':keys.size===1?(goalDraft.models.find(m=>keys.has(m.key))?.label||'Model unavailable'):`${keys.size} models selected`;
+ goalFormError('');clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();
+});
+$('goals-model-search').addEventListener('input',()=>{clearTimeout(goalModelTimer);++goalModelRequest;goalModelTimer=setTimeout(refreshGoalModels,200);});
+$('goals-target').addEventListener('input',()=>{updateGoalTargetNote();renderGoalPreview();});
+$('goals-target-high').addEventListener('input',renderGoalPreview);
+$('goals-work-type').addEventListener('change',()=>{clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();});
+['goals-comparison','goals-repeat'].forEach(id=>$(id).addEventListener('change',renderGoalPreview));
+$('goals-title').addEventListener('input',renderGoalPreview);
+['goals-period','goals-start','goals-end'].forEach(id=>$(id).addEventListener('change',()=>{if(id==='goals-period')goalDraft.anchor='';updateGoalFormFields();refreshGoalPreview();}));
+$('goals-metric-options').addEventListener('click',event=>{const button=event.target.closest('[data-goal-metric]');if(!button||button.dataset.goalMetric===$('goals-metric').value)return;$('goals-metric').value=button.dataset.goalMetric;$('goals-metric').dispatchEvent(new Event('change'));});
+$('goals-options').addEventListener('click',event=>{const button=event.target.closest('[data-goal-option]');if(!button)return;chooseGoalOption(button.dataset.goalOption,true);if(button.dataset.goalOption==='custom')($('goals-comparison').disabled?$('goals-target'):$('goals-comparison')).focus();});
+function handleGoalClick(event){
+ const toggle=event.target.closest('[data-goals-toggle]');
+ if(toggle){const root=event.currentTarget,section=root.id;goalsListModes[section]=goalsListModes[section]==='previous'?'current':'previous';return loadGoals().then(()=>root.querySelector('[data-goals-toggle]')?.focus());}
+ const edit=event.target.closest('[data-goal-edit]'),duplicate=event.target.closest('[data-goal-duplicate]'),end=event.target.closest('[data-goal-end]'),remove=event.target.closest('[data-goal-delete]');
+ if(edit){const g=GOALS?.goals?.find(goal=>goal.id===edit.dataset.goalEdit);if(g)openGoalForm(g);}
+ else if(duplicate){const g=GOALS?.goals?.find(goal=>goal.id===duplicate.dataset.goalDuplicate);if(g)openGoalForm(g,true);}
+ else if(end)goalAction('end',end.dataset.goalEnd,'Goal ended.');
+ else if(remove)goalAction('delete',remove.dataset.goalDelete,'Goal deleted.');
+}
+['efficiency-goals','spend-goals','git-goals','work-goals'].forEach(id=>$(id).addEventListener('click',handleGoalClick));
+function openGoalFromLink(event){
+ const link=event.target.closest('[data-goal-new]');if(!link)return;
+ event.preventDefault();
+ loadGoals().then(()=>{if(GOALS)openGoalForm({},false,link.dataset.goalNew);});
+}
+document.addEventListener('click',openGoalFromLink);
+function closeGoalMenus(event){document.querySelectorAll('.goalMenu[open]').forEach(menu=>{if(!menu.contains(event.target)||event.target.closest('[data-goal-duplicate],[data-goal-end],[data-goal-delete]'))menu.open=false;});}
+document.addEventListener('click',closeGoalMenus);
+document.addEventListener('keydown',event=>{if(event.key!=='Escape')return;const menu=event.target.closest?.('.goalMenu[open]');if(menu){menu.open=false;menu.querySelector('summary').focus();}});
+let goalDetailRequest=0,goalDetailOrigin='',goalDetailData=null;
+function releaseGoalChart(){const svg=$('goals-trend-chart');if(svg)chartResizeObserver.unobserve(svg);goalDetailData=null;}
+function showGoalDetail(open){
+ const wasOpen=!$('goal-detail').hidden;
+ if(!open){++goalDetailRequest;releaseGoalChart();}
+ $('view-efficiency').classList.toggle('goalDetailOpen',open);
+ $('goals-overview').hidden=open;$('goal-detail').hidden=!open;
+ if(!open&&wasOpen)requestAnimationFrame(()=>{const link=[...$('goals-overview').querySelectorAll('.goalTitleLink')].find(a=>a.getAttribute('href')===`#efficiency-goals/${goalDetailOrigin}`);(link||$('goals-heading')).focus();});
+}
+function goalBackLink(g){const home=goalHome(g?.metric);return `<a class=tbtn href="#${home.route}">← Back to ${esc(home.back)}</a>`;}
+async function loadGoalDetail(id){
+ goalDetailOrigin=id;
+ releaseGoalChart();
+ showGoalDetail(true);
+ const request=++goalDetailRequest;
+ $('goal-detail').innerHTML=`${goalBackLink()}<p class="emptyState goalsEmpty">Loading goal detail…</p>`;
+ let data;
+ try{if(!GOALS)await loadGoals();data=await (await fetch(`/goals?goal=${encodeURIComponent(id)}`,{cache:'no-store'})).json();}
+ catch{data={ok:false,error:'Goal detail is unavailable right now.'};}
+ if(request!==goalDetailRequest)return;
+ if(!data.ok||!GOALS){$('goal-detail').innerHTML=`${goalBackLink()}<p class="emptyState goalsEmpty">${esc(data.error||'Goal detail is unavailable right now.')}</p>`;return;}
+ $('goal-detail').innerHTML=renderGoalDetail(data);
+ goalDetailData=data;drawGoalTrend();const chart=$('goals-trend-chart');if(chart)chartResizeObserver.observe(chart);
+ window.scrollTo(0,0);$('goal-detail-heading')?.focus({preventScroll:true});
+}
+function goalTrendChart(g,trend){
+ const days=(trend||[]).map(p=>p.day);
+ if(!days.length)return '<p class="emptyState goalsEmpty">No daily evidence yet.</p>';
+ return `<div class=efficiencyChartWrap><svg class="goalTrend efficiencyChart" id=goals-trend-chart preserveAspectRatio=none role=img tabindex=0 aria-label="${esc(goalLabel(g.metric))} to date. Use arrow keys to inspect values." aria-describedby=goals-trend-status></svg><div class="efficiencyChartTip chartTip goalTrendTip" id=goals-trend-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=goals-trend-status aria-live=polite></span></div>`
+  +`<div class=goalTrendAxis><span>${esc(days[0])}</span><span>${g.comparison==='between'?`Dashed lines: range ${esc(goalTargetText(g,g.metric))}`:`Dashed line: target ${esc(goalValue(g.target,g.metric))}`}</span><span>${esc(days.at(-1))}</span></div>`;
+}
+function drawGoalTrend(){
+ const svg=$('goals-trend-chart');if(!svg||!goalDetailData)return;
+ const g=goalDetailData.goal,samples=goalDetailData.trend||[],tip=$('goals-trend-tip'),status=$('goals-trend-status'),width=Math.max(1,Math.round(svg.clientWidth)),height=Math.max(1,Math.round(svg.clientHeight)),target=Number(g.target),targets=g.comparison==='between'?[target,Number(g.target_high)]:[target],known=p=>p.value!==null&&Number.isFinite(p.value),values=samples.filter(known).map(p=>p.value),low=Math.min(0,...targets,...values),high=Math.max(...targets,...values,low+1),span=high-low,pad=10,plot=Math.max(1,width-pad*2),x=index=>pad+(samples.length===1?plot/2:index*plot/(samples.length-1)),y=value=>height-pad-(value-low)/span*Math.max(1,height-pad*2);
+ svg.setAttribute('viewBox',`0 0 ${width} ${height}`);tip.hidden=true;status.textContent='';
+ let html=targets.map(t=>`<line class=goalSparkTarget x1="${pad}" x2="${width-pad}" y1="${y(t)}" y2="${y(t)}"/>`).join(''),segment=[];
+ const finish=()=>{if(segment.length===1)html+=`<circle class=efficiencyChartDot cx="${segment[0][0]}" cy="${segment[0][1]}" r=3.5/>`;else if(segment.length)html+=`<polyline class=goalSparkLine points="${segment.map(p=>p.join(',')).join(' ')}"/>`;segment=[];};
+ samples.forEach((p,i)=>{if(known(p))segment.push([x(i).toFixed(1),y(p.value).toFixed(1)]);else finish();});finish();
+ if(!values.length)html+=`<text class=efficiencyChartEmpty x=10 y="${height/2}">No daily evidence</text>`;
+ svg.innerHTML=html+`<g class=efficiencyChartInspect visibility=hidden><line class=efficiencyChartInspectLine y1="${pad}" y2="${height-pad}"/><circle class=efficiencyChartInspectDot r=4/></g>`;
+ const inspect=svg.querySelector('.efficiencyChartInspect'),line=inspect.querySelector('line'),dot=inspect.querySelector('circle');let active=samples.length-1;
+ const hide=()=>{inspect.setAttribute('visibility','hidden');tip.hidden=true;status.textContent='';};
+ const show=(index,announce=false)=>{const p=samples[index];if(!p)return;active=index;const px=x(index),value=known(p)?goalValue(p.value,g.metric):'No data',text=`${p.day} · ${value} to date · target ${goalValue(target,g.metric)}`;inspect.setAttribute('visibility','visible');line.setAttribute('x1',px);line.setAttribute('x2',px);dot.setAttribute('visibility',known(p)?'visible':'hidden');if(known(p)){dot.setAttribute('cx',px);dot.setAttribute('cy',y(p.value));}tip.textContent=text;tip.hidden=false;const edge=Math.min(width/2,tip.offsetWidth/2+8);tip.style.left=`${Math.max(edge,Math.min(width-edge,px))}px`;if(announce)status.textContent=text;};
+ svg.onpointermove=event=>{const rect=svg.getBoundingClientRect(),local=(event.clientX-rect.left)*width/Math.max(1,rect.width);show(Math.max(0,Math.min(samples.length-1,Math.round((local-pad)/plot*Math.max(0,samples.length-1)))));};
+ svg.onpointerleave=hide;svg.onblur=hide;svg.onfocus=()=>show(samples.length-1,true);
+ svg.onkeydown=event=>{if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;event.preventDefault();show(efficiencyChartKeyIndex(event.key,active,samples.length),true);};
+ if(document.activeElement===svg)show(active,true);
+}
+function goalDriverRows(rows,valueText){
+ return rows.map(r=>`<div class=goalDriverRow><span title="${esc(r.label)}">${esc(r.label)}</span><div class=goalDriverBar><i style="width:${Math.max(0,Math.min(100,Number(r.share)||0)).toFixed(1)}%"></i></div><b>${esc(valueText(r))}</b></div>`).join('');
+}
+function goalDriversCard(g,drivers){
+ const metric=g.metric,parts=[];
+ if(metric==='cost_per_1k_lines'){
+  const repos=drivers.by_repository||[],top=Math.max(0,...repos.map(r=>r.cost));
+  parts.push(repos.length?`<h5>By repository</h5>${goalDriverRows(repos.map(r=>({...r,share:top?r.cost/top*100:0})),r=>`${goalValue(r.value,metric)} · ${f(r.lines)} lines · ${money(r.cost)}`)}`:'<p class=goalDriverNote>No repository had both measured Git coverage and agent spend in this period.</p>');
+  const coverage=drivers.repository_coverage;
+  if(coverage){
+   parts.push(`<p class=goalDriverNote>${f(coverage.included)} of ${f(coverage.discovered)} discovered repositories included${g.measurement?.counted_share!==null&&g.measurement?.counted_share!==undefined?` · ${g.measurement.counted_share.toFixed(0)}% of agent spend covered`:''}. All projects includes every eligible discovered repository, including those outside this preview.</p>`);
+   if(coverage.omitted)parts.push(`<p class=goalDriverNote>Showing the top ${f(repos.length)} by spend. ${f(coverage.omitted)} more comparable repositories contribute to the total.</p>`);
+   parts.push(`<details class=goalsPrevious><summary>Repository evidence</summary><p class=goalDriverNote>${esc(`${coverage.start} to ${coverage.end}. ${coverage.available?(coverage.stale?'Git history is stale.':'Git evidence available.'):'Git history unavailable.'} Repositories require spend evidence and measured Git coverage; membership does not depend on meeting the target.`)}</p>`
+    +((coverage.rows||[]).length?`<div class=deliveryTableWrap><table class=tbl><thead><tr><th>Repository</th><th>Evidence</th><th>Spend</th><th>Pushed lines</th></tr></thead><tbody>${coverage.rows.map(r=>{const evidence=deliveryProjectEvidence(r);return `<tr><td>${esc(r.label)}</td><td>${esc(evidence.label)}${r.availability.partial?' · partial':''}</td><td>${r.availability.cost?money(r.cost):'--'}</td><td>${r.availability.code_pushed?f(r.lines):'--'}</td></tr>`;}).join('')}</tbody></table></div>`:'<p class=emptyState>No published repository evidence yet.</p>')
+    +((coverage.limits||[]).length?`<p class=goalDriverNote>${esc(coverage.limits.map(code=>({repository_limit:'Repository discovery limit reached.',scan_limited:'Git history scan was limited.',no_push_history:'Some discovered history has no recorded push evidence.'})[code]).join(' '))}</p>`:'')
+    +'<p class=goalDriverNote>Zero lines means measured Git history with no changed lines in this period. “--” means unavailable. Discovery follows local agent activity, up to '+f(coverage.repository_limit)+' repositories; it does not scan every repository on disk. Sessions outside repository folders are not attributed. The Git page has its own selected history range.</p><a class=tbtn href="#git">Open Git</a></details>');
+  }
+ }else if(metric==='tokens'){
+  const tokens=drivers.token_drivers||{};
+  if((tokens.by_model||[]).length)parts.push(`<h5>By model, share of tokens</h5>${goalDriverRows(tokens.by_model,r=>`${goalValue(r.tokens,metric)} · ${r.share.toFixed(0)}%`)}`);
+  if((tokens.by_agent||[]).length>1)parts.push(`<h5>By app</h5>${goalDriverRows(tokens.by_agent,r=>`${goalValue(r.tokens,metric)} · ${r.share.toFixed(0)}%`)}`);
+  if(tokens.omitted)parts.push(`<p class=goalDriverNote>${f(tokens.omitted)} more models contribute to the total.</p>`);
+ }else{
+  const ratio=['output_per_dollar','context_load','reasoning_ratio'].includes(metric);
+  if((drivers.by_model||[]).length)parts.push(`<h5>By model, share of spend</h5>${goalDriverRows(drivers.by_model,r=>`${money(r.cost)} · ${r.share.toFixed(0)}%${ratio&&r.value!==null?` · ${goalValue(r.value,metric)}`:''}`)}`);
+  if((drivers.by_effort||[]).length)parts.push(`<h5>By reasoning effort</h5>${goalDriverRows(drivers.by_effort.map(r=>({...r,label:r.effort.charAt(0).toUpperCase()+r.effort.slice(1)})),r=>`${money(r.cost)} · ${r.share.toFixed(0)}%`)}`);
+  if((drivers.by_agent||[]).length>1)parts.push(`<h5>By app</h5>${goalDriverRows(drivers.by_agent,r=>`${money(r.cost)} · ${r.share.toFixed(0)}%`)}`);
+  if(drivers.cache_hit!==null&&drivers.cache_hit!==undefined)parts.push(`<p class=goalDriverNote>${esc(`${drivers.cache_hit.toFixed(0)}% of processed input came from cache.`)}</p>`);
+ }
+ return `<section class="card goalDetailCard"><h4>What is driving it</h4>${parts.join('')||'<p class=goalDriverNote>No breakdown is available for this period yet.</p>'}</section>`;
+}
+function goalCoachingCard(tips){
+ const hasEstimate=(tips||[]).some(t=>t.estimate);
+ return `<section class="card goalDetailCard"><h4>Coaching</h4>${(tips||[]).map(t=>`<article class=goalCoachTip><h5>${esc(t.title)}</h5><p>${esc(t.evidence)}</p><p><strong>Try:</strong> ${esc(t.action)}</p>${t.estimate?`<p class=goalCoachSaving>Could save up to ${esc(money(t.estimate))}<small>${esc(t.estimate_basis||'')}</small></p>`:''}</article>`).join('')}${hasEstimate?'<p class=goalDriverNote>Estimates are upper bounds from your own history. They can overlap, so do not add them together.</p>':''}</section>`;
+}
+function goalContributorsCard(g,contributors){
+ const items=contributors?.items||[],basis=contributors?.basis||'cost';
+ if(!items.length)return '';
+ if(g.metric==='cost_per_1k_lines')return `<section class="card goalDetailCard"><h4>Biggest contributors</h4><p class=goalDriverNote>Repositories ranked by covered spend, ${esc(contributors.start)} to ${esc(contributors.end)}. ${f(contributors.repositories)} repositories in total; showing ${f(items.length)}. Lines pushed counts additions plus deletions. Rates require at least 50 lines and positive spend.</p><div class=deliveryTableWrap><table class=tbl><thead><tr><th>Repository</th><th>Spend</th><th>Lines pushed</th><th>Cost per 1K pushed lines</th><th>Spend share</th></tr></thead><tbody>${items.map(c=>`<tr><td>${esc(c.label)}${c.partial?' · partial':''}</td><td>${money(c.cost)}</td><td>${f(c.lines)}</td><td>${esc(goalValue(c.value,g.metric))}</td><td>${c.share===null?'--':c.share.toFixed(0)+'%'}</td></tr>`).join('')}</tbody><tfoot><tr><th>All included repositories</th><td>${money(contributors.total_cost)}</td><td>${f(contributors.total_lines)}</td><td>${esc(goalValue(g.measurement?.value,g.metric))}</td><td>${contributors.total_cost>0?'100%':'--'}</td></tr></tfoot></table></div></section>`;
+ const amount=c=>basis==='cost'?money(c.cost||0):`${compactNumber(basis==='tokens'?c.tokens:basis==='input tokens'?c.input_tokens:c.reasoning_tokens)} tokens`;
+ return `<section class="card goalDetailCard"><h4>Biggest contributors</h4><p class=goalDriverNote>${esc(`Sessions that moved this goal most this period, by ${basis}. ${contributors.sessions} sessions in total.`)}</p><table class=tbl><thead><tr><th>Session</th><th>Last day</th><th>Model</th><th>Effort</th><th>Executions</th><th>${esc(basis==='cost'?'Cost':'Tokens')}</th><th>Share</th><th></th></tr></thead><tbody>${items.map(c=>`<tr><td>${esc(c.title)}<br><small>${esc(c.agent)}</small></td><td>${esc(c.last_day)}</td><td>${esc(c.model)}</td><td>${esc(c.effort||'--')}</td><td>${f(c.executions)}</td><td>${esc(amount(c))}</td><td>${c.share.toFixed(0)}%</td><td><a href="${esc(sessionRoute(c.id))}">Open</a></td></tr>`).join('')}</tbody></table></section>`;
+}
+function renderGoalDetail(d){
+ const g=d.goal,m=g.measurement||{},metric=g.metric,option=(GOALS.metrics[metric]?.options||[]).find(o=>o.id===g.target_option);
+ const scope=metric==='cost_per_1k_lines'?`Across ${goalRepoText(m.projects||0,m.project_names)}`:g.scope_label;
+ const tiles=[
+  ['Current',goalValue(m.value,metric),GOAL_CONFIDENCE[m.confidence]||''],
+  [g.comparison==='between'?'Target range':g.comparison==='at_most'?'Target, at most':'Target, at least',g.comparison==='between'?goalTargetText(g,metric):goalValue(g.target,metric),option?.label||'Custom'],
+  m.projected!==undefined?['Projected',goalValue(m.projected,metric),'At the current pace']:null,
+  g.baseline?.value!==null&&g.baseline?.value!==undefined?[g.baseline.label||'Reference',goalValue(g.baseline.value,metric),`${g.baseline.start} to ${g.baseline.end}`]:null,
+ ].filter(Boolean);
+ const reason=[g.status_reason,g.progress?.early?'Early in the period':'',goalGuardrail(g)?`Watch: ${goalGuardrail(g)}`:'',...goalNotes(g).filter(n=>!n.startsWith('Across '))].filter(Boolean).join(' · ');
+ return `<div class=goalDetailHead>${goalBackLink(g)}<div class=goalDetailTitle><h3 id=goal-detail-heading tabindex=-1>${esc(goalTitle(g))}</h3><p class=goalMeta>${esc(scope)} · ${esc(goalLabel(metric))} · ${esc(g.start)} to ${esc(g.end)}${g.repeat?` · Repeats every ${esc(g.period)}`:''}</p></div><span class="chip goalStatus ${esc(g.status)}">${esc(GOAL_STATUS_LABELS[g.status]||g.status)}</span><button class=tbtn type=button data-goal-edit="${esc(g.id)}">Edit</button><button class=tbtn type=button data-goal-duplicate="${esc(g.id)}">Duplicate</button></div>`
+  +`<div class=goalDetailSummary>${tiles.map(([label,value,note])=>`<div class="card metric goalDetailMetric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`).join('')}</div>`
+  +(reason?`<p class=goalDetail>${esc(reason)}</p>`:'')
+  +`<section class="card goalDetailCard"><h4>${esc(goalLabel(metric))} to date</h4>${goalTrendChart(g,d.trend)}</section>`
+  +`<div class=goalDetailGrid>${goalDriversCard(g,d.drivers||{})}${goalCoachingCard(d.coaching)}</div>`
+  +(g.history?.length?`<section class="card goalDetailCard"><h4>Previous periods</h4>${goalHistory(g)}</section>`:'')
+  +goalContributorsCard(g,d.contributors);
+}
diff --git a/dashboard/js/live.js b/dashboard/js/live.js
new file mode 100644
index 00000000..eb4c3b85
--- /dev/null
+++ b/dashboard/js/live.js
@@ -0,0 +1,171 @@
+function selectSession(id,{updateUrl=true,replace=false,show=true,returnScope=sessionScope}={}){
+ id=String(id||'').trim();
+ if(!id)return Promise.resolve();
+ sessionReturnScope=normalizeSessionScope(returnScope);
+ if(updateUrl&&history.pushState)history[replace?'replaceState':'pushState']({sessionScope:sessionReturnScope,sessionListBack:!replace&&sessionListBackAvailable(sessionReturnScope)},'',sessionRoute(id));
+ sessionRequest++;
+ pinned=id;
+ if(show)applyHashRoute();
+ return refreshSelectedSession({show,notifyOnError:true});
+}
+function adoptXsession(holder,state){
+ if(state?.xsession_unchanged){
+  if(holder.snapshot&&state.xsession_revision===holder.revision){state.xsession=holder.snapshot;return state;}
+  holder.snapshot=null;holder.revision='';
+  return null;
+ }
+ holder.snapshot=state?.xsession||null;
+ holder.revision=holder.snapshot?String(state?.xsession_revision||''):'';
+ return state;
+}
+async function fetchLiveJson(url,holder,label){
+ for(let attempt=0;attempt<2;attempt++){
+  const response=await fetch(url+(url.includes('?')?'&':'?')+'xsession='+encodeURIComponent(holder.revision),{cache:'no-store'});
+  if(!response.ok)throw new Error(`${label} request failed (${response.status}).`);
+  const state=adoptXsession(holder,await response.json());
+  if(state)return state;
+ }
+ throw new Error(`${label} request failed.`);
+}
+async function refreshSelectedSession({show=true,notifyOnError=false}={}){
+ const id=pinned,request=sessionRequest;
+ if(!id||selectedPollId===id)return null;
+ selectedPollId=id;
+ try{
+  const state=await fetchLiveJson('/session?id='+encodeURIComponent(id)+'&live=1',LIVE_XSESSION.session,'Session');
+  if(request!==sessionRequest||pinned!==id)return null;
+  if(!state||!stateSessionId(state))throw new Error('Session was not found.');
+  CURRENT=state;
+  if(show&&currentPanel!=='sessions'&&$('view-session').classList.contains('on')){
+   applyHashRoute();
+   renderSession(state);
+  }
+  return state;
+ }catch(error){
+  if(request!==sessionRequest||pinned!==id)return null;
+  if(notifyOnError){
+   pinned=null;
+   CURRENT=LATEST;
+   if(routedSessionId()===id&&history.replaceState)history.replaceState(null,'',`/#${sessionScopeRoute(sessionReturnScope)}`);
+   if(show)applyHashRoute();
+   showAppToast({title:'Session could not be opened',body:error.message||String(error),kind:'warn',sticky:true});
+  }
+  return null;
+ }finally{
+  if(selectedPollId===id)selectedPollId='';
+ }
+}
+function openCurrentSessions({replace=false}={}){
+ return openSessionScope('current',{replace});
+}
+function followLatestSession({updateUrl=true,replace=false,show=true,preservePanel=false}={}){
+ sessionRequest++; pinned=null; CURRENT=LATEST;sessionReturnScope='current';
+ if(updateUrl&&history.pushState){
+  const panel=preservePanel&&PANEL_KEYS.includes(sessionPanel)?sessionPanel:'summary';
+  history[replace?'replaceState':'pushState'](null,'',`/#${panel}`);
+ }
+ if(show){
+  applyHashRoute();
+  if(LATEST)renderSession(LATEST);
+ }
+ return LATEST;
+}
+function goToLatestSession(){followLatestSession();}
+
+let statePollBusy=false;
+const LIVE_STATE_POLL_MS=1000;
+const SELECTED_SESSION_POLL_MS=2000;
+// Deep links into Settings: a card can still be hidden (Work insights wait for the server to say they are
+// supported) or move down as cards above it fill in, so the scroll waits for it and settles once.
+function scrollToSettingsCard(id){
+ pendingSettingsScroll={id,since:Date.now(),until:Date.now()+60000,top:null,stable:0,timer:0};
+ requestAnimationFrame(trySettingsScroll);
+}
+function trySettingsScroll(){
+ const pending=pendingSettingsScroll;
+ if(!pending)return;
+ pending.timer=0;
+ if(Date.now()>pending.until||!$('view-settings').classList.contains('on')){pendingSettingsScroll=null;return;}
+ const card=$(pending.id);
+ if(!card||card.hidden||!card.getClientRects().length)return; // shown later: applyWorkSupport retries
+ const top=card.getBoundingClientRect().top;
+ if(pending.top!==null&&Math.abs(top-pending.top)<4){
+  if(++pending.stable>=2){pendingSettingsScroll=null;return;} // still for two checks in a row: settled
+ }else{
+  pending.stable=0;card.scrollIntoView({block:'start'});
+ }
+ pending.top=card.getBoundingClientRect().top;
+ pending.timer=setTimeout(trySettingsScroll,600);
+}
+// The reader takes over once they scroll or click themselves; the keypress or click that opened the link doesn't count.
+const SETTINGS_SCROLL_KEYS=['ArrowUp','ArrowDown','PageUp','PageDown','Home','End',' '];
+['wheel','touchstart','mousedown','keydown'].forEach(type=>window.addEventListener(type,event=>{
+ const pending=pendingSettingsScroll;
+ if(!pending||Date.now()-pending.since<300)return;
+ if(type==='keydown'&&!SETTINGS_SCROLL_KEYS.includes(event.key))return;
+ clearTimeout(pending.timer);pendingSettingsScroll=null;
+},{passive:true}));
+function applyWorkSupport(supported){
+ if(typeof supported!=='boolean'||supported===workSupported)return;
+ workSupported=supported;
+ $('tab-work').hidden=!supported;$('work-insights-settings').hidden=!supported;
+ if(supported&&pendingSettingsScroll&&!pendingSettingsScroll.timer)requestAnimationFrame(trySettingsScroll);
+ if(!supported&&/^#?(work|sessions-all\?work=)/.test(location.hash.replace(/^#/,'')))location.hash='sessions';
+}
+function applyLiveState(state){
+ RUNTIME_CATALOG=state?.runtime_catalog||RUNTIME_CATALOG;
+ defaultSessionBudget=Number(state?.xsession?.budgets?.default_session_budget||10);
+ adoptFreshDiscounts(state);LATEST=state;
+ applyWorkSupport(state?.work_insights_supported);
+ renderMenubarSettings(state?.menubar_settings);
+ renderCurrentSessions(LATEST);
+ const sessionSurfaceActive=$('view-session').classList.contains('on');
+ if(!pinned&&sessionSurfaceActive&&currentPanel!=='sessions')renderSession(LATEST);
+ if(sessionSurfaceActive&&currentPanel==='sessions'&&sessionScope==='all'){
+  const inventoryStale=!allSessionInventory||allSessionInventoryAt!==Number(LATEST.xsession?.generated_at||0);
+  if(inventoryStale)loadAllSessions();
+  else renderAllSessions(LATEST.xsession);
+ }
+ if(sessionSurfaceActive&&currentPanel==='sessions'&&sessionScope==='compare'&&compareIds.length&&!compareLoading&&Date.now()-compareLoadedAt>15000)loadComparison({force:true});
+ if(sessionSurfaceActive&&currentPanel==='sessions'&&sessionScope==='subagents'){
+  const inventoryStale=!allSessionInventory||allSessionInventoryAt!==Number(LATEST.xsession?.generated_at||0);
+  renderSubagentExplorer(LATEST.xsession?.agent_usage);
+  if(inventoryStale)loadAllSessions();
+ }
+ if($('view-subagents').classList.contains('on')){
+  const inventoryStale=!allSessionInventory||allSessionInventoryAt!==Number(LATEST.xsession?.generated_at||0);
+  renderSubagentExplorer(LATEST.xsession?.agent_usage);
+  if(inventoryStale)loadAllSessions();
+ }
+	 if($('view-models').classList.contains('on'))renderActiveModelStats();
+	 if($('view-daily').classList.contains('on'))renderSpendView(LATEST.xsession);
+ if($('view-capabilities').classList.contains('on'))renderCapabilities(LATEST.xsession?.capabilities);
+	 if($('view-efficiency').classList.contains('on'))renderActiveEfficiency();
+	 if(['view-daily','view-efficiency','view-git','view-work'].some(id=>$(id).classList.contains('on'))&&Date.now()-goalsLoadedAt>30000)loadGoals(true);
+	 if($('view-git').classList.contains('on')&&Date.now()-deliveryLastLoadedAt>60000)loadDelivery();
+	 if($('view-work').classList.contains('on')&&Date.now()-workLastLoadedAt>15000)loadWork();
+	 if($('view-settings').classList.contains('on'))renderSettings(LATEST.xsession);
+ if($('view-learn').classList.contains('on'))renderLearn(LATEST);
+ if($('welcome-dialog').open)renderWelcome(LATEST);
+ maybeAutoShowWelcome();
+}
+async function refreshLiveState(){
+ if(statePollBusy)return;
+ statePollBusy=true;
+ try{
+  applyLiveState(await fetchLiveJson('/state',LIVE_XSESSION.state,'State'));
+ }catch(error){
+  if($('view-capabilities').classList.contains('on')){
+   if(capabilityLastGoodAt)setCapabilityAvailability('stale');
+   else setCapabilityAvailability('unavailable');
+  }
+ }
+ finally{statePollBusy=false;}
+}
+setInterval(refreshLiveState,LIVE_STATE_POLL_MS);
+setInterval(()=>refreshSelectedSession({show:true}),SELECTED_SESSION_POLL_MS);
+setInterval(refreshSoftwareUpdateStatus,60000);
+setInterval(tickCacheRings,1000);
+document.addEventListener('visibilitychange',()=>{if(!document.hidden){refreshLiveState();refreshSelectedSession({show:true});}});
+refreshLiveState();
+refreshSoftwareUpdateStatus();
diff --git a/dashboard/js/models.js b/dashboard/js/models.js
new file mode 100644
index 00000000..37a771c3
--- /dev/null
+++ b/dashboard/js/models.js
@@ -0,0 +1,361 @@
+function filledModelDays(rows,window){
+ if(!window.days)return rows;
+ const byDay=new Map(rows.map(row=>[row.day,row]));
+ return window.days.map(day=>byDay.get(day)||{day});
+}
+function modelEffortLabel(row){
+ const effort=String(row?.reasoning_effort||'').trim().replaceAll('_',' ');
+ if(effort)return effort;
+ return Number(row?.thinking_executions||0)>0?'thinking unavailable':'unavailable';
+}
+// Claude Code and Codex leave effort empty when the app's default is in use; other apps never record it.
+function efficiencyEffortLabel(row){
+ const providers=row?.providers||[];
+ if(!String(row?.reasoning_effort||'').trim()&&providers.length&&providers.every(p=>p==='claude'||p==='codex'))return 'default';
+ return modelEffortLabel(row);
+}
+function modelRuntimeLabel(row){return `${row.model} · ${row.runtime||'unknown runtime'} · ${modelEffortLabel(row)}`;}
+function migrateModelRuntimeFilters(filters,models){
+ const ids=new Set(models.map(row=>row.id)),migrated=[];
+ (filters||[]).forEach(value=>{if(ids.has(value)){migrated.push(value);return;}const legacy=models.filter(row=>`${row.model}::${row.runtime||'unknown runtime'}`===value);if(legacy.length){migrated.push(...legacy.map(row=>row.id));return;}const candidates=models.filter(row=>row.model===value).sort((a,b)=>Number(b.output_tokens||0)-Number(a.output_tokens||0));if(candidates.length)migrated.push(candidates[0].id);});
+ return [...new Set(migrated)];
+}
+function buildModelTrend(models,window,names){
+ const byModel=models.map(model=>({id:model.id,model:modelRuntimeLabel(model),color:modelColor(model.id,names),estimated:hasLocalEstimate(model),byDay:new Map((model.daily||[]).filter(row=>modelDayInRange(row.day,window)).map(row=>[row.day,row]))}));
+ const days=window.days||[...new Set(byModel.flatMap(model=>[...model.byDay.keys()]))].sort();
+ return {days,series:byModel.map(model=>({id:model.id,model:model.model,color:model.color,estimated:model.estimated,points:days.map(day=>{const row=model.byDay.get(day)||{day};return {...row,perf:aggregateModelDays([row])};})}))};
+}
+function modelTokensPerExecution(row,key){
+ const executions=Number(row.executions||0);
+ return executions?Number(row[key]||0)/executions:0;
+}
+const MODEL_TREND_METRICS={
+ speed:{note:'observed tok/s',axis:'tok/s',format:speedFmt,value:row=>Number(row.perf.output_tps||0),available:row=>Boolean(row.perf.available)},
+ wait:{note:'median wait',axis:'median wait',format:waitFmt,value:row=>Number(row.perf.median_wait_s||0),available:row=>Number(row.perf.wait_samples||0)>0},
+ avg_input:{note:'avg input / execution',axis:'input / exec',format:compactNumber,value:row=>modelTokensPerExecution(row,'input_tokens'),available:row=>metricAvailable(row,'tokens')&&Number(row.executions||0)>0},
+ avg_output:{note:'avg output / execution',axis:'output / exec',format:compactNumber,value:row=>modelTokensPerExecution(row,'output_tokens'),available:row=>metricAvailable(row,'tokens')&&Number(row.executions||0)>0},
+};
+function modelTrendRowHasUsage(row){
+ return Number(row?.input_tokens||0)>0||Number(row?.output_tokens||0)>0||Number(row?.executions||0)>0;
+}
+function drawModelTrend(chart){
+ const svg=$('m-chart'),tip=$('m-chart-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||270)),ML=62,MR=72,MT=18,MB=38,PW=VW-ML-MR,PH=VH-MT-MB;svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ const days=chart.days||[],series=chart.series||[],metric=MODEL_TREND_METRICS[modelTrendMetric]||MODEL_TREND_METRICS.speed;
+ const hasData=series.some(model=>model.points.some(row=>Number(row.input_tokens||0)||Number(row.output_tokens||0)||Number(row.executions||0)||metric.available(row)));
+ if(!days.length||!series.length||!hasData){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="${svgTextPx(svg,VW,VH,13)}">No model history in this window</text>`;tip.style.display='none';return;}
+ const lineValue=metric.value,lineAvailable=metric.available;
+ const maxOutput=Math.max(1,...series.flatMap(model=>model.points.map(row=>Number(row.output_tokens||0)))),maxLine=Math.max(1,...series.flatMap(model=>model.points.filter(lineAvailable).map(lineValue)));
+ const step=PW/Math.max(1,days.length),groupW=Math.max(2,Math.min(30,step*.72)),barW=Math.max(.8,groupW/series.length);
+ const x=index=>ML+step*(index+.5),outY=value=>MT+PH-PH*(Number(value||0)/maxOutput),lineY=value=>MT+PH-PH*(Number(value||0)/maxLine),lineFormat=metric.format;
+ let html='';
+ for(let i=0;i<=4;i++){const y=MT+PH*i/4;html+=`<line x1="${ML}" x2="${ML+PW}" y1="${y}" y2="${y}" stroke="${CHART.grid}" stroke-width="1"/><text x="${ML-8}" y="${y+4}" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${compactNumber(maxOutput*(1-i/4))}</text><text x="${ML+PW+8}" y="${y+4}" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${lineFormat(maxLine*(1-i/4))}</text>`;}
+ days.forEach((day,index)=>series.forEach((model,modelIndex)=>{const row=model.points[index],y=outY(row.output_tokens),h=MT+PH-y,barX=x(index)-groupW/2+modelIndex*barW,paint=modelTrendPaint(model.color);html+=`<rect x="${barX}" y="${y}" width="${Math.max(.8,barW-.5)}" height="${Math.max(0,h)}" rx="2" fill="${paint.barFill}" stroke="${paint.barStroke}" stroke-opacity=".78"/>`;}));
+ series.forEach(model=>{const paint=modelTrendPaint(model.color),{segments,bridges}=chartGapRuns(model.points.flatMap((row,index)=>lineAvailable(row)?[{index,x:x(index),y:lineY(lineValue(row))}]:[]));bridges.forEach(([from,to])=>{html+=chartGapBridge(from.x,from.y,to.x,to.y,paint.line);});segments.filter(segment=>segment.length>1).forEach(segment=>{html+=`<path d="${segment.map((point,index)=>`${index?'L':'M'}${point.x.toFixed(1)},${point.y.toFixed(1)}`).join(' ')}" fill="none" stroke="${paint.line}" stroke-width="2.5" ${model.estimated?'stroke-dasharray="6 4"':''} stroke-linecap="round" stroke-linejoin="round"/>`;});model.points.forEach((row,index)=>{if(lineAvailable(row))html+=`<circle cx="${x(index)}" cy="${lineY(lineValue(row))}" r="3.8" fill="${paint.line}" stroke="${CHART.ink}" stroke-width="2"/>`;});});
+ const labelEvery=Math.max(1,Math.ceil(days.length/8));
+ days.forEach((day,index)=>{const remaining=days.length-1-index,showLabel=index===days.length-1||(index%labelEvery===0&&remaining>=Math.max(2,Math.ceil(labelEvery/2)));if(showLabel)html+=`<text x="${x(index)}" y="${VH-12}" text-anchor="middle" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(day.slice(5))}</text>`;html+=`<rect data-model-day="${esc(day)}" x="${ML+step*index}" y="${MT}" width="${step}" height="${PH}" fill="transparent" pointer-events="all"/>`;});
+ html+=`<text x="8" y="12" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">output</text><text x="${VW-8}" y="12" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(metric.axis)}</text>`;
+ svg.innerHTML=html;
+ svg.setAttribute('aria-label',`Daily model ${metric.note} and output token volume`);
+ const cancelTipHide=()=>{if(tip._hideTimer){clearTimeout(tip._hideTimer);tip._hideTimer=0;}};
+ const hideTip=()=>{cancelTipHide();tip.style.display='none';};
+ const scheduleTipHide=()=>{cancelTipHide();tip._hideTimer=setTimeout(hideTip,180);};
+ const show=(event,index)=>{
+  cancelTipHide();
+  const rect=$('m-chart').parentElement.getBoundingClientRect(),day=days[index],rows=series.map(model=>({model:model.model,color:model.color,row:model.points[index]})).filter(item=>modelTrendRowHasUsage(item.row)),dayChanged=tip.dataset.day!==day;
+  tip.innerHTML=`<div class=h>${esc(day)}</div>`+(rows.length?'':'<div class=r><span>No data</span></div>')+rows.map(item=>{
+   const outputAvailable=metricAvailable(item.row,'tokens');
+   const selectedAvailable=metric.available(item.row);
+   return `<div class=modelTipSeries><div class=modelTipName title="${esc(item.model)}"><i class=modelSwatch style="background:${item.color}"></i>${esc(item.model)}</div><div class=modelTipMetrics><span><small>output</small><b>${outputAvailable?compactNumber(item.row.output_tokens||0):'--'}</b></span><span><small>${esc(metric.note)}</small><b>${selectedAvailable?metric.format(metric.value(item.row)):'--'}</b></span></div></div>`;
+  }).join('');
+  tip.dataset.day=day;tip.style.display='block';
+  const pointerX=event.clientX-rect.left,rightX=pointerX+12,leftX=pointerX-tip.offsetWidth-12;
+  tip.style.left=(rightX+tip.offsetWidth<=rect.width-8?rightX:Math.max(8,leftX))+'px';tip.style.top=Math.max(8,event.clientY-rect.top-tip.offsetHeight-10)+'px';if(dayChanged)tip.scrollTop=0;
+ };
+ [...svg.querySelectorAll('[data-model-day]')].forEach((hit,index)=>{hit.onpointerenter=event=>show(event,index);hit.onpointermove=event=>show(event,index);hit.onpointerleave=scheduleTipHide;});
+ tip.onpointerenter=cancelTipHide;tip.onpointerleave=scheduleTipHide;tip.onfocus=cancelTipHide;tip.onblur=scheduleTipHide;
+}
+function setModelKpiHelp(labelId,detail){
+ const label=$(labelId);if(!label)return;
+ const definition=label.dataset.helpDefinition||label.dataset.tip||'';
+ if(!label.dataset.helpDefinition)label.dataset.helpDefinition=definition;
+ const copy=[definition,detail].filter(Boolean).join(' ');
+ label.dataset.tip=copy;label.setAttribute('aria-description',copy);
+}
+function renderMatchedPace(stats,selected){
+ const value=$('m-change'),note=$('m-change-note');note.className='subline modelDelta';value.title='';note.title='';
+ if(selected.length!==2){value.textContent='--';note.textContent='Select 2 models';note.title='Matched pace compares exactly two model-runtime histories.';return;}
+ if(selected.some(hasLocalEstimate)){value.textContent='--';note.textContent='Unavailable for local estimates';note.title='Cursor local input-context and visible-output estimates are excluded from matched pace.';return;}
+ const ids=new Set(selected.map(row=>row.id)),comparison=(stats?.matched_pace?.windows?.[modelRange]||[]).find(row=>ids.has(row.a_id)&&ids.has(row.b_id));
+ if(!comparison){value.textContent='--';note.textContent='No pairwise timing';note.title='The selected histories do not contain comparable completed timing samples in this window.';return;}
+ if(!comparison.available){value.textContent='--';note.textContent='Not enough matched evidence';note.title=`${comparison.reason} · ${f(comparison.a_samples)}/${f(comparison.b_samples)} timed. Token Meter withholds the verdict until there are at least 20 matched pairs covering 30% of the smaller eligible history.`;return;}
+ const byId=new Map(selected.map(row=>[row.id,row])),ratio=Number(comparison.pace_ratio||0),low=Number(comparison.ci_low||0),high=Number(comparison.ci_high||0),uncertain=low<=1&&high>=1;
+ const evidence=`${f(comparison.matched_pairs)} matched · ${pct(comparison.coverage)} coverage · 95% CI ${low.toFixed(2)}–${high.toFixed(2)}×`;
+ if(uncertain){value.textContent='≈ same';note.textContent='No clear difference';value.title=`Observed ratio ${ratio.toFixed(2)}×; confidence interval includes parity.`;note.title=`${evidence}. The 95% confidence interval crosses 1.00, so the observed histories do not provide a clear faster-runtime verdict.`;return;}
+ const fasterId=ratio>1?comparison.a_id:comparison.b_id,factor=ratio>1?ratio:1/ratio,faster=byId.get(fasterId);
+ value.textContent=`${factor.toFixed(2)}×`;note.classList.add('up');note.textContent=`${modelRuntimeLabel(faster)} faster`;note.title=`${note.textContent} · ${evidence}`;
+}
+function setModelKpiValue(id,value,qualifier){
+ const el=$(id);el.textContent=value;
+ if(qualifier.trim()){const tag=document.createElement('small');tag.className='modelValueQual';tag.textContent=qualifier.trim();el.append(tag);}
+}
+const MODEL_OTHER_COLOR=THEME.modelOther;
+const MODEL_MIX_METRICS={
+ cost:{label:'Cost',unit:'est. cost',value:day=>metricAvailable(day,'cost')?Number(day.cost||0):0,format:value=>money(value)},
+ output:{label:'Output',unit:'output tokens',value:day=>metricAvailable(day,'tokens')?Number(day.output_tokens||0):0,format:compactNumber},
+ executions:{label:'Executions',unit:'executions',value:day=>Number(day.executions||0),format:value=>f(Math.round(value))},
+};
+function modelGroupKey(row){return `${row.model}::${row.runtime||'unknown runtime'}`;}
+function modelGroupRows(selected,rangeWindow){
+ const groups=new Map();
+ selected.forEach(model=>{
+  const daily=(model.daily||[]).filter(day=>modelDayInRange(day.day,rangeWindow)),window=aggregateModelDays(daily);
+  if(!(window.input_tokens||window.output_tokens||window.executions||window.wait_samples||window.cost))return;
+  const key=modelGroupKey(model),group=groups.get(key)||{key,model:model.model,runtime:model.runtime,variants:[],daily:[]};
+  group.variants.push({...model,window});group.daily.push(...daily);groups.set(key,group);
+ });
+ return [...groups.values()].map(group=>({...group,window:aggregateModelDays(group.daily),ids:group.variants.map(row=>row.id),estimated:group.variants.some(hasLocalEstimate)}));
+}
+function modelBoardValue(row,key){
+ const data=row.window||{},costAvailable=data.availability?.cost===true;
+ if(key==='model')return `${row.model} · ${row.runtime}`;
+ if(key==='cost')return costAvailable?Number(data.cost||0):null;
+ if(key==='cost_per_exec'){
+  if(!costAvailable)return null;
+  const covered=Number(data.cost_covered_executions||0);
+  if(covered>0)return (Number(data.cost_covered_cost||0)||Number(data.cost||0))/covered;
+  return Number(data.executions||0)>0?Number(data.cost||0)/Number(data.executions):null;
+ }
+ if(key==='cache')return efficiencyMetrics(data).cache_hit_ratio;
+ if(key==='executions')return Number(data.executions||0);
+ if(key==='output')return metricAvailable(data,'tokens')?Number(data.output_tokens||0):null;
+ if(key==='speed')return data.available?Number(data.output_tps||0):null;
+ if(key==='wait')return data.wait_samples?Number(data.median_wait_s||0):null;
+ if(key==='pushback')return row.variants?modelPushbackFor(row)?.rate??null:null;
+ return null;
+}
+function sortModelBoard(rows,sort=modelSort){
+ const direction=sort.direction==='asc'?1:-1,label=row=>`${row.model} · ${row.runtime} · ${row.reasoning_effort||''}`;
+ return [...(rows||[])].sort((a,b)=>{const left=modelBoardValue(a,sort.key),right=modelBoardValue(b,sort.key);if(left===null&&right===null)return label(a).localeCompare(label(b));if(left===null)return 1;if(right===null)return -1;const compared=typeof left==='string'?left.localeCompare(right):left-right;return compared?compared*direction:label(a).localeCompare(label(b));});
+}
+function modelSpendRanking(groups){
+ const label=row=>`${row.model} · ${row.runtime}`;
+ return [...(groups||[])].sort((a,b)=>{const left=modelBoardValue(a,'cost'),right=modelBoardValue(b,'cost');if(left!==right&&(left===null||right===null))return left===null?1:-1;if(left!==null&&right!==null&&right!==left)return right-left;return (Number(modelBoardValue(b,'output'))||0)-(Number(modelBoardValue(a,'output'))||0)||label(a).localeCompare(label(b));});
+}
+function renderModelSpend(groups,ranking,top,allSelected){
+ const costed=groups.filter(group=>modelBoardValue(group,'cost')!==null),uncosted=groups.length-costed.length,total=costed.reduce((sum,group)=>sum+Number(group.window.cost||0),0),partial=costed.some(group=>metricPartial(group.window,'cost'));
+ $('m-spend-total').textContent=total>0?`≈ ${money(total)} est. · ${modelRangeLabel(modelRange)}${partial?' · partial':''}`:'Cost unavailable';
+ const topKeys=new Set(top.map(group=>group.key)),topColor=modelRankedColors(top),segments=top.filter(group=>Number(modelBoardValue(group,'cost'))>0).map((group,index)=>({label:group.model,runtime:group.runtime,cost:Number(group.window.cost||0),color:topColor.get(group.key),ids:group.ids}));
+ const rest=ranking.filter(group=>!topKeys.has(group.key)&&Number(modelBoardValue(group,'cost'))>0),restCost=rest.reduce((sum,group)=>sum+Number(group.window.cost||0),0);
+ if(restCost>0)segments.push({label:`Other (${f(rest.length)})`,runtime:'',cost:restCost,color:MODEL_OTHER_COLOR,ids:[]});
+ const share=segment=>total>0?segment.cost/total:0,name=segment=>segment.runtime?`${segment.label} · ${segment.runtime}`:segment.label;
+ setLogHtml($('m-spend-bar'),total>0?segments.map(segment=>{const portion=share(segment),title=`${name(segment)} · ≈ ${money(segment.cost)} est. · ${pct(portion)}`,inner=portion>=.1?`<span>${esc(segment.label)}</span><b>${pct(portion)}</b>`:'';return segment.ids.length?`<button class=modelSpendSeg type=button style="flex:${portion} 1 0;background:${segment.color}" data-model-ids="${esc(segment.ids.join('\n'))}" title="${esc(title)} · click to focus" aria-label="${esc(title)}. Focus this model.">${inner}</button>`:`<div class=modelSpendSeg role=img style="flex:${portion} 1 0;background:${segment.color}" title="${esc(title)}" aria-label="${esc(title)}">${inner}</div>`;}).join(''):'<div class="modelSpendEmpty emptyState">No estimated cost in this window</div>');
+ setLogHtml($('m-spend-legend'),segments.map(segment=>`<${segment.ids.length?`button type=button data-model-ids="${esc(segment.ids.join('\n'))}"`:'span'} class=modelSpendChip title="${esc(name(segment))}"><i style="background:${segment.color}"></i><span class=modelSpendChipName>${esc(segment.label)}</span>${segment.runtime?`<small>${esc(segment.runtime)}</small>`:''}<b class=mono>${money(segment.cost)}</b><em>${pct(share(segment))}</em></${segment.ids.length?'button':'span'}>`).join(''));
+ const notes=[];
+ if(uncosted){const detail=`${f(uncosted)} ${countWord(uncosted,'model runtime')} without cost data ${uncosted===1?'is':'are'} excluded, not counted as $0.`;notes.push(`<span class=fieldtip tabindex=0 aria-description="${esc(detail)}" data-tip="${esc(detail)}">${esc(`${f(uncosted)} unpriced, excluded`)}</span>`);}
+ if(costed.some(group=>group.estimated))notes.push(esc('Includes Cursor local estimates.'));
+ setLogHtml($('m-spend-note'),notes.join(' ')+(allSelected?'':' <button class=modelLinkBtn type=button data-model-clear>Show all models</button>'));
+}
+function drawModelMix(groups,top,rangeWindow){
+ const svg=$('m-mix'),tip=$('m-mix-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||250)),ML=62,MR=18,MT=16,MB=34,PW=VW-ML-MR,PH=VH-MT-MB,metric=MODEL_MIX_METRICS[modelMixMetric];svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ const days=rangeWindow.days||[...new Set(groups.flatMap(group=>group.daily.map(day=>day.day)))].sort();
+ const topIndex=new Map(top.map((group,index)=>[group.key,index])),topColor=modelRankedColors(top),series=[...top.map(group=>({label:`${group.model} · ${group.runtime}`,color:topColor.get(group.key),values:new Map()})),{label:'Other',color:MODEL_OTHER_COLOR,values:new Map()}];
+ groups.forEach(group=>{const target=topIndex.has(group.key)?series[topIndex.get(group.key)]:series[series.length-1];group.daily.forEach(day=>target.values.set(day.day,(target.values.get(day.day)||0)+metric.value(day)));});
+ const totals=days.map(day=>series.reduce((sum,item)=>sum+(item.values.get(day)||0),0)),max=Math.max(0,...totals);
+ [...$('m-mix-metric').querySelectorAll('button')].forEach(button=>button.classList.toggle('on',button.dataset.modelMix===modelMixMetric));
+ $('m-mix-note').textContent=`Top ${f(top.length)} by ${top.every(group=>Number(modelBoardValue(group,'cost'))>0)?'spend':top.some(group=>Number(modelBoardValue(group,'cost'))>0)?'spend, then output':'output'}${series[series.length-1].values.size?' + Other':''}`;
+ if(!days.length||max<=0){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="${svgTextPx(svg,VW,VH,13)}">${esc(modelMixMetric==='cost'?'No estimated cost in this window. Try Output or Executions.':'No model activity in this window')}</text>`;tip.style.display='none';return;}
+ const step=PW/Math.max(1,days.length),barW=Math.max(1,Math.min(34,step*.7)),x=index=>ML+step*(index+.5),h=value=>PH*value/max;
+ let html='';
+ for(let i=0;i<=4;i++){const y=MT+PH*i/4;html+=`<line x1="${ML}" x2="${ML+PW}" y1="${y}" y2="${y}" stroke="${CHART.grid}" stroke-width="1"/><text x="${ML-8}" y="${y+4}" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(metric.format(max*(1-i/4)))}</text>`;}
+ days.forEach((day,index)=>{let base=MT+PH;series.forEach(item=>{const value=item.values.get(day)||0;if(value<=0)return;const height=h(value);base-=height;html+=`<rect x="${(x(index)-barW/2).toFixed(1)}" y="${base.toFixed(1)}" width="${barW.toFixed(1)}" height="${Math.max(0,height-.6).toFixed(1)}" fill="${item.color}" fill-opacity=".9"/>`;});});
+ const labelEvery=Math.max(1,Math.ceil(days.length/8));
+ days.forEach((day,index)=>{const remaining=days.length-1-index,showLabel=index===days.length-1||(index%labelEvery===0&&remaining>=Math.max(2,Math.ceil(labelEvery/2)));if(showLabel)html+=`<text x="${x(index)}" y="${VH-10}" text-anchor="middle" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(day.slice(5))}</text>`;html+=`<rect data-mix-day="${index}" x="${ML+step*index}" y="${MT}" width="${step}" height="${PH}" fill="transparent" pointer-events="all"/>`;});
+ svg.innerHTML=html;svg.setAttribute('aria-label',`Daily ${metric.unit} stacked by model`);
+ const hide=()=>{tip.style.display='none';};
+ const show=(event,index)=>{
+  const rows=series.map(item=>({label:item.label,color:item.color,value:item.values.get(days[index])||0})).filter(item=>item.value>0);
+  if(!rows.length){hide();return;}
+  tip.innerHTML=`<div class=h>${esc(days[index])} · ${esc(metric.format(totals[index]))}</div>`+rows.map(item=>`<div class=r><span><i class=modelSwatch style="background:${item.color}"></i>${esc(item.label)}</span><b>${esc(metric.format(item.value))} · ${pct(item.value/totals[index])}</b></div>`).join('');
+  tip.style.display='block';
+  const rect=svg.parentElement.getBoundingClientRect(),pointerX=event.clientX-rect.left,rightX=pointerX+12,leftX=pointerX-tip.offsetWidth-12;
+  tip.style.left=(rightX+tip.offsetWidth<=rect.width-8?rightX:Math.max(8,leftX))+'px';tip.style.top=Math.max(8,event.clientY-rect.top-tip.offsetHeight-10)+'px';
+ };
+ [...svg.querySelectorAll('[data-mix-day]')].forEach(hit=>{const index=Number(hit.dataset.mixDay);hit.onpointerenter=event=>show(event,index);hit.onpointermove=event=>show(event,index);hit.onpointerleave=hide;});
+}
+const MODEL_PUSHBACK_PERIODS={today:'1d','7':'7d','30':'30d','90':'90d',month:'month',all:'0'},MODEL_PUSHBACK_TTL_MS=60000,MODEL_PUSHBACK_MAX_MODELS=20;
+let modelPushback={key:'',state:'idle',rates:new Map(),at:0,loading:false},modelPushbackRequest=0;
+function modelPushbackKey(){return `${modelRange}\u0000${modelProject}`;}
+function modelPushbackFor(row){return modelPushback.rates.get(`${row.model}\u0000${row.runtime}`)||null;}
+async function loadModelPushback(){
+ const key=modelPushbackKey(),period=MODEL_PUSHBACK_PERIODS[modelRange];
+ if(modelPushback.key===key&&(modelPushback.loading||modelPushback.state==='unsupported_range'||modelPushback.state==='unsupported'||Date.now()-modelPushback.at<MODEL_PUSHBACK_TTL_MS))return;
+ if(!period){modelPushback={key,state:'unsupported_range',rates:new Map(),at:Date.now(),loading:false};return;}
+ const request=++modelPushbackRequest,query=new URLSearchParams({months:period});
+ if(modelProject)query.set('project',modelProject);
+ modelPushback=modelPushback.key===key?{...modelPushback,loading:true}:{key,state:'loading',rates:new Map(),at:0,loading:true};
+ let next={key,state:'unavailable',rates:new Map(),at:Date.now(),loading:false};
+ try{
+  const response=await fetch(`/work?${query}`,{cache:'no-store'}),payload=await response.json();
+  if(response.ok&&payload.ok&&payload.insights){
+   const models=payload.insights.rework?.models||[];
+   next={key,state:payload.settings?.enabled?'ready':'off',rates:new Map(models.map(item=>[`${item.model}\u0000${item.runtime}`,item])),capped:models.length>=MODEL_PUSHBACK_MAX_MODELS,at:Date.now(),loading:false};
+  }else if(response.status===404&&!/project/i.test(payload.error||''))next={...next,state:'unsupported'};
+ }catch(error){}
+ if(request!==modelPushbackRequest)return;
+ modelPushback=next;
+ if(LATEST&&modelPushbackKey()===key)rerenderActiveModelStats();
+}
+function modelPushbackCell(row){
+ if(!row.variants)return '<td class="num modelMuted"></td>';
+ const item=modelPushbackFor(row),span=modelRange==='all'?' · last 24 months':'';
+ if(item){
+  const tip=`${f(Math.round(item.rate*item.samples))} of ${f(item.samples)} labeled follow-ups pushed back${span}${item.few_samples?' · few samples, treat as a rough signal':''} · local model estimate`;
+  return `<td class="num mono${item.few_samples?' modelMuted':''}" title="${esc(tip)}">${pct(item.rate)}${item.few_samples?'*':''}</td>`;
+ }
+ const state=modelPushback.state;
+ const reason=state==='unsupported_range'?'Pushback is not available for Yesterday or Last month. Choose another History range.':state==='unsupported'?'Work insights are not available on this system.':state==='loading'?'Loading pushback.':state==='off'?'Turn on Work insights in Settings to label follow-ups.':state==='unavailable'?'Pushback is unavailable right now. It retries shortly.':modelPushback.capped?`Not among the ${MODEL_PUSHBACK_MAX_MODELS} models with the most labeled follow-ups in this window.`:'No labeled follow-ups for this model in this window.';
+ return `<td class="num modelMuted" title="${esc(reason)}">--</td>`;
+}
+function modelBoardCells(row,color,leaderCost,totalCost){
+ const data=row.window,cost=modelBoardValue(row,'cost'),perExec=modelBoardValue(row,'cost_per_exec'),cache=modelBoardValue(row,'cache'),output=modelBoardValue(row,'output'),speed=modelBoardValue(row,'speed'),wait=modelBoardValue(row,'wait'),partial=metricPartial(data,'cost'),covered=Number(data.cost_covered_executions||0),perExecPartial=partial||(covered>0&&covered<Number(data.executions||0)),est=row.runtime==='Cursor'?' est':'';
+ const spend=cost===null?`<td class="num modelMuted" title="Cost unavailable for this runtime">--</td>`:`<td class="num modelSpendCell"><span class=modelSpendTrack><i style="width:${leaderCost>0?Math.max(2,100*cost/leaderCost):0}%;background:${color}"></i></span><b class=mono>${money(cost)}${partial?'*':''}</b><small>${totalCost>0?pct(cost/totalCost):''}</small></td>`;
+ const speedTip=data.available?`${speedFmt(data.output_tps)} tok/s average · ${data.throughput_basis==='tool_free'?'tool-free':'end-to-end'} timing · ${f(data.throughput_samples)} timed ${countWord(data.throughput_samples,'sample')} · ${pct(data.timing_coverage)} of output covered`:'No attributable output timing in this window.';
+ const waitTip=data.wait_samples?`Prompt-to-completed-response wait. ${f(data.wait_samples)} timed ${countWord(data.wait_samples,'request')} · ${waitFmt(data.avg_wait_s)} average · ${waitFmt(data.p95_wait_s)} p95`:'No model-attributable completed waits in this window.';
+ return `${spend}<td class="num mono">${perExec===null?'--':money(perExec)+(perExecPartial?'*':'')}</td><td class="num mono">${cache===null?'--':pct(cache)}</td><td class="num mono">${f(data.executions)}</td><td class="num mono">${output===null?'--':compactNumber(output)+est}</td><td class="num mono modelSpeedCell" title="${esc(speedTip)}">${speed===null?'--':speedFmt(speed)+est}</td><td class="num mono" title="${esc(waitTip)}">${wait===null?'--':waitFmt(wait)}</td>${modelPushbackCell(row)}`;
+}
+function modelBoardTip(row){
+ const data=row.window,rowTokens=metricAvailable(data,'tokens'),cursorEstimate=row.runtime==='Cursor',basis=data.throughput_basis==='tool_free'?'tool-free':data.throughput_basis==='end_to_end'?'end-to-end':'unavailable',ttftNote=data.ttft_samples?`${Math.round(data.avg_ttft_ms)}ms avg TTFT`:'TTFT unavailable in these traces';
+ const workload=`Typical workload (approximate shape, not semantic difficulty): ${compactNumber(data.median_peak_input_tokens)} median peak context · ${rowTokens?compactNumber(data.median_workload_output_tokens):'--'} median output · ${compactNumber(data.median_tool_calls)} median tools · ${compactNumber(data.median_model_calls)} median model calls${cursorEstimate?' · Cursor input/output are local proxies':''}.`;
+ const pace=data.available?`Observed output pace ${speedFmt(data.output_tps)} tok/s (${basis} · ${f(data.throughput_samples)} ${countWord(data.throughput_samples,'sample')} · ${pct(data.timing_coverage)} coverage · ${ttftNote}); diagnostic, not a model verdict.`:'No attributable output timing in this window.';
+ return `${row.model} · ${row.runtime}. Input ${rowTokens?compactNumber(data.input_tokens):'--'}. ${workload} ${pace}`;
+}
+const MODEL_SPEED_EXTRA_COLORS=THEME.modelSpeedExtra;
+function modelSpeedBasis(window){return Number(window?.tool_free_samples||0)>0&&Number(window?.tool_free_seconds||0)>0?'tool_free':'timed';}
+function modelSpeedSeries(daily,days,basis){
+ const outKey=basis==='tool_free'?'tool_free_output_tokens':'timed_output_tokens',secKey=basis==='tool_free'?'tool_free_seconds':'timed_seconds',sampleKey=basis==='tool_free'?'tool_free_samples':'timed_samples';
+ const byDay=new Map();
+ (daily||[]).forEach(day=>{const target=byDay.get(day.day)||{out:0,sec:0,samples:0};target.out+=Number(day[outKey]||0);target.sec+=Number(day[secKey]||0);target.samples+=Number(day[sampleKey]||0);byDay.set(day.day,target);});
+ return days.map((day,index)=>{
+  const own=byDay.get(day);if(!own||own.sec<=0||own.out<=0)return null;
+  let out=0,sec=0;for(let offset=-1;offset<=1;offset++){const near=byDay.get(days[index+offset]);if(near&&near.sec>0){out+=near.out;sec+=near.sec;}}
+  return {index,day,value:sec>0?out/sec:0,raw:own.out/own.sec,samples:own.samples};
+ }).filter(Boolean);
+}
+function modelCalendarDays(values){
+ const sorted=[...new Set((values||[]).filter(value=>/^\d{4}-\d{2}-\d{2}$/.test(value)))].sort();
+ if(!sorted.length)return [];
+ const out=[],cursor=new Date(`${sorted[0]}T12:00:00`),last=sorted[sorted.length-1];
+ while(out.length<3700){const key=localDateKey(cursor);out.push(key);if(key>=last)break;cursor.setDate(cursor.getDate()+1);}
+ return out;
+}
+function modelSpeedDefaultKeys(ranking){return ranking.filter(group=>group.window.available).slice(0,5).map(group=>group.key);}
+function modelSmoothPath(points){
+ if(points.length<2)return '';
+ const n=points.length,dx=[],slope=[],tangent=new Array(n).fill(0);
+ for(let i=0;i<n-1;i++){dx[i]=points[i+1][0]-points[i][0];slope[i]=dx[i]?(points[i+1][1]-points[i][1])/dx[i]:0;}
+ tangent[0]=slope[0];tangent[n-1]=slope[n-2];
+ for(let i=1;i<n-1;i++)tangent[i]=slope[i-1]*slope[i]<=0?0:(slope[i-1]+slope[i])/2;
+ for(let i=0;i<n-1;i++){if(slope[i]===0){tangent[i]=0;tangent[i+1]=0;continue;}const a=tangent[i]/slope[i],b=tangent[i+1]/slope[i],h=a*a+b*b;if(h>9){const t=3/Math.sqrt(h);tangent[i]=t*a*slope[i];tangent[i+1]=t*b*slope[i];}}
+ let d=`M${points[0][0].toFixed(1)},${points[0][1].toFixed(1)}`;
+ for(let i=0;i<n-1;i++){const [x0,y0]=points[i],[x1,y1]=points[i+1],third=dx[i]/3;d+=` C${(x0+third).toFixed(1)},${(y0+tangent[i]*third).toFixed(1)} ${(x1-third).toFixed(1)},${(y1-tangent[i+1]*third).toFixed(1)} ${x1.toFixed(1)},${y1.toFixed(1)}`;}
+ return d;
+}
+function renderModelSpeedChart(groups,ranking,top,rangeWindow){
+ const svg=$('m-speedchart-svg'),tip=$('m-speedchart-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||250)),ML=56,MR=18,MT=30,MB=34,PW=VW-ML-MR,PH=VH-MT-MB;svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ const timed=ranking.filter(group=>group.window.available),byKey=new Map(timed.map(group=>[group.key,group])),defaults=modelSpeedDefaultKeys(ranking);
+ let keys=(modelSpeedSelection||defaults).filter(key=>byKey.has(key)),fallback=false;
+ if(modelSpeedSelection&&!keys.length&&defaults.length){keys=defaults;fallback=true;}
+ const topColor=modelRankedColors(top);let extra=0;
+ const colorFor=key=>topColor.get(key)||MODEL_SPEED_EXTRA_COLORS[(extra++)%MODEL_SPEED_EXTRA_COLORS.length];
+ const days=rangeWindow.days||modelCalendarDays(groups.flatMap(group=>group.daily.map(day=>day.day)));
+ const series=keys.map(key=>{const group=byKey.get(key);return {key,label:`${group.model} · ${group.runtime}`,color:colorFor(key),estimated:group.estimated,points:modelSpeedSeries(group.daily,days,modelSpeedBasis(group.window))};});
+ const custom=Boolean(modelSpeedSelection)&&!fallback;
+ $('m-speedchart-summary').textContent=custom?`${f(keys.length)} ${countWord(keys.length,'model')} selected`:'Top 5 by spend';
+ $('m-speedchart-reset').disabled=!modelSpeedSelection;
+ const atMax=keys.length>=MODEL_SPEED_MAX_SERIES;
+ setLogHtml($('m-speedchart-options'),timed.length?timed.map(group=>{const checked=keys.includes(group.key);return `<label class=modelOption title="${esc(group.model)} · ${esc(group.runtime)}"><input type=checkbox data-model-speed-choice="${esc(group.key)}" ${checked?'checked':''} ${!checked&&atMax?'disabled':''}><span>${esc(group.model)} · ${esc(group.runtime)} · ${esc(speedFmt(group.window.output_tps))} tok/s</span></label>`;}).join(''):'<div class="modelEmpty emptyState">No timed models in this window</div>');
+ setLogHtml($('m-speedchart-legend'),series.map(item=>`<span class=modelSpeedChip><i style="background:${item.color}"></i>${esc(item.label)}${item.estimated?' <small>est</small>':''}</span>`).join(''));
+ $('m-speedchart-note').textContent=`3-day avg output tok/s · ${custom?'your selection':`top ${f(keys.length)} by spend`}${fallback?' · your chosen models have no timing here':''}`;
+ const values=series.flatMap(item=>item.points.map(point=>point.value)),max=values.length?Math.max(...values)*1.1:0;
+ if(!series.length||max<=0){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="${svgTextPx(svg,VW,VH,13)}">No timed output in this window</text>`;tip.style.display='none';return;}
+ const step=PW/Math.max(1,days.length),x=index=>ML+step*(index+.5),y=value=>MT+PH-PH*value/max;
+ let html='';
+ for(let i=0;i<=4;i++){const yy=MT+PH*i/4;html+=`<line x1="${ML}" x2="${ML+PW}" y1="${yy}" y2="${yy}" stroke="${CHART.grid}" stroke-width="1"/><text x="${ML-8}" y="${yy+4}" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(speedFmt(max*(1-i/4))==='--'?'0':speedFmt(max*(1-i/4)))}</text>`;}
+ series.forEach(item=>{const {segments,bridges}=chartGapRuns(item.points);bridges.forEach(([from,to])=>{html+=chartGapBridge(x(from.index),y(from.value),x(to.index),y(to.value),item.color);});segments.forEach(segment=>{const pts=segment.map(point=>[x(point.index),y(point.value)]);if(pts.length>1)html+=`<path d="${modelSmoothPath(pts)}" fill="none" stroke="${item.color}" stroke-width="2.4" ${item.estimated?'stroke-dasharray="6 4"':''} stroke-linecap="round" stroke-linejoin="round"/>`;else html+=`<circle cx="${pts[0][0].toFixed(1)}" cy="${pts[0][1].toFixed(1)}" r="3.4" fill="${item.estimated?'none':item.color}" stroke="${item.color}" stroke-width="1.6"/>`;});});
+ const labelEvery=Math.max(1,Math.ceil(days.length/8));
+ days.forEach((day,index)=>{const remaining=days.length-1-index,showLabel=index===days.length-1||(index%labelEvery===0&&remaining>=Math.max(2,Math.ceil(labelEvery/2)));if(showLabel)html+=`<text x="${x(index)}" y="${VH-10}" text-anchor="middle" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(day.slice(5))}</text>`;html+=`<rect data-speed-day="${index}" x="${ML+step*index}" y="${MT}" width="${step}" height="${PH}" fill="transparent" pointer-events="all"/>`;});
+ html+=`<text x="8" y="12" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">tok/s</text>`;
+ svg.innerHTML=html;
+ const hide=()=>{tip.style.display='none';};
+ const show=(event,index)=>{
+  const rows=series.map(item=>({item,point:item.points.find(point=>point.index===index)})).filter(row=>row.point);
+  tip.innerHTML=`<div class=h>${esc(days[index])}</div>`+(rows.length?'':'<div class=r><span>No data</span></div>')+rows.map(({item,point})=>`<div class=r><span><i class=modelSwatch style="background:${item.color}"></i>${esc(item.label)}</span><b>${esc(speedFmt(point.value))} tok/s · ${f(point.samples)} ${countWord(point.samples,'sample')}</b></div>`).join('');
+  tip.style.display='block';
+  const rect=svg.parentElement.getBoundingClientRect(),pointerX=event.clientX-rect.left,rightX=pointerX+12,leftX=pointerX-tip.offsetWidth-12;
+  tip.style.left=(rightX+tip.offsetWidth<=rect.width-8?rightX:Math.max(8,leftX))+'px';tip.style.top=Math.max(8,event.clientY-rect.top-tip.offsetHeight-10)+'px';
+ };
+ [...svg.querySelectorAll('[data-speed-day]')].forEach(hit=>{const index=Number(hit.dataset.speedDay);hit.onpointerenter=event=>show(event,index);hit.onpointermove=event=>show(event,index);hit.onpointerleave=hide;});
+}
+function renderModelBoard(groups,ranking,top){
+ loadModelPushback();
+ const rank=new Map(ranking.map((group,index)=>[group.key,index+1])),topColor=modelRankedColors(top);
+ const costs=groups.map(group=>modelBoardValue(group,'cost')).filter(value=>value!==null),leaderCost=Math.max(0,...costs),totalCost=costs.reduce((sum,value)=>sum+value,0);
+ [...$('m-table').querySelectorAll('th')].forEach(th=>{const button=th.querySelector('[data-model-sort]');if(!button){th.removeAttribute('aria-sort');return;}const active=button.dataset.modelSort===modelSort.key;th.setAttribute('aria-sort',active?(modelSort.direction==='asc'?'ascending':'descending'):'none');button.classList.toggle('on',active);button.dataset.direction=active?modelSort.direction:'';});
+ const html=sortModelBoard(groups).map(group=>{
+  const color=topColor.get(group.key)||MODEL_OTHER_COLOR,expandable=group.variants.length>1,expanded=expandable&&modelExpandedGroups.has(group.key),only=group.variants[0],tip=modelBoardTip(group);
+  const subline=expandable?`${f(group.variants.length)} reasoning efforts`:`${modelEffortLabel(only)} · ${f(only.logs)} ${countWord(only.logs,'log')}`;
+  const toggle=expandable?`<button class=modelExpand type=button data-model-expand="${esc(group.key)}" aria-expanded=${expanded} aria-label="${expanded?'Hide':'Show'} reasoning efforts for ${esc(group.model)} · ${esc(group.runtime)}">${expanded?'▾':'▸'}</button>`:'<span class=modelExpandSpacer></span>';
+  let rowHtml=`<tr class=modelGroupRow><td class="modelRankCol mono">${f(rank.get(group.key)||0)}</td><td class="fieldtip modelCellTip modelNameCell" tabindex=0 data-tip="${esc(tip)}" aria-description="${esc(tip)}"><div class=modelNameLine>${toggle}<i class=modelSwatch style="background:${color}"></i><div class=modelName title="${esc(group.model)}">${esc(group.model)}</div></div><div class=modelRuntime>${esc(group.runtime)}${group.estimated?' est':''} · ${esc(subline)}</div></td>${modelBoardCells(group,color,leaderCost,totalCost)}</tr>`;
+  if(expanded)rowHtml+=sortModelBoard(group.variants).map(variant=>`<tr class=modelVariantRow><td></td><td class="fieldtip modelCellTip" tabindex=0 data-tip="${esc(modelBoardTip(variant))}" aria-description="${esc(modelBoardTip(variant))}"><div class=modelVariantName>${esc(modelEffortLabel(variant))}<small>${f(variant.logs)} ${countWord(variant.logs,'log')}</small></div></td>${modelBoardCells(variant,color,leaderCost,totalCost)}</tr>`).join('');
+  return rowHtml;
+ }).join('');
+ setLogHtml($('m-table').querySelector('tbody'),html||`<tr><td colspan=10><div class="modelEmpty emptyState">No model activity in this window</div></td></tr>`);
+}
+const MODEL_FOCUS_KEYS=['modelExpand','modelIds','modelSort','modelMix','modelSpeedChoice'];
+function modelFocusKey(){
+ const el=document.activeElement;if(!el||!el.dataset||!$('view-models').contains(el))return null;
+ const key=MODEL_FOCUS_KEYS.find(name=>name in el.dataset);if(!key)return null;
+ const container=el.closest('#m-spend-bar,#m-spend-legend,#m-table,#m-mix-metric,#m-speedchart-options')||$('view-models');
+ return {el,key,value:el.dataset[key],containerId:container.id};
+}
+function restoreModelFocus(focus){
+ if(!focus||focus.el.isConnected)return;
+ const container=$(focus.containerId)||$('view-models'),attr='data-'+focus.key.replace(/[A-Z]/g,char=>'-'+char.toLowerCase());
+ const target=[...container.querySelectorAll(`[${attr}]`)].find(el=>el.dataset[focus.key]===focus.value);
+ if(target)target.focus({preventScroll:true});
+}
+function renderModelStats(stats){
+ const focus=modelFocusKey();
+ stats=stats||{models:[]};
+ const allModels=(stats.models||[]).map(row=>({...row,id:row.id||row.model,runtime:row.runtime||(row.providers||[]).join(' + ')||'unknown runtime'})),names=allModels.map(row=>row.id).sort((a,b)=>a.localeCompare(b));
+ modelFilters=migrateModelRuntimeFilters(modelFilters,allModels);saveActiveModelFilters();
+ const allSelected=!modelFilters.length,selected=allModels.filter(row=>allSelected||modelFilters.includes(row.id)),rangeWindow=modelRangeWindow(modelRange),options=allModels.slice().sort((a,b)=>modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b)));
+ const modelPickerOptions=`<label class="modelOption all"><input type=checkbox data-model-choice=all ${allSelected?'checked':''}><span>All model runtimes</span></label>`+options.map(row=>`<label class=modelOption title="${esc(modelRuntimeLabel(row))}"><input type=checkbox data-model-choice=model value="${esc(row.id)}" ${modelFilters.includes(row.id)?'checked':''}><span>${esc(modelRuntimeLabel(row))}</span></label>`).join('');
+ setLogHtml($('m-model-options'),modelPickerOptions);
+ if($('m-model-picker').open)requestAnimationFrame(positionModelPickerMenu);
+ const selectionLabel=allSelected?'All model runtimes':selected.length===1?modelRuntimeLabel(selected[0]):`${selected.length} model runtimes selected`;$('m-model-summary').textContent=selectionLabel;$('m-model-summary').title=allSelected?'All model runtimes':selected.map(modelRuntimeLabel).join(', ');$('m-range').value=modelRange;
+	 const total=aggregateModelDays(mergeModelDays(selected,rangeWindow)),chart=buildModelTrend(selected,rangeWindow,names);
+	 const groups=modelGroupRows(selected,rangeWindow),ranking=modelSpendRanking(groups),top=ranking.slice(0,5);
+	 renderModelSpend(groups,ranking,top,allSelected);
+	 drawModelMix(groups,top,rangeWindow);
+	 renderModelSpeedChart(groups,ranking,top,rangeWindow);
+	 renderModelBoard(groups,ranking,top);
+	 [...$('m-metric').querySelectorAll('button')].forEach(button=>button.classList.toggle('on',button.dataset.modelMetric===modelTrendMetric));
+	 $('m-speed-label').textContent=total.throughput_basis==='tool_free'?'Tool-free output pace':'Observed output pace';
+	 setModelKpiValue('m-speed',total.available?speedFmt(total.output_tps)+' tok/s':'--',total.available?estimateSuffix(total):'');
+	 const speedDetail=total.available?`${total.throughput_basis==='tool_free'?'Tool-free':'End-to-end'} timing · ${f(total.throughput_samples)} timed ${countWord(total.throughput_samples,'sample')} · ${pct(total.timing_coverage)} output coverage.`:'No attributable timing in this window.';
+	 $('m-speed-note').textContent=total.available?`${pct(total.timing_coverage)} output covered`:'Timing unavailable';
+	 setModelKpiHelp('m-speed-label',speedDetail);
+	 $('m-coverage-bar').style.width=Math.max(0,Math.min(100,100*total.timing_coverage))+'%';
+	 $('m-coverage').setAttribute('aria-valuenow',String(Math.round(100*total.timing_coverage)));
+	 $('m-wait').textContent=total.wait_samples?waitFmt(total.median_wait_s):'--';
+	 const waitDetail=total.wait_samples?`${f(total.wait_samples)} timed · ${waitFmt(total.avg_wait_s)} average · ${waitFmt(total.p95_wait_s)} p95${total.user_pause_seconds?` · ${waitFmt(total.user_pause_seconds)} human pause excluded`:''}.`:'No model-attributable completed waits.';
+	 $('m-wait-note').textContent=total.wait_samples?`${f(total.wait_samples)} timed`:'Timing unavailable';
+	 setModelKpiHelp('m-wait-label',waitDetail);
+	 renderMatchedPace(stats,selected);
+	 setModelKpiHelp('m-change-label',$('m-change-note').title||$('m-change-note').textContent);
+	 $('m-trend-note').textContent=`Bars: daily output tokens · Lines: ${(MODEL_TREND_METRICS[modelTrendMetric]||MODEL_TREND_METRICS.speed).note} per model · ${modelScopeLabel()} · ${allSelected?'all runtimes':`${f(selected.length)} selected`} · ${modelRangeLabel(modelRange)}`;
+	 drawModelTrend(chart);
+	 restoreModelFocus(focus);
+}
+
diff --git a/dashboard/js/motion-readouts.js b/dashboard/js/motion-readouts.js
new file mode 100644
index 00000000..b40f7eed
--- /dev/null
+++ b/dashboard/js/motion-readouts.js
@@ -0,0 +1,103 @@
+// Pixel-viewBox charts redraw when their box changes (resize, or first shown after a hidden render)
+// so text and marks stay undistorted. Redrawing sets viewBox to the box, so this settles.
+let chartResizeTimer=0;
+const PIXEL_CHARTS={spend:['s-scatter-svg'],git:['d-daily-chart'],models:['m-chart','m-mix','m-speedchart-svg'],goals:['goals-trend-chart'],efficiency:['e-output-dollar-chart','e-reasoning-chart','e-context-load-chart','e-cache-hit-chart'],session:['iochart']};
+const chartViewBoxStale=id=>{const svg=$(id);if(!svg||!svg.clientWidth||!svg.clientHeight)return false;const box=svg.viewBox.baseVal;return Math.abs(box.width-Math.round(svg.clientWidth))>1||Math.abs(box.height-Math.round(svg.clientHeight))>1;};
+const chartResizeObserver=new ResizeObserver(()=>{
+ clearTimeout(chartResizeTimer);
+ chartResizeTimer=setTimeout(()=>{
+  if(activeModelStats&&activeModelScope===modelProject&&PIXEL_CHARTS.models.some(chartViewBoxStale))renderModelStats(activeModelStats);
+  if(activeEfficiencyStats&&activeEfficiencyScope===efficiencyProject&&PIXEL_CHARTS.efficiency.some(chartViewBoxStale))renderEfficiency(activeEfficiencyStats);
+  if(CURRENT&&PIXEL_CHARTS.session.some(chartViewBoxStale))drawIO(CURRENT.series||[]);
+  if(spendInsightPayload&&PIXEL_CHARTS.spend.some(chartViewBoxStale))drawSpendScatter(spendInsightPayload.sessions||[]);
+  if(deliveryPayload&&PIXEL_CHARTS.git.some(chartViewBoxStale))drawDeliveryChart(deliveryPayload.days||[]);
+  if(goalDetailData&&PIXEL_CHARTS.goals.some(chartViewBoxStale))drawGoalTrend();
+ },120);
+});
+Object.values(PIXEL_CHARTS).flat().forEach(id=>{const svg=$(id);if(svg)chartResizeObserver.observe(svg);});
+// spectrum-motion-v1: motion that explains a change, never on poll redraws or keyboard-only paths.
+const motionAllowed=()=>!pageSignalReducedMotionQuery.matches&&!document.hidden;
+const CHART_REVEAL_IDS=Object.values(PIXEL_CHARTS).flat();
+const chartsRevealedThisVisit=new Set();
+function revealChart(svg){
+ if(!svg||chartsRevealedThisVisit.has(svg.id)||!svg.childElementCount||!svg.getClientRects().length)return;
+ chartsRevealedThisVisit.add(svg.id);
+ if(!motionAllowed()||!svg.animate)return;
+ // Time runs left to right, so the series draws in that direction.
+ svg.animate([{clipPath:'inset(0 100% 0 0)'},{clipPath:'inset(0 0 0 0)'}],{duration:560,easing:cssVar('--ease-in-out')});
+}
+const chartRevealObserver=new MutationObserver(records=>records.forEach(record=>revealChart(record.target)));
+CHART_REVEAL_IDS.forEach(id=>{const svg=$(id);if(svg)chartRevealObserver.observe(svg,{childList:true});});
+let motionRouteView=null;
+function playRouteMotion(view){
+ if(view===motionRouteView)return;
+ motionRouteView=view;
+ chartsRevealedThisVisit.clear();
+ CHART_REVEAL_IDS.forEach(id=>revealChart($(id)));
+ if(!view||view.dataset.entered)return;
+ view.dataset.entered='1';
+ if(!motionAllowed())return;
+ [...view.children].forEach((child,index)=>child.style.setProperty('--enter-i',String(Math.min(index,6))));
+ view.classList.add('viewEnter');
+ setTimeout(()=>view.classList.remove('viewEnter'),900);
+}
+const READOUT_SELECTOR=':is(.metric>.v,.metric>strong,.metric>b,.previewCost,.previewKpi .v,.budgetSpendValue,.efficiencyHeadline .v,.ov .v,.stat .v)';
+const READOUT_PATTERN=/^([$<≈~]?)(\d[\d,]*(?:\.\d+)?)(\s?[A-Za-z%]{0,3})$/;
+const READOUT_MIN_SHARE=.01,READOUT_QUIET_MS=10000;
+const readoutText=new WeakMap(),readoutTweens=new WeakMap(),readoutLastTween=new WeakMap();
+function parseReadout(text){
+ const match=READOUT_PATTERN.exec(String(text).trim());
+ if(!match)return null;
+ return {prefix:match[1],suffix:match[3],value:Number(match[2].replace(/,/g,'')),decimals:(match[2].split('.')[1]||'').length,grouped:match[2].includes(',')};
+}
+function formatReadout(shape,value){
+ return shape.prefix+value.toLocaleString('en-US',{minimumFractionDigits:shape.decimals,maximumFractionDigits:shape.decimals,useGrouping:shape.grouped})+shape.suffix;
+}
+function tweenReadout(element,fromText,toText){
+ // Placeholders mean unavailable evidence: they switch instantly instead of counting up from a fake zero.
+ const to=parseReadout(toText),from=parseReadout(fromText);
+ if(!to||!from||from.prefix!==to.prefix||from.suffix!==to.suffix||from.value===to.value)return;
+ // Live ticks stay quiet: only a meaningful change counts, at most once per element every 10s.
+ if(Math.abs(to.value-from.value)<READOUT_MIN_SHARE*Math.max(Math.abs(from.value),Math.abs(to.value)))return;
+ const now=performance.now();
+ if(now-(readoutLastTween.get(element)??-Infinity)<READOUT_QUIET_MS)return;
+ readoutLastTween.set(element,now);
+ const started=now,duration=parseFloat(cssVar('--dur-data'))||480;
+ const step=now=>{
+  if(readoutTweens.get(element)!==step)return;
+  const progress=Math.min(1,(now-started)/duration),eased=1-Math.pow(1-progress,3);
+  const text=progress>=1?toText:formatReadout(to,from.value+(to.value-from.value)*eased);
+  readoutText.set(element,text);
+  element.textContent=text;
+  if(progress<1)requestAnimationFrame(step);else readoutTweens.delete(element);
+ };
+ readoutTweens.set(element,step);
+ requestAnimationFrame(step);
+}
+// Readouts count toward their new value so the size of a change is visible, not just its result.
+const readoutObserver=new MutationObserver(records=>{
+ records.forEach(record=>{
+  const element=record.type==='characterData'?record.target.parentElement:record.target;
+  if(!element?.matches?.(READOUT_SELECTOR))return;
+  const next=element.textContent,previous=readoutText.get(element);
+  if(next===previous)return;
+  readoutText.set(element,next);
+  readoutTweens.delete(element);
+  if(previous===undefined||element.childElementCount||!motionAllowed()||element.closest('[aria-live]')||!element.getClientRects().length)return;
+  tweenReadout(element,previous,next);
+ });
+});
+document.querySelectorAll(READOUT_SELECTOR).forEach(element=>readoutText.set(element,element.textContent));
+readoutObserver.observe(document.body,{subtree:true,childList:true,characterData:true});
+window.addEventListener('resize',()=>{
+ clearTimeout(spendResizeTimer);
+ spendResizeTimer=setTimeout(()=>{
+  if(!$('view-daily').classList.contains('on')||!spendChartRows.length)return;
+  reconcileSpendBars(spendChartRows);
+  const hovered=$('s-chart-inner').querySelector('.spendDay:hover');
+  if(hovered)showSpendTip(hovered.dataset.spendDay,hovered);else hideSpendTip();
+  if(spendInsightPayload)drawSpendScatter(spendInsightPayload.sessions||[]);
+ },100);
+});
+
+
diff --git a/dashboard/js/notifications-settings.js b/dashboard/js/notifications-settings.js
new file mode 100644
index 00000000..f68ad889
--- /dev/null
+++ b/dashboard/js/notifications-settings.js
@@ -0,0 +1,450 @@
+const canNotify=('Notification' in window);
+const notifySecure=window.isSecureContext||['localhost','127.0.0.1','::1'].includes(location.hostname);
+const notifyWanted=localStorage.getItem('tm_notify')==='1';
+let notifyOn=notifyWanted && canNotify && notifySecure && Notification.permission==='granted';
+if(notifyWanted&&!notifyOn) localStorage.setItem('tm_notify','0');
+let notifiedKeys=new Set();
+let notifyLog=[];
+try{
+ notifyLog=JSON.parse(localStorage.getItem('tm_notify_log')||'[]')
+  .filter(n=>n&&n.title!=='Token insight'&&!(n.title==='Token Meter alert'&&String(n.body||'').startsWith('Last execution cost ')))
+  .slice(0,24);
+ localStorage.setItem('tm_notify_log',JSON.stringify(notifyLog));
+}catch(e){ notifyLog=[]; }
+function notifyStamp(){ return new Date().toLocaleTimeString([], {hour:'2-digit', minute:'2-digit', second:'2-digit'}); }
+function setNotifyState(msg){ if($('notify-state')) $('notify-state').textContent=msg; }
+function saveNotifyLog(){ try{ localStorage.setItem('tm_notify_log',JSON.stringify(notifyLog.slice(0,24))); }catch(e){} }
+function renderNotifyLog(){
+ const box=$('notify-log'); if(!box) return;
+ box.innerHTML=notifyLog.length?notifyLog.map(n=>`<div class="logrow ${esc(n.kind||'')}"><div class=h><span>${esc(n.title)}</span><span class=mono>${esc(n.time)}</span></div><div class=b>${esc(n.body)}</div></div>`).join(''):'<div class=subline>no notifications yet</div>';
+}
+function showAppToast(entry){
+ const box=$('toastbox'); if(!box) return;
+ const toast=document.createElement('div');
+ toast.className='toast '+(entry.kind||'');
+ const head=document.createElement('div'); head.className='th';
+ const title=document.createElement('span'); title.textContent=entry.title;
+ const close=document.createElement('button'); close.type='button'; close.textContent='x'; close.setAttribute('aria-label','Dismiss');
+ head.appendChild(title); head.appendChild(close);
+ const body=document.createElement('div'); body.className='tb'; body.textContent=entry.body;
+ toast.appendChild(head); toast.appendChild(body); box.appendChild(toast);
+ close.onclick=()=>toast.remove();
+ setTimeout(()=>toast.remove(),entry.sticky?9500:6500);
+ while(box.children.length>4) box.firstElementChild.remove();
+}
+function agentActionToken(){return LATEST?.xsession?.capabilities?.actions?.token||'';}
+let SOFTWARE_UPDATE=null,softwareUpdateRequestBusy=false,softwareUpdatePollTimer=0,softwareUpdateTarget='';
+function softwareUpdateActionToken(){return SOFTWARE_UPDATE?.actions?.token||agentActionToken();}
+function softwareUpdateStamp(value){
+ if(!value)return'';
+ return new Date(Number(value)*1000).toLocaleString([],{
+  month:'short',day:'numeric',hour:'2-digit',minute:'2-digit',
+ });
+}
+function scheduleSoftwareUpdatePoll(delay=1500){
+ clearTimeout(softwareUpdatePollTimer);
+ softwareUpdatePollTimer=setTimeout(refreshSoftwareUpdateStatus,delay);
+}
+function renderSoftwareUpdate(status){
+ if(!status)return;
+ SOFTWARE_UPDATE=status;
+ const state=status.state||'waiting',enabled=!!status.enabled;
+ $('update-enabled').checked=enabled;
+ $('update-auto-install').checked=enabled&&status.auto_install===true;
+ $('update-auto-install').disabled=!enabled;
+ $('update-check').disabled=!enabled||status.checking||status.updating;
+ $('update-check').textContent=status.checking?'Checking…':'Check now';
+ const badge={
+  disabled:'Checks off',waiting:'Waiting',checking:'Checking',available:'Update ready',
+  updating:'Updating',updated:'Updated',current:'Up to date',attention:'Needs attention',
+ }[state]||'Unavailable';
+ $('update-settings-badge').textContent=badge;
+ $('update-settings-status').className=`settingsStatus ${['attention'].includes(state)?'warn':['available','updated','current'].includes(state)?'good':''}`;
+ $('update-settings-status').textContent=status.message||'Update status is unavailable.';
+ const revisions=status.current_revision
+  ? `${status.current_revision.slice(0,12)}${status.latest_revision&&status.latest_revision!==status.current_revision?` → ${status.latest_revision.slice(0,12)}`:''}`
+  :'';
+ const checked=softwareUpdateStamp(status.checked_at);
+ $('update-settings-meta').textContent=[revisions,checked?`last checked ${checked}`:''].filter(Boolean).join(' · ');
+ if(softwareUpdateTarget&&state==='attention'){
+  softwareUpdateTarget='';
+  showAppToast({title:'Update did not complete',body:status.message||'The source checkout needs attention.',kind:'warn',sticky:true});
+ }
+ const showNotice=Boolean(
+  (status.available&&status.can_update)
+  || (softwareUpdateTarget&&status.updating)
+ );
+ $('update-notice').hidden=!showNotice;
+ $('update-notice').disabled=!!status.updating;
+ $('update-notice').textContent=status.updating?'Updating…':'New update available';
+ document.body.classList.toggle('updateReady',showNotice);
+ if(softwareUpdateTarget&&['updated','current'].includes(state)
+    &&status.current_revision===softwareUpdateTarget){
+  try{localStorage.setItem('tm_update_completed',softwareUpdateTarget);}catch(error){}
+  softwareUpdateTarget='';
+  setTimeout(()=>location.reload(),350);
+  return;
+ }
+ if(status.checking||status.updating||softwareUpdateTarget)scheduleSoftwareUpdatePoll();
+ const completed=localStorage.getItem('tm_update_completed')||'';
+ if(completed&&status.current_revision===completed){
+  localStorage.removeItem('tm_update_completed');
+  showAppToast({title:'Token Meter updated',body:`Now running ${completed.slice(0,12)}.`,kind:'good',sticky:true});
+ }
+}
+async function refreshSoftwareUpdateStatus(){
+ if(softwareUpdateRequestBusy)return;
+ softwareUpdateRequestBusy=true;
+ try{
+  const response=await fetch('/updates/status',{cache:'no-store'});
+  if(!response.ok)throw new Error(`Update status failed (${response.status}).`);
+  renderSoftwareUpdate(await response.json());
+ }catch(error){
+  if(softwareUpdateTarget)scheduleSoftwareUpdatePoll(2000);
+ }finally{softwareUpdateRequestBusy=false;}
+}
+async function postSoftwareUpdate(path,payload={}){
+ const token=softwareUpdateActionToken();
+ if(!token)throw new Error('Update controls are not ready yet. Wait a moment and try again.');
+ const response=await fetch(path,{
+  method:'POST',
+  headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},
+  body:JSON.stringify(payload),
+ });
+ let result={};
+ try{result=await response.json();}catch(error){}
+ if(!response.ok||!result.ok)throw new Error(result.error||'Token Meter could not complete the update action.');
+ if(result.status)renderSoftwareUpdate(result.status);
+ return result;
+}
+async function saveSoftwareUpdatePreferences(event){
+ const enabled=$('update-enabled').checked;
+ if(!enabled)$('update-auto-install').checked=false;
+ const autoInstall=enabled&&$('update-auto-install').checked;
+ $('update-enabled').disabled=true;
+ $('update-auto-install').disabled=true;
+ try{
+  const result=await postSoftwareUpdate('/settings/updates',{enabled,auto_install:autoInstall});
+  renderSoftwareUpdate(result.status);
+  const changedAutoInstall=event.target.id==='update-auto-install';
+  showAppToast({
+   title:changedAutoInstall
+    ?(autoInstall?'Automatic installation enabled':'Automatic installation disabled')
+    :(enabled?'Update checks enabled':'Update checks disabled'),
+   body:changedAutoInstall
+    ?(autoInstall?'Safe main updates will install automatically.':'Checks continue; available updates stay visible in the menu bar.')
+    :(enabled?'Token Meter is checking the tracked main branch now.':'Update checks and automatic installation are off.'),
+   kind:enabled?'good':'neutral',
+  });
+ }catch(error){
+  renderSoftwareUpdate(SOFTWARE_UPDATE);
+  showAppToast({title:'Update setting could not be saved',body:error.message||String(error),kind:'warn',sticky:true});
+ }finally{
+  $('update-enabled').disabled=false;
+  $('update-auto-install').disabled=!$('update-enabled').checked;
+ }
+}
+$('update-enabled').onchange=saveSoftwareUpdatePreferences;
+let menubarSettingsBusy=false;
+function renderMenubarSettings(settings){
+ if(!settings||menubarSettingsBusy)return;
+ $('menubar-cache-timer').querySelectorAll('button').forEach(button=>{
+  button.setAttribute('aria-pressed',String(button.dataset.cacheTimer===settings.cache_timer));
+ });
+}
+$('menubar-cache-timer').onclick=async event=>{
+ const button=event.target.closest('button[data-cache-timer]');
+ if(!button||menubarSettingsBusy)return;
+ const status=$('menubar-settings-status'),token=softwareUpdateActionToken();
+ if(!token){status.textContent='Settings are not ready yet. Wait a moment and try again.';return;}
+ menubarSettingsBusy=true;status.textContent='Saving…';
+ try{
+  const response=await fetch('/settings/menubar',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({cache_timer:button.dataset.cacheTimer})});
+  let result={};try{result=await response.json();}catch(error){}
+  if(!response.ok||!result.ok)throw new Error(result.error||'Token Meter could not save the menu bar setting.');
+  menubarSettingsBusy=false;renderMenubarSettings(result.menubar);
+  status.textContent='Saved';
+ }catch(error){
+  menubarSettingsBusy=false;status.textContent=error.message;
+ }
+};
+$('update-auto-install').onchange=saveSoftwareUpdatePreferences;
+$('update-check').onclick=async()=>{
+ const button=$('update-check'),original=button.textContent;
+ button.disabled=true;button.textContent='Checking…';
+ try{
+  await postSoftwareUpdate('/updates/check');
+  scheduleSoftwareUpdatePoll();
+ }catch(error){
+  showAppToast({title:'Update check failed',body:error.message||String(error),kind:'warn',sticky:true});
+  button.disabled=false;button.textContent=original;
+ }
+};
+$('update-notice').onclick=async()=>{
+ if(!SOFTWARE_UPDATE?.can_update||SOFTWARE_UPDATE.updating)return;
+ softwareUpdateTarget=SOFTWARE_UPDATE.latest_revision||'';
+ $('update-notice').disabled=true;$('update-notice').textContent='Starting update…';
+ try{
+  const result=await postSoftwareUpdate('/updates/install');
+  renderSoftwareUpdate(result.status);
+  scheduleSoftwareUpdatePoll();
+ }catch(error){
+  softwareUpdateTarget='';
+  $('update-notice').disabled=false;$('update-notice').textContent='New update available';
+  showAppToast({title:'Update could not start',body:error.message||String(error),kind:'warn',sticky:true});
+ }
+};
+const MODEL_PRICE_FIELDS=['input','output','cache_write','cache_read'];
+let modelPricingState=null,modelPricingSelected=new Set(),modelPricingTab='all';
+function modelPriceKey(provider,model){return `${provider}:${model}`;}
+function renderModelPriceTabs(){
+ const rows=modelPricingState?.models||[],providers=new Map();
+ for(const row of rows){
+  const entry=providers.get(row.provider)||{label:row.provider_label||row.provider,count:0,edited:false};
+  entry.count++;if(modelPricingSelected.has(modelPriceKey(row.provider,row.model)))entry.edited=true;
+  providers.set(row.provider,entry);
+ }
+ if(modelPricingTab!=='all'&&!providers.has(modelPricingTab))modelPricingTab='all';
+ const tabs=[['all',{label:'All',count:rows.length,edited:modelPricingSelected.size>0}],...providers];
+ $('model-price-tabs').innerHTML=rows.length?tabs.map(([id,tab])=>{
+  const on=id===modelPricingTab;
+  return `<button type=button role=tab id="model-price-tab-${esc(id)}" aria-selected=${on} aria-controls=model-price-table-wrap tabindex=${on?0:-1} data-model-price-tab="${esc(id)}">${esc(tab.label)}<span class=count>${f(tab.count)}</span>${tab.edited?'<span class=edited title="Unsaved edits" aria-label="Unsaved edits"></span>':''}</button>`;
+ }).join(''):'';
+ $('model-price-tabs').querySelectorAll('[data-model-price-tab]').forEach(button=>{
+  button.onclick=()=>selectModelPriceTab(button.dataset.modelPriceTab);
+  button.onkeydown=event=>{
+   const buttons=[...$('model-price-tabs').querySelectorAll('[data-model-price-tab]')],index=buttons.indexOf(button);
+   const next=event.key==='ArrowRight'?index+1:event.key==='ArrowLeft'?index-1:event.key==='Home'?0:event.key==='End'?buttons.length-1:null;
+   if(next===null)return;
+   event.preventDefault();
+   selectModelPriceTab(buttons[(next+buttons.length)%buttons.length].dataset.modelPriceTab);
+  };
+ });
+ applyModelPriceTab();
+}
+function applyModelPriceTab(){
+ for(const root of $('model-pricing-rows').querySelectorAll('[data-model-price-key]'))root.hidden=modelPricingTab!=='all'&&root.dataset.modelPriceProvider!==modelPricingTab;
+ const active=$('model-price-tabs').querySelector('[aria-selected=true]');
+ if(active)$('model-price-table-wrap').setAttribute('aria-labelledby',active.id);
+}
+function selectModelPriceTab(tab){
+ if(tab===modelPricingTab)return;
+ const hadFocus=$('model-price-tabs').contains(document.activeElement);
+ modelPricingTab=tab;
+ renderModelPriceTabs();
+ $('model-price-table-wrap').scrollTop=0;
+ if(hadFocus)$('model-price-tabs').querySelector('[aria-selected=true]')?.focus();
+}
+function modelPriceSelectionState(count){
+ const selected=Math.max(0,Number(count)||0),noun=selected===1?'model':'models';
+ return {summary:selected?`${selected} ${noun} selected`:'No models selected',button:selected?`Save ${selected} ${noun}`:'Save models',disabled:selected===0};
+}
+function modelPriceScope(){return document.querySelector('input[name="model-price-scope"]:checked')?.value||'from_now';}
+function modelPriceAllHistory(){return modelPriceScope()==='all_history';}
+function modelPriceEffectiveFrom(){
+ if(modelPriceScope()!=='from_date')return null;
+ const raw=$('model-price-effective-from').value;
+ if(!raw)throw new Error('Choose the date when these prices should start.');
+ const timestamp=new Date(raw).getTime()/1000;
+ if(!Number.isFinite(timestamp))throw new Error('Choose a valid effective date and time.');
+ if(timestamp>Date.now()/1000+60)throw new Error('The effective date cannot be in the future.');
+ return timestamp;
+}
+function modelPriceScopePayload(scopeOverride=null){
+ const scope=scopeOverride||modelPriceScope(),payload={apply_to_all_history:scope==='all_history'};
+ if(scope==='from_date')payload.effective_from=modelPriceEffectiveFrom();
+ return payload;
+}
+function modelPriceSource(row){
+ const source=row.source||'built-in',periods=Number(row.periods||0);
+ const label=source==='built-in'?'':source;
+ if(!periods)return label;
+ if(row.effective_from==null)return label?`${label} · all history`:'all history';
+ const date=new Date(Number(row.effective_from)*1000);
+ if(Number.isNaN(date.getTime()))return label;
+ const effective=`from ${date.toLocaleString([], {dateStyle:'medium',timeStyle:'short'})}`;
+ return label?`${label} · ${effective}`:effective;
+}
+function updateModelPriceScope(){
+ const scope=modelPriceScope(),history=scope==='all_history',fromDate=scope==='from_date';
+ $('model-price-scope').classList.toggle('history',history);
+ $('model-price-effective-from').disabled=!fromDate;
+ $('model-price-scope-note').textContent=history?'All matching session estimates will be recalculated.':(fromDate?'Choose the date; session estimates from then are recalculated and older session estimates keep their prior prices.':'Changes start when you save; older session estimates keep their prior prices.');
+}
+function confirmModelPriceHistory(action,model){
+ if(modelPriceAllHistory())return confirm(`${action} for ${model} across all recorded history? Older cost estimates will be recalculated and the previous price timeline will be replaced.`);
+ const effective=modelPriceEffectiveFrom();
+ if(effective==null)return true;
+ const when=new Date(effective*1000).toLocaleString([], {dateStyle:'medium',timeStyle:'short'});
+ return confirm(`${action} for ${model} from ${when}? Sessions at or after that time will be recalculated; earlier sessions keep their prices.`);
+}
+function modelPriceNumber(value){
+ const number=Number(value);
+ return Number.isFinite(number)?String(number):'0';
+}
+function modelPriceValues(root){
+ const prices={};
+ for(const field of MODEL_PRICE_FIELDS){
+  const input=root.querySelector(`[data-price-field="${field}"]`);
+  const value=Number(input?.value);
+  if(!input||input.value.trim()===''||!Number.isFinite(value)||value<0)throw new Error('Enter a non-negative number for every price.');
+  prices[field]=value;
+ }
+ return prices;
+}
+function modelPriceRowForRoot(root){
+ const key=root?.dataset.modelPriceKey||'';
+ return (modelPricingState?.models||[]).find(row=>modelPriceKey(row.provider,row.model)===key);
+}
+function restoreModelPriceRow(root){
+ const row=modelPriceRowForRoot(root),prices=row?.prices||{};
+ if(!row)return;
+ for(const field of MODEL_PRICE_FIELDS){
+  const input=root.querySelector(`[data-price-field="${field}"]`);
+  if(input)input.value=modelPriceNumber(prices[field]);
+ }
+}
+function setModelPriceSelected(root,selected,restore=true){
+ const key=root?.dataset.modelPriceKey;
+ if(!key)return;
+ if(selected)modelPricingSelected.add(key);else{
+  modelPricingSelected.delete(key);
+  if(restore)restoreModelPriceRow(root);
+ }
+ root.classList.toggle('selected',selected);
+ const checkbox=root.querySelector('[data-model-price-select]');
+ if(checkbox)checkbox.checked=selected;
+ updateModelPriceSelectionState();
+}
+function updateModelPriceSelectionState(){
+ const state=modelPriceSelectionState(modelPricingSelected.size),button=$('model-price-save-changes');
+ $('model-price-selection-count').textContent=state.summary;
+ button.disabled=state.disabled;button.textContent=state.button;
+ renderModelPriceTabs();
+}
+function renderModelPricing(pricing,force=false){
+ if(!pricing)return;
+ modelPricingState=pricing;
+ $('model-pricing-reviewed').textContent=pricing.reviewed_on||'not recorded';
+ const sources=Array.isArray(pricing.sources)?pricing.sources:[];
+ $('model-pricing-sources').innerHTML=sources.length?sources.map(source=>`<a href="${esc(source.url||'#')}" target=_blank rel="noreferrer">${esc(source.label||source.provider||'Source')}</a>`).join(' · '):'No source links available';
+ const custom=Number(pricing.custom_models||0),retired=Number(pricing.retired_custom_models||0),overrides=Number(pricing.overrides||0);
+ const badge=$('model-pricing-badge'),hasCustomPricing=!!(custom||overrides||retired);
+ badge.hidden=!hasCustomPricing;
+ badge.textContent=hasCustomPricing?`${f(custom)} custom · ${f(overrides)} ${countWord(overrides,'override')}${retired?` · ${f(retired)} retired`:''}`:'';
+ if(modelPricingSelected.size&&!force)return;
+ const drafts=new Map();
+ if(force)for(const root of $('model-pricing-rows').querySelectorAll('[data-model-price-key]')){
+  if(modelPricingSelected.has(root.dataset.modelPriceKey)){
+   try{drafts.set(root.dataset.modelPriceKey,modelPriceValues(root));}catch(error){}
+  }
+ }
+ const rows=pricing.models||[];
+ $('model-pricing-rows').innerHTML=rows.length?rows.map(row=>{
+  const prices=row.prices||{},key=modelPriceKey(row.provider,row.model),sourceLabel=modelPriceSource(row),selected=modelPricingSelected.has(key);
+  const lifecycleAction=modelPriceLifecycle(row),lifecycle=lifecycleAction?`<button class=modelPriceLifecycle data-model-price-lifecycle type=button>${lifecycleAction.label}</button>`:'';
+  const fieldLabels={input:'Input',output:'Output',cache_write:'Cache write',cache_read:'Cached input'};
+  return `<tr${selected?' class=selected':''} data-model-price-key="${esc(key)}" data-model-price-provider="${esc(row.provider)}"><td class=modelPriceSelectCell data-label="Select"><input data-model-price-select type=checkbox${selected?' checked':''} aria-label="${esc(`Select ${row.model} for price update`)}"></td><td data-label="Provider"><span class="badge ${esc(row.provider)}">${esc(row.provider_label||row.provider)}</span></td><td data-label="Model id"><div class=modelPriceModel><code>${esc(row.model)}</code>${sourceLabel?`<span class=modelPriceSource>${esc(sourceLabel)}</span>`:''}${lifecycle}</div></td>${MODEL_PRICE_FIELDS.map(field=>`<td class=num data-label="${fieldLabels[field]}"><input class=modelPriceInput data-price-field="${field}" type=number min=0 max=1000000 step=any value="${esc(modelPriceNumber(prices[field]))}" aria-label="${esc(`${row.model} ${field.replace('_',' ')} price`)}"></td>`).join('')}</tr>`;
+ }).join(''):'<tr><td colspan=7 class=modelPricingEmpty>No model prices configured.</td></tr>';
+ for(const root of $('model-pricing-rows').querySelectorAll('[data-model-price-key]')){
+  const draft=drafts.get(root.dataset.modelPriceKey);
+  if(draft)for(const field of MODEL_PRICE_FIELDS)root.querySelector(`[data-price-field="${field}"]`).value=modelPriceNumber(draft[field]);
+ }
+ $('model-pricing-rows').querySelectorAll('.modelPriceInput').forEach(input=>input.addEventListener('input',()=>{
+  const root=input.closest('[data-model-price-key]');setModelPriceSelected(root,true,false);$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent='Unsaved price changes';
+ }));
+ $('model-pricing-rows').querySelectorAll('[data-model-price-select]').forEach(checkbox=>checkbox.addEventListener('change',()=>{
+  const root=checkbox.closest('[data-model-price-key]');setModelPriceSelected(root,checkbox.checked,true);
+  $('model-pricing-status').className=modelPricingSelected.size?'settingsStatus warn':'settingsStatus';$('model-pricing-status').textContent=modelPricingSelected.size?'Selected model prices are ready to edit.':'';
+ }));
+ $('model-pricing-rows').querySelectorAll('[data-model-price-lifecycle]').forEach(button=>button.onclick=()=>applyModelPriceLifecycle(button));
+ updateModelPriceSelectionState();
+ updateModelPriceScope();
+}
+async function requestModelPrice(payload,scopeOverride=null){
+ const token=agentActionToken();
+ if(!token)throw new Error('Settings are not ready yet. Wait for live state and try again.');
+ const response=await fetch('/settings/model-pricing',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({...payload,...modelPriceScopePayload(scopeOverride)})});
+ const result=await response.json();
+ if(!response.ok||!result.ok)throw new Error(result.error||'Could not save model pricing.');
+ if(LATEST?.xsession)LATEST.xsession.model_pricing=result.model_pricing;
+ return result;
+}
+function modelPriceRowFor(button){
+ return modelPriceRowForRoot(button.closest('[data-model-price-key]'));
+}
+async function saveModelPriceChanges(){
+ const button=$('model-price-save-changes'),keys=[...modelPricingSelected];
+ if(!keys.length)return;
+ try{
+  const changes=keys.map(key=>{
+   const row=(modelPricingState?.models||[]).find(item=>modelPriceKey(item.provider,item.model)===key),root=[...$('model-pricing-rows').querySelectorAll('[data-model-price-key]')].find(item=>item.dataset.modelPriceKey===key);
+   if(!row||!root)throw new Error('Reload Settings and try saving these model prices again.');
+   return {provider:row.provider,model:row.model,prices:modelPriceValues(root)};
+  });
+  if(!confirmModelPriceHistory(`Apply ${changes.length} price ${countWord(changes.length,'change')}`,'the selected models'))return;
+  const original=button.textContent;button.disabled=true;button.textContent='Saving…';
+  try{
+   const result=await requestModelPrice({changes});
+   keys.forEach(key=>modelPricingSelected.delete(key));
+   renderModelPricing(result.model_pricing,true);
+   $('model-pricing-status').className='settingsStatus good';
+   $('model-pricing-status').textContent=result.effective_scope==='all_history'?'Saved · matching session estimates recalculated':(result.effective_scope==='selected_time'?'Saved from the selected date':'Saved from now');
+   showAppToast({title:'Model prices updated',body:`Saved ${changes.length} ${countWord(changes.length,'change')}.`,kind:'good'});
+   await refreshLiveState();
+  }finally{button.textContent=original;updateModelPriceSelectionState();}
+ }catch(error){$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent=error.message||String(error);showAppToast({title:'Model pricing could not be saved',body:error.message||String(error),kind:'warn',sticky:true});}
+}
+function modelPriceLifecycle(row){
+ if(row.custom)return {label:'Remove custom model',scope:row.active?null:'all_history'};
+ if(row.overridden||Number(row.periods||0)>0)return {label:'Restore built-in price',scope:null};
+ return null;
+}
+async function applyModelPriceLifecycle(button){
+ const row=modelPriceRowFor(button),action=row&&modelPriceLifecycle(row);
+ if(!action)return;
+ const scopeOverride=action.scope;
+ if(!row.custom&&!row.overridden&&modelPriceScope()==='from_now'){
+  // Already built-in from now; only All history clears the saved periods.
+  const guidance=`${row.model} already uses built-in prices from now. Choose All history, then restore to clear its earlier saved prices.`;
+  $('model-pricing-status').className='settingsStatus';
+  $('model-pricing-status').textContent=guidance;
+  showAppToast({title:'Already on built-in prices',body:guidance});
+  return;
+ }
+ if(row.custom&&!row.active){if(!confirm(`Delete ${row.model} from all saved pricing history?`))return;}
+ else if(!confirmModelPriceHistory(row.custom?'Retire this custom price':'Restore built-in pricing',row.model))return;
+ const original=button.textContent;button.disabled=true;button.textContent=row.custom?'Removing…':'Restoring…';
+ try{
+  const result=await requestModelPrice({provider:row.provider,model:row.model,remove:true},scopeOverride);
+  modelPricingSelected.delete(modelPriceKey(row.provider,row.model));
+  renderModelPricing(result.model_pricing,true);
+  $('model-pricing-status').className='settingsStatus good';$('model-pricing-status').textContent=row.custom?'Custom price updated.':'Default price restored.';
+  showAppToast({title:row.custom?'Custom price changed':'Default price restored',body:result.effective_scope==='all_history'?(row.custom?`${row.model} was removed from all pricing history.`:`${row.model} uses built-in prices across all history.`):(result.effective_scope==='selected_time'?(row.custom?`${row.model} is retired from the selected time; earlier sessions retain its price.`:`${row.model} uses built-in pricing from the selected time.`):(row.custom?`${row.model} is retired from now; older sessions retain its price.`:`${row.model} uses Token Meter’s built-in price from now.`)),kind:'good'});
+  await refreshLiveState();
+ }catch(error){$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent=error.message||String(error);showAppToast({title:'Model pricing could not be changed',body:error.message||String(error),kind:'warn',sticky:true});}
+ finally{button.disabled=false;button.textContent=original;}
+}
+$('model-price-add-form').addEventListener('submit',async event=>{
+ event.preventDefault();
+ const button=$('model-price-add'),model=$('model-price-model').value.trim();
+ try{
+  const root=event.currentTarget,prices={
+   input:Number($('model-price-input').value),output:Number($('model-price-output').value),
+   cache_write:Number($('model-price-cache-write').value),cache_read:Number($('model-price-cache-read').value),
+ };
+ for(const [field,value] of Object.entries(prices))if(root.querySelector(`#model-price-${field.replaceAll('_','-')}`)?.value.trim()===''||!Number.isFinite(value)||value<0)throw new Error('Enter a non-negative number for every price.');
+  if(!confirmModelPriceHistory('Add this custom price',model))return;
+  const original=button.textContent;button.disabled=true;button.textContent='Adding…';
+  let result;
+  try{result=await requestModelPrice({provider:$('model-price-provider').value,model,prices});}
+  finally{button.disabled=false;button.textContent=original;}
+  renderModelPricing(result.model_pricing,true);
+  $('model-price-model').value='';$('model-price-input').value='';$('model-price-output').value='';$('model-price-cache-write').value='0';$('model-price-cache-read').value='0';
+  showAppToast({title:'Model price added',body:result.effective_scope==='all_history'?`${model} now prices all matching history.`:(result.effective_scope==='selected_time'?`${model} is priced from the selected time; earlier sessions are unchanged.`:`${model} is priced from now; older sessions are unchanged.`),kind:'good'});
+  await refreshLiveState();
+ }catch(error){$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent=error.message||String(error);showAppToast({title:'Model could not be added',body:error.message||String(error),kind:'warn',sticky:true});}
+});
+document.querySelectorAll('input[name="model-price-scope"]').forEach(input=>input.addEventListener('change',updateModelPriceScope));
+$('model-price-save-changes').addEventListener('click',saveModelPriceChanges);
+updateModelPriceScope();
diff --git a/dashboard/js/router.js b/dashboard/js/router.js
new file mode 100644
index 00000000..f2c0df61
--- /dev/null
+++ b/dashboard/js/router.js
@@ -0,0 +1,187 @@
+function applyHashRoute(){
+ const h=(location.hash||'').replace(/^#/,'');
+ // Back on Learn by any route (button, browser Back, or the nav) means the way back is used up.
+ if(tourReturn?.host==='learn'&&(h==='learn'||h==='learn-agent-access'))showTourReturn(null);
+ const panel=PANEL_ALIAS[h]||h;
+ const legacyGlobal=h==='global'||h==='global-logs'||/^global-(overview|evidence)$/.test(h);
+ if(h==='subagents'||h==='sessions-subagents'){
+  if(pinned){sessionRequest++;pinned=null;CURRENT=LATEST;}
+  mountSubagentExplorer(h==='subagents'?'roles':'sessions');
+  if(h==='sessions-subagents'){
+   setSessionScope('subagents');
+   showTab('session');
+   showCurrentPanel('sessions');
+  }else showTab('subagents');
+  if(LATEST)renderSubagentExplorer(LATEST.xsession?.agent_usage);
+  return;
+ }
+ if(h==='sessions'||h==='sessions-all'||h==='sessions-compare'||h==='current-sessions'){
+ const scope=h==='sessions-all'?'all':h==='sessions-compare'?'compare':'current',route=sessionScopeRoute(scope);
+ if((routedSessionId()||h==='current-sessions')&&history.replaceState)history.replaceState(null,'',`/#${route}`);
+ if(pinned){sessionRequest++;pinned=null;CURRENT=LATEST;}
+ setSessionScope(scope);
+ showTab('session');
+ showCurrentPanel('sessions');
+ renderCurrentSessions();
+ return;
+}
+if(h==='logs'||legacyGlobal){
+ if(history.replaceState)history.replaceState(null,'','/#sessions-all');
+ setSessionScope('all');
+ showTab('session');
+ showCurrentPanel('sessions');
+ return;
+ }
+	 if(h==='daily')setHashRoute('spend',{replace:true,apply:false});
+	 if(h==='settings-budgets'||h==='budgets')setHashRoute('spend-budgets',{replace:true,apply:false});
+	 if(h==='spend'||h==='daily'||h==='spend-budgets'||h==='spend-discounts'||h==='settings-budgets'||h==='budgets'){
+  showTab('spend');
+  if(LATEST)renderSpendView(LATEST.xsession);
+  if(h==='spend-discounts')openDiscounts();
+  else if(h!=='spend'&&h!=='daily'){
+   setBudgetEditorOpen(true);
+   requestAnimationFrame(()=>$('spend-budgets').scrollIntoView({block:'start'}));
+  }
+  loadGoals();
+	  return;
+	 }
+ if(h==='preview-settings'){
+  setHashRoute('settings',{replace:true,apply:false});
+  showTab('settings');
+  if(LATEST)renderSettings(LATEST.xsession);
+  loadAgentAccess();
+  return;
+ }
+ const legacyCurrentRoutes={preview:'summary','preview-run':'summary','preview-activity':'summary','preview-tools':'summary'};
+ if(legacyCurrentRoutes[h]){
+  const canonical=legacyCurrentRoutes[h];
+  setHashRoute(canonical,{replace:true,apply:false});
+  showTab('session');
+  showCurrentPanel(canonical);
+  return;
+ }
+	 if(h==='models'||h==='frustration'){
+	  if(h==='frustration')setHashRoute('models',{replace:true,apply:false});
+	  showTab('models');
+	  if(LATEST)renderActiveModelStats();
+	  return;
+	 }
+ if(h==='goals')setHashRoute('efficiency-goals',{replace:true,apply:false});
+ if(h.startsWith('efficiency-goals/')){
+  showTab('efficiency');
+  if(LATEST)renderActiveEfficiency();
+  loadGoalDetail(decodeURIComponent(h.slice('efficiency-goals/'.length)));
+  return;
+ }
+ if(h==='goals'||h==='efficiency-goals'){
+  showGoalDetail(false);
+  showTab('efficiency');
+  if(LATEST)renderActiveEfficiency();
+  loadGoals().then(()=>requestAnimationFrame(()=>$('efficiency-goals').scrollIntoView({block:'start'})));
+  return;
+ }
+ if(h==='efficiency'){
+  if(routedSessionId()){
+   showTab('session');
+   showCurrentPanel('summary');
+  }else{
+   showGoalDetail(false);
+   showTab('efficiency');
+   if(LATEST)renderActiveEfficiency();
+   loadGoals();
+  }
+  return;
+ }
+ if(h==='work'){
+  if(workSupported===false){location.hash='sessions';return;}
+  showTab('work');
+  loadWork();
+  loadGoals();
+  return;
+ }
+ if(h.startsWith('work-sessions')||h.startsWith('sessions-all?work=')){
+  // The sessions behind a Work cell, shown in All sessions with a removable Work filter.
+  applyWorkSessionFilter(new URLSearchParams(h.split('?')[1]||''));
+  return;
+ }
+ if(h==='delivery')setHashRoute('git',{replace:true,apply:false});
+ if(h==='git'||h==='delivery'){
+  showTab('git');
+  loadDelivery();
+  loadGoals();
+  return;
+ }
+ if(h==='capabilities'){
+  showTab('capabilities');
+  if(LATEST)renderCapabilities(LATEST.xsession?.capabilities);
+  return;
+ }
+ if(h==='learn'||h==='learn-agent-access'){
+  showTab('learn');
+  if(h==='learn-agent-access')showDeckSlide('learn',DECK_SLIDES.findIndex(slide=>slide.id==='agent'),{animate:false});
+  else renderLearn(LATEST);
+  return;
+ }
+ if(h==='settings-agent-defaults'){
+  setHashRoute('settings',{replace:true,apply:false});
+  showTab('settings');
+  if(LATEST)renderSettings(LATEST.xsession);
+  loadAgentAccess();
+  return;
+ }
+ if(h==='settings'||h==='model-pricing'||h==='settings-updates'||h==='settings-appearance'||h==='settings-work-insights'){
+  showTab('settings');
+  if(LATEST)renderSettings(LATEST.xsession);
+  const card={'model-pricing':'model-pricing-settings','settings-updates':'update-settings','settings-work-insights':'work-insights-settings','settings-appearance':'appearance-settings'}[h];
+  if(card)scrollToSettingsCard(card);
+  else pendingSettingsScroll=null; // plain #settings: drop a scroll an earlier link left waiting
+  loadWorkSettings();
+  loadAgentAccess();
+  return;
+ }
+if(!h||h==='session'){
+  setSessionScope('current');
+  showTab('session');
+  if(routedSessionId()){
+   showCurrentPanel('summary');
+   setHashRoute('summary',{replace:true,apply:false});
+  }else{
+   showCurrentPanel('sessions');
+   setHashRoute('sessions',{replace:true,apply:false});
+  }
+  return;
+ }
+ if(PANEL_KEYS.includes(panel)){
+  showTab('session');
+  showCurrentPanel(panel);
+  if(h!==panel)setHashRoute(panel,{replace:true,apply:false});
+ }
+else{
+  setSessionScope('current');
+ showTab('session');
+ showCurrentPanel('sessions');
+ setHashRoute('sessions',{replace:true,apply:false});
+ }
+}
+function applyLocationRoute(){
+ applyHashRoute();
+ const id=routedSessionId();
+ if(id){sessionReturnScope=normalizeSessionScope(history.state?.sessionScope);selectSession(id,{updateUrl:false,show:$('view-session').classList.contains('on'),returnScope:sessionReturnScope});return;}
+ if(pinned){
+  pinned=null;
+  if(LATEST&&$('view-session').classList.contains('on'))renderSession(LATEST);
+ }
+}
+function mountSubagentExplorer(destination){
+ const roles=destination==='roles',home=roles?$('subagent-page-home'):$('preview-surface-sessions'),explorer=$('subagent-explorer');
+ if(explorer.parentElement!==home)home.appendChild(explorer);
+ explorer.hidden=false;
+ explorer.setAttribute('role',roles?'region':'tabpanel');
+ if(roles){explorer.setAttribute('aria-label','Subagent roles');explorer.removeAttribute('aria-labelledby');}
+ else{explorer.removeAttribute('aria-label');explorer.setAttribute('aria-labelledby','session-scope-subagents');}
+ $('subagent-model-distribution').hidden=roles;
+}
+applyLocationRoute();
+window.addEventListener('hashchange',applyHashRoute);
+window.addEventListener('popstate',applyLocationRoute);
+
diff --git a/dashboard/js/session-budgets-filters.js b/dashboard/js/session-budgets-filters.js
new file mode 100644
index 00000000..a3ca37bf
--- /dev/null
+++ b/dashboard/js/session-budgets-filters.js
@@ -0,0 +1,459 @@
+// A subagent run spends against its root session's cap, which the server names.
+function budgetSessionKey(s){return String(s?.session_budget?.id||s?.source?.id||s?.session||'unknown');}
+function saveLegacySessionBudgets(){try{localStorage.setItem('tm_session_budgets',JSON.stringify(legacySessionBudgets));}catch(e){}}
+function sessionBudgetForSession(s){
+ const saved=parseFloat(s?.session_budget?.budget_usd);
+ if(Number.isFinite(saved)&&saved>0)return saved;
+ const legacy=parseFloat(legacySessionBudgets[budgetSessionKey(s)]);
+ if(Number.isFinite(legacy)&&legacy>0)return legacy;
+ return defaultSessionBudget;
+}
+function sessionBudgetSource(s){return s?.session_budget?.source||'legacy';}
+// A session family (root plus child runs) shares one cap; the server reports
+// its combined spend, which is a lower bound when any member lacks evidence.
+function sessionCapSpend(s){
+ const b=s?.session_budget;
+ if(b&&Object.prototype.hasOwnProperty.call(b,'cost_partial')){
+  const spend=Number(b.spend_usd),available=b.cost_available!==false&&b.spend_usd!=null&&Number.isFinite(spend);
+  return {available,spend:available?spend:0,partial:available&&!!b.cost_partial};
+ }
+ return {available:metricAvailable(s||{},'cost'),spend:Number(s?.total_cost)||0,partial:false};
+}
+async function persistSessionBudget(s,value,{migrating=false}={}){
+ const sessionId=budgetSessionKey(s),response=await fetch('/settings/session-budget',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':agentActionToken()},body:JSON.stringify({session_id:sessionId,budget_usd:value})});
+ const result=await response.json();
+ if(!response.ok||!result.ok)throw new Error(result.error||'Could not save session budget.');
+ if(s)s.session_budget=result.session_budget;
+ if(migrating){delete legacySessionBudgets[sessionId];saveLegacySessionBudgets();}
+ return result.session_budget;
+}
+function queueSessionBudget(s,value,{migrating=false}={}){
+ const sessionId=budgetSessionKey(s);
+ let entry=sessionBudgetWrites.get(sessionId);
+ if(!entry){entry={pending:false,saving:false,write:null,promise:null};sessionBudgetWrites.set(sessionId,entry);}
+ entry.write={value,migrating};entry.pending=true;
+ if(entry.saving)return entry.promise;
+ entry.saving=true;
+ entry.promise=(async()=>{
+  let finalError=null;
+  while(entry.pending){
+   const write=entry.write;entry.pending=false;
+   try{await persistSessionBudget(s,write.value,{migrating:write.migrating});finalError=null;}
+   catch(error){finalError=error;}
+  }
+  entry.saving=false;
+  if(sessionBudgetWrites.get(sessionId)===entry)sessionBudgetWrites.delete(sessionId);
+  if(finalError)throw finalError;
+ })();
+ return entry.promise;
+}
+function migrateLegacySessionBudget(s){
+ const sessionId=budgetSessionKey(s),legacy=parseFloat(legacySessionBudgets[sessionId]);
+ if(sessionBudgetSource(s)!=='default'||!Number.isFinite(legacy)||legacy<=0)return;
+ queueSessionBudget(s,legacy,{migrating:true}).then(()=>{if(s===CURRENT)syncSessionBudgetControls(sessionBudgetForSession(s),s);}).catch(()=>{});
+}
+function sessionBudgetSliderMax(s,value){
+ const reference=Math.max(defaultSessionBudget,Number(value)||0,sessionCapSpend(s).spend);
+ return Math.max(SESSION_BUDGET_SLIDER_BASE_MAX,Math.ceil(reference*1.5/10)*10);
+}
+function syncSessionBudgetControls(value,s=CURRENT){
+ const n=Math.max(0.5,Number(value)||defaultSessionBudget);
+ const slider=$('budget-slider'),max=sessionBudgetSliderMax(s,n);
+ $('budget').value=formatBudgetInput(n);
+ slider.max=String(max);
+ slider.value=String(Math.min(max,Math.max(SESSION_BUDGET_SLIDER_MIN,n)));
+ const min=Number(slider.min)||SESSION_BUDGET_SLIDER_MIN;
+ slider.style.setProperty('--budget-fill',`${Math.max(0,Math.min(100,100*(Number(slider.value)-min)/(max-min||1)))}%`);
+  $('budget-slider-min').textContent=money(min);
+ $('budget-slider-max').textContent=money(max);
+ const capSpend=sessionCapSpend(s);
+ $('session-budget-spend').textContent=capSpend.available?`Session spend ${capSpend.partial?'at least ':''}${money(capSpend.spend)}${s?.cost_approx?' est':''}`:'Session spend unavailable';
+}
+function loadBudgetForSession(s){
+ syncSessionBudgetControls(sessionBudgetForSession(s),s);
+ migrateLegacySessionBudget(s);
+}
+let sessionBudgetStatusTimer=0;
+function saveBudgetForSession(value){
+ if(!CURRENT)return;
+ const n=parseFloat(value);
+ if(!Number.isFinite(n)||n<=0)return;
+ syncSessionBudgetControls(n,CURRENT);
+ queueSessionBudget(CURRENT,n).then(()=>{const status=$('session-budget-status');status.textContent='Saved';clearTimeout(sessionBudgetStatusTimer);sessionBudgetStatusTimer=setTimeout(()=>{status.textContent='';},2500);}).catch(error=>showAppToast({title:'Session budget could not be saved',body:error.message||String(error),kind:'warn',sticky:true}));
+ return n;
+}
+$('budget').value=String(defaultSessionBudget);
+$('budget').addEventListener('input',()=>saveBudgetForSession($('budget').value));
+$('budget').addEventListener('change',()=>{if(CURRENT)renderSession(CURRENT);});
+$('budget-slider').addEventListener('input',()=>saveBudgetForSession($('budget-slider').value));
+$('budget-slider').addEventListener('change',()=>{if(CURRENT)renderSession(CURRENT);});
+function dollarInputValue(id,fallback=1e9){
+ const n=parseFloat($(id)?.value);
+ return Number.isFinite(n)&&n>0?n:fallback;
+}
+function formatBudgetInput(n){
+ n=Math.max(0,Math.ceil((n||0)*2)/2);
+ return Number.isInteger(n)?String(n):n.toFixed(1);
+}
+function setBudgetCap(n){
+ const value=formatBudgetInput(n);
+ return saveBudgetForSession(value)||parseFloat(value);
+}
+function extendBudget(){
+ if(!CURRENT) return;
+ const add=parseFloat($('budget-add').value);
+ if(!Number.isFinite(add)||add<=0){ setNotifyState('Enter a positive budget amount.'); return; }
+ const currentCost=sessionCapSpend(CURRENT).spend;
+ const currentCap=dollarInputValue('budget',0);
+ const next=setBudgetCap(Math.max(currentCap,currentCost)+add);
+ setNotifyState('Budget raised to '+money(next)+'.');
+ pushAppNotice('Budget updated','Session budget raised to '+money(next)+'.','neutral',{status:'Budget updated'});
+ renderSession(CURRENT);
+}
+$('budget-add-btn').onclick=extendBudget;
+$('budget-add').addEventListener('keydown',e=>{ if(e.key==='Enter') extendBudget(); });
+
+const CHART_SCALES=['linear','cumulative'];
+let chartScale=localStorage.getItem('tm_chart_scale')||'linear';
+if(!CHART_SCALES.includes(chartScale)){
+ chartScale='linear';
+ localStorage.setItem('tm_chart_scale',chartScale);
+}
+function paintScale(){
+ [...$('scale').querySelectorAll('button')].forEach(b=>{
+  const selected=b.dataset.scale===chartScale;
+  b.classList.toggle('on',selected);
+  b.setAttribute('aria-pressed',selected?'true':'false');
+ });
+}
+$('scale').onclick=e=>{ if(e.target.dataset.scale){ chartScale=e.target.dataset.scale; localStorage.setItem('tm_chart_scale',chartScale); paintScale(); if(CURRENT) drawIO(CURRENT.series||[]); } };
+paintScale();
+
+const CHART_MODES=['tokens','cost','context','tools','steps','wait'];
+const requestedChartMode=new URLSearchParams(location.search).get('chart');
+let chartMode=CHART_MODES.includes(requestedChartMode)?requestedChartMode:'tokens';
+if(chartMode==='cache'){
+ chartMode='tokens';
+ localStorage.setItem('tm_chart_mode',chartMode);
+}
+if(!CHART_MODES.includes(chartMode)){
+ chartMode='tokens';
+ localStorage.setItem('tm_chart_mode',chartMode);
+}
+function paintChartMode(){
+ [...$('chart-mode').querySelectorAll('button')].forEach(b=>b.classList.toggle('on',b.dataset.chart===chartMode));
+}
+$('chart-mode').onclick=e=>{ if(e.target.dataset.chart){ chartMode=e.target.dataset.chart; localStorage.setItem('tm_chart_mode',chartMode); paintChartMode(); if(CURRENT) drawIO(CURRENT.series||[]); } };
+paintChartMode();
+
+let globalSearch=localStorage.getItem('tm_global_search')||'';
+let globalSort=localStorage.getItem('tm_global_sort')||'recent';
+let globalApp=localStorage.getItem('tm_global_app')||'';
+if(['claude_code','claude_desktop'].includes(globalApp)){
+ globalApp='claude';
+ localStorage.setItem('tm_global_app',globalApp);
+}
+let globalProject=localStorage.getItem('tm_global_project')||'';
+let globalTime=localStorage.getItem('tm_global_time')||DEFAULT_TIME_FILTER_WINDOW;
+let globalShowChildren=localStorage.getItem('tm_global_children')==='show';
+let childSessionMap=new Map();
+let subagentUsageDimension=localStorage.getItem('tm_subagent_usage_dimension')||'runtimes';
+if(!['runtimes','models','depths','kinds','roles'].includes(subagentUsageDimension))subagentUsageDimension='runtimes';
+let subagentUsageSort=localStorage.getItem('tm_subagent_usage_sort')||'cost';
+if(!['cost','tokens','agents','output'].includes(subagentUsageSort))subagentUsageSort='cost';
+let subagentView=localStorage.getItem('tm_subagent_view')||'roles';
+if(!['issues','sessions','roles'].includes(subagentView))subagentView='roles';
+let subagentRoleChartMode=localStorage.getItem('tm_subagent_role_chart')||'average';
+if(!['spend','average','runs'].includes(subagentRoleChartMode))subagentRoleChartMode='average';
+let subagentFilters={
+ query:localStorage.getItem('tm_subagent_filter_search')||'',
+ role:localStorage.getItem('tm_subagent_filter_role')||'',
+ kind:localStorage.getItem('tm_subagent_filter_kind')||'',
+ runtime:localStorage.getItem('tm_subagent_filter_app')||'',
+ project:localStorage.getItem('tm_subagent_filter_project')||'',
+ model:localStorage.getItem('tm_subagent_filter_model')||'',
+ status:localStorage.getItem('tm_subagent_filter_status')||'all',
+ signal:localStorage.getItem('tm_subagent_filter_signal')||'all',
+ window:localStorage.getItem('tm_subagent_filter_time')||DEFAULT_TIME_FILTER_WINDOW,
+ sort:localStorage.getItem('tm_subagent_filter_sort')||'recent',
+};
+if(subagentFilters.sort==='elapsed'){
+ subagentFilters.sort='work';
+ localStorage.setItem('tm_subagent_filter_sort','work');
+}
+if(subagentFilters.window==='24h'){
+ subagentFilters.window='today';
+ localStorage.setItem('tm_subagent_filter_time','today');
+}
+if(!TIME_FILTER_WINDOWS.includes(subagentFilters.window)){
+ subagentFilters.window=DEFAULT_TIME_FILTER_WINDOW;
+ localStorage.removeItem('tm_subagent_filter_time');
+}
+const SUBAGENT_PAGE_SIZE=50;
+let subagentVisibleLimit=SUBAGENT_PAGE_SIZE,selectedSubagentId='',expandedSubagentRoot=null;
+let subagentAdvancedOpen=Boolean(subagentFilters.model||subagentFilters.status!=='all'||subagentFilters.signal!=='all'||subagentFilters.sort!=='recent');
+const logHtmlCache=new WeakMap();
+function setLogText(element,value){
+ value=String(value??'');
+ if(element.textContent!==value)element.textContent=value;
+}
+function setLogAttribute(element,name,value){
+ value=String(value??'');
+ if(element.getAttribute(name)!==value)element.setAttribute(name,value);
+}
+function setLogHtml(element,html){
+ if(logHtmlCache.get(element)===html)return;
+ element.innerHTML=html;
+ logHtmlCache.set(element,html);
+}
+function setLogSelectOptions(element,html,value){
+ setLogHtml(element,html);
+ if(element.value!==value)element.value=value;
+}
+async function loadAllSessions(){
+ if(allSessionsRequest)return allSessionsRequest;
+ allSessionsRequest=fetch('/logs',{cache:'no-store'}).then(response=>{
+  if(!response.ok)throw new Error(`All sessions request failed (${response.status}).`);
+  return response.json();
+ }).then(payload=>{
+  allSessionInventory=payload.sessions||[];
+  allSessionInventoryAt=Number(payload.generated_at||0);
+  if(LATEST&&$('view-session').classList.contains('on')&&sessionScope==='all')renderAllSessions(LATEST.xsession);
+  if(LATEST&&($('view-subagents').classList.contains('on')||($('view-session').classList.contains('on')&&sessionScope==='subagents')))renderSubagentExplorer(LATEST.xsession?.agent_usage);
+  return allSessionInventory;
+ }).catch(()=>allSessionInventory||[]).finally(()=>{allSessionsRequest=null;});
+ return allSessionsRequest;
+}
+function loadProjectModelFilterMap(){
+ const stored=localStorage.getItem('tm_model_project_filters');
+ if(!stored)return {};
+ try{
+  const parsed=JSON.parse(stored);
+  return parsed&&typeof parsed==='object'&&!Array.isArray(parsed)?parsed:{};
+ }catch(error){return {};}
+}
+function loadModelFilters(project=''){
+ if(project){
+  const scoped=loadProjectModelFilterMap(),values=scoped[project];
+  return Array.isArray(values)?[...new Set(values.filter(value=>typeof value==='string'&&value))]:[];
+ }
+ const stored=localStorage.getItem('tm_model_filters');
+ if(stored!==null){try{const parsed=JSON.parse(stored);if(Array.isArray(parsed))return [...new Set(parsed.filter(value=>typeof value==='string'&&value))];}catch(error){}}
+ const legacy=localStorage.getItem('tm_model_filter')||'';
+ return legacy?[legacy]:[];
+}
+function saveActiveModelFilters(){
+ if(!modelProject)localStorage.setItem('tm_model_filters',JSON.stringify(modelFilters));
+ else{
+  const scoped=loadProjectModelFilterMap();
+  scoped[modelProject]=modelFilters;
+  localStorage.setItem('tm_model_project_filters',JSON.stringify(scoped));
+ }
+ localStorage.removeItem('tm_model_filter');
+}
+let modelProject=localStorage.getItem('tm_model_project')||'';
+let modelFilters=loadModelFilters(modelProject);
+const MODEL_RANGES=['today','yesterday','7','30','90','month','last_month','all'];
+let modelRange=localStorage.getItem('tm_model_range')||'30';
+let modelTrendMetric=localStorage.getItem('tm_model_trend_metric')||'speed';
+const MODEL_MIX_KEYS=['cost','output','executions'];
+let modelMixMetric=localStorage.getItem('tm_model_mix_metric');if(!MODEL_MIX_KEYS.includes(modelMixMetric))modelMixMetric='cost';
+const MODEL_SORT_KEYS=['model','cost','cost_per_exec','cache','executions','output','speed','wait','pushback'];
+let modelSort=(()=>{try{const stored=JSON.parse(localStorage.getItem('tm_model_sort')||'null');if(stored&&MODEL_SORT_KEYS.includes(stored.key)&&['asc','desc'].includes(stored.direction))return {key:stored.key,direction:stored.direction};}catch(error){}return {key:'cost',direction:'desc'};})();
+const modelExpandedGroups=new Set();
+const MODEL_SPEED_MAX_SERIES=8;
+let modelSpeedSelection=(()=>{try{const stored=JSON.parse(localStorage.getItem('tm_model_speed_models')||'null');return Array.isArray(stored)?[...new Set(stored.filter(value=>typeof value==='string'&&value))].slice(0,MODEL_SPEED_MAX_SERIES):null;}catch(error){return null;}})();
+let activeModelStats=null,activeModelScope='',activeModelGeneration=0;
+let modelProjectRequest=0,modelProjectLoadingKey='';
+const modelProjectCache=new Map();
+const OTHER_LOCAL_SESSIONS_PROJECT='__other_local_sessions__';
+function projectFilterValue(value){
+ const project=String(value||'').trim().replaceAll('\\','/');
+ return project&&(project.startsWith('/')&&!project.startsWith('/private/')||project.startsWith('~/')&&!project.startsWith('~/.codex/')&&!project.startsWith('~/Library/')&&!project.startsWith('~/Documents/Codex/')||/^[A-Za-z]:\//.test(project))?project:OTHER_LOCAL_SESSIONS_PROJECT;
+}
+function projectFilterLabel(value){return value===OTHER_LOCAL_SESSIONS_PROJECT?'Other local sessions':value;}
+function storedModelFilterId(value){return typeof value==='string'&&value.length<=200&&!/[\\/\x00-\x1F\x7F]/.test(value)&&/^[^:]+::[^:]+(?:::[^:]+)?$/.test(value);}
+function migrateStoredProjectFilters(key,scoped=false){
+ const stored=localStorage.getItem(key);if(!stored)return scoped?undefined:'';
+ if(!scoped){const project=projectFilterValue(stored);if(project!==stored)localStorage.setItem(key,project);return project;}
+ let parsed={};try{const value=JSON.parse(stored);if(value&&typeof value==='object'&&!Array.isArray(value))parsed=value;}catch(error){return;}
+ const grouped={};Object.entries(parsed).forEach(([project,values])=>{if(!Array.isArray(values))return;const group=projectFilterValue(project);grouped[group]=[...new Set([...(grouped[group]||[]),...values.filter(storedModelFilterId)])];});
+ if(JSON.stringify(grouped)!==JSON.stringify(parsed))localStorage.setItem(key,JSON.stringify(grouped));
+}
+migrateStoredProjectFilters('tm_model_project_filters',true);
+migrateStoredProjectFilters('tm_efficiency_project_filters',true);
+globalProject=migrateStoredProjectFilters('tm_global_project');
+modelProject=migrateStoredProjectFilters('tm_model_project');
+modelFilters=loadModelFilters(modelProject);
+if(!['recent','cost','tokens','executions','wait'].includes(globalSort)) globalSort='recent';
+if(globalTime!==normalizeTimeFilterWindow(globalTime)){globalTime=normalizeTimeFilterWindow(globalTime);if(globalTime===DEFAULT_TIME_FILTER_WINDOW)localStorage.removeItem('tm_global_time');else localStorage.setItem('tm_global_time',globalTime);}
+if(!MODEL_RANGES.includes(modelRange)){modelRange='30';localStorage.setItem('tm_model_range',modelRange);}
+if(!['speed','wait','avg_input','avg_output'].includes(modelTrendMetric))modelTrendMetric='speed';
+$('m-range').value=modelRange;
+function modelScopeLabel(project=modelProject){return project?projectFilterLabel(project):'All projects';}
+function paintModelProjects(stats){
+ const projects=(stats?.projects||[]).filter(project=>typeof project==='string'&&project);
+ if(modelProject&&!projects.includes(modelProject)){
+  modelProject='';modelFilters=loadModelFilters('');
+  localStorage.removeItem('tm_model_project');
+ }
+ const projectSelect=$('m-project'),projectOptions='<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(projectFilterLabel(project))}</option>`).join('');
+ setLogSelectOptions(projectSelect,projectOptions,modelProject);
+ const projectTitle=stats?.projects_truncated?'Showing the first 500 discovered projects.':'';
+ if(projectSelect.title!==projectTitle)projectSelect.title=projectTitle;
+}
+function setModelProjectLoading(loading){
+ const projectSelect=$('m-project');
+ if(loading)projectSelect.setAttribute('aria-busy','true');
+ else projectSelect.removeAttribute('aria-busy');
+}
+function commitModelStats(stats,scope,generation){
+ activeModelStats=stats;activeModelScope=scope;activeModelGeneration=generation;
+ setModelProjectLoading(false);
+ $('m-project-status').textContent='';$('m-project-status').classList.remove('warn');
+ renderModelStats(stats);
+}
+async function renderActiveModelStats(){
+ if(!LATEST)return;
+ const machine=LATEST.xsession?.model_stats||{models:[],projects:[]},generation=Number(LATEST.xsession?.generated_at||0);
+ paintModelProjects(machine);
+ if(!modelProject){
+  modelProjectRequest++;modelProjectLoadingKey='';
+  setModelProjectLoading(false);
+  commitModelStats(machine,'',generation);
+  return;
+ }
+ const project=modelProject,key=`${generation}\n${project}`,cached=modelProjectCache.get(key);
+ if(cached){commitModelStats(cached,project,generation);return;}
+ if(modelProjectLoadingKey===key)return;
+ $('m-project-status').textContent='';
+ $('m-project-status').classList.remove('warn');
+ setModelProjectLoading(true);
+ modelProjectLoadingKey=key;
+ const request=++modelProjectRequest;
+ try{
+  const response=await fetch('/model-stats?project='+encodeURIComponent(project),{cache:'no-store'});
+  const payload=await response.json();
+  if(!response.ok||!payload.ok)throw new Error('Project model stats are unavailable.');
+  if(request!==modelProjectRequest||project!==modelProject)return;
+  const responseGeneration=Number(payload.generated_at||generation);
+  modelProjectCache.set(key,payload.model_stats);
+  modelProjectCache.set(`${responseGeneration}\n${project}`,payload.model_stats);
+  commitModelStats(payload.model_stats,project,responseGeneration);
+ }catch(error){
+  if(request!==modelProjectRequest||project!==modelProject)return;
+  $('m-project-status').textContent=`Could not load ${projectFilterLabel(project)}${activeModelStats?` · still showing ${modelScopeLabel(activeModelScope)}`:''}`;
+  $('m-project-status').classList.add('warn');
+ }finally{
+  if(modelProjectLoadingKey===key){modelProjectLoadingKey='';setModelProjectLoading(false);}
+ }
+}
+function rerenderActiveModelStats(){
+ if(activeModelStats&&activeModelScope===modelProject)renderModelStats(activeModelStats);
+ else renderActiveModelStats();
+}
+$('m-project').addEventListener('change',event=>{
+ modelProject=event.target.value;
+ modelFilters=loadModelFilters(modelProject);
+ if(modelProject)localStorage.setItem('tm_model_project',modelProject);else localStorage.removeItem('tm_model_project');
+ modelProjectRequest++;modelProjectLoadingKey='';
+ renderActiveModelStats();
+});
+$('m-model-options').addEventListener('change',event=>{
+ const input=event.target.closest('input[data-model-choice]');if(!input)return;
+ if(input.dataset.modelChoice==='all')modelFilters=[];
+ else if(input.checked)modelFilters=[...new Set([...modelFilters,input.value])];
+ else modelFilters=modelFilters.filter(name=>name!==input.value);
+ saveActiveModelFilters();
+ if(LATEST)rerenderActiveModelStats();
+});
+$('m-model-picker').addEventListener('keydown',event=>{if(event.key==='Escape')$('m-model-picker').removeAttribute('open');});
+document.addEventListener('pointerdown',event=>{const picker=$('m-model-picker');if(picker.open&&!picker.contains(event.target))picker.removeAttribute('open');});
+function positionModelPickerMenu(){
+ const picker=$('m-model-picker'),menu=$('m-model-options');
+ if(!picker.open){picker.classList.remove('opensUp');menu.style.maxHeight='';return;}
+ const trigger=picker.querySelector('summary'),rect=trigger.getBoundingClientRect(),margin=12;
+ const above=Math.max(0,rect.top-margin),below=Math.max(0,window.innerHeight-rect.bottom-margin),preferred=Math.min(360,menu.scrollHeight||360);
+ const opensUp=below<preferred&&above>below,available=opensUp?above:below;
+ picker.classList.toggle('opensUp',opensUp);
+ menu.style.maxHeight=`${Math.min(360,available)}px`;
+}
+$('m-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionModelPickerMenu));
+window.addEventListener('resize',()=>{if($('m-model-picker').open)positionModelPickerMenu();});
+$('m-mix-metric').onclick=event=>{const metric=event.target.closest('[data-model-mix]')?.dataset.modelMix;if(!MODEL_MIX_KEYS.includes(metric))return;modelMixMetric=metric;localStorage.setItem('tm_model_mix_metric',metric);if(LATEST)rerenderActiveModelStats();};
+$('m-table').querySelector('thead').onclick=event=>{const key=event.target.closest('[data-model-sort]')?.dataset.modelSort;if(!MODEL_SORT_KEYS.includes(key))return;modelSort=modelSort.key===key?{key,direction:modelSort.direction==='asc'?'desc':'asc'}:{key,direction:key==='model'?'asc':'desc'};localStorage.setItem('tm_model_sort',JSON.stringify(modelSort));if(LATEST)rerenderActiveModelStats();};
+$('m-table').querySelector('tbody').onclick=event=>{const button=event.target.closest('[data-model-expand]');if(!button)return;const key=button.dataset.modelExpand;if(modelExpandedGroups.has(key))modelExpandedGroups.delete(key);else modelExpandedGroups.add(key);if(LATEST)rerenderActiveModelStats();};
+$('m-spend').onclick=event=>{
+ if(event.target.closest('[data-model-clear]')){modelFilters=[];saveActiveModelFilters();if(LATEST)rerenderActiveModelStats();return;}
+ const ids=event.target.closest('[data-model-ids]')?.dataset.modelIds;if(!ids)return;
+ modelFilters=ids.split('\n').filter(Boolean);saveActiveModelFilters();if(LATEST)rerenderActiveModelStats();
+};
+$('m-speedchart-options').addEventListener('change',event=>{
+ const input=event.target.closest('input[data-model-speed-choice]');if(!input)return;
+ const boxes=[...$('m-speedchart-options').querySelectorAll('input[data-model-speed-choice]')],visible=new Set(boxes.map(box=>box.dataset.modelSpeedChoice));
+ const hidden=(modelSpeedSelection||[]).filter(key=>!visible.has(key)),checked=boxes.filter(box=>box.checked).map(box=>box.dataset.modelSpeedChoice);
+ const next=[...new Set([...checked,...hidden])].slice(0,MODEL_SPEED_MAX_SERIES);
+ modelSpeedSelection=checked.length?next:null;
+ if(modelSpeedSelection)localStorage.setItem('tm_model_speed_models',JSON.stringify(modelSpeedSelection));else localStorage.removeItem('tm_model_speed_models');
+ if(LATEST)rerenderActiveModelStats();
+});
+$('m-speedchart-reset').onclick=()=>{modelSpeedSelection=null;localStorage.removeItem('tm_model_speed_models');if(LATEST)rerenderActiveModelStats();};
+$('m-speedchart-picker').addEventListener('keydown',event=>{if(event.key==='Escape')$('m-speedchart-picker').removeAttribute('open');});
+document.addEventListener('pointerdown',event=>{const picker=$('m-speedchart-picker');if(picker.open&&!picker.contains(event.target))picker.removeAttribute('open');});
+$('m-diagnostics').open=localStorage.getItem('tm_model_diagnostics_open')==='1';
+$('m-diagnostics').addEventListener('toggle',()=>localStorage.setItem('tm_model_diagnostics_open',$('m-diagnostics').open?'1':'0'));
+$('m-range').addEventListener('change',e=>{modelRange=e.target.value;localStorage.setItem('tm_model_range',modelRange);if(LATEST)rerenderActiveModelStats();});
+$('m-metric').onclick=event=>{const metric=event.target.dataset.modelMetric;if(!metric)return;modelTrendMetric=metric;localStorage.setItem('tm_model_trend_metric',metric);if(LATEST)rerenderActiveModelStats();};
+function paintGlobalSort(){
+ [...$('g-sort').querySelectorAll('button')].forEach(b=>b.classList.toggle('on',b.dataset.gsort===globalSort));
+ const label={recent:'recent activity',cost:'highest cost',tokens:'most tokens',executions:'most executions'}[globalSort]||'recent activity';
+ $('g-hint').textContent=label;
+}
+function paintGlobalChildren(){
+ [...$('g-children').querySelectorAll('button')].forEach(b=>{
+  const on=(b.dataset.gchildren==='show')===globalShowChildren;
+  b.classList.toggle('on',on);
+  b.setAttribute('aria-pressed',on?'true':'false');
+ });
+}
+$('g-children').onclick=event=>{
+ const button=event.target.closest('[data-gchildren]');
+ if(!button)return;
+ globalShowChildren=button.dataset.gchildren==='show';
+ localStorage.setItem('tm_global_children',globalShowChildren?'show':'hide');
+ paintGlobalChildren();
+ if(LATEST)renderAllSessions(LATEST.xsession);
+};
+$('g-search').value=globalSearch;
+$('g-time').value=globalTime;
+paintGlobalChildren();
+function paintGlobalFilters(){
+ const disabled=!(globalSearch.trim()||globalApp||globalProject||globalTime!==DEFAULT_TIME_FILTER_WINDOW);
+ if($('g-clear').disabled!==disabled)$('g-clear').disabled=disabled;
+}
+$('g-search').addEventListener('input',e=>{ globalSearch=e.target.value; localStorage.setItem('tm_global_search',globalSearch); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
+$('g-app').addEventListener('change',e=>{ globalApp=e.target.value; localStorage.setItem('tm_global_app',globalApp); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
+$('g-project').addEventListener('change',e=>{ globalProject=e.target.value; localStorage.setItem('tm_global_project',globalProject); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
+$('g-time').addEventListener('change',e=>{ globalTime=e.target.value; localStorage.setItem('tm_global_time',globalTime); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
+$('g-clear').onclick=()=>{
+ globalSearch='';globalApp='';globalProject='';globalTime=DEFAULT_TIME_FILTER_WINDOW;
+ $('g-search').value='';$('g-app').value='';$('g-project').value='';$('g-time').value=DEFAULT_TIME_FILTER_WINDOW;
+ ['tm_global_search','tm_global_app','tm_global_project','tm_global_time'].forEach(key=>localStorage.removeItem(key));
+ paintGlobalFilters();
+ if(LATEST)renderAllSessions(LATEST.xsession);
+};
+$('g-active-filters').onclick=event=>{
+ const key=event.target.closest('button[data-clear-log-filter]')?.dataset.clearLogFilter;
+ if(!key)return;
+ if(key==='search'){globalSearch='';$('g-search').value='';localStorage.removeItem('tm_global_search');}
+ if(key==='app'){globalApp='';$('g-app').value='';localStorage.removeItem('tm_global_app');}
+ if(key==='project'){globalProject='';$('g-project').value='';localStorage.removeItem('tm_global_project');}
+ if(key==='time'){globalTime=DEFAULT_TIME_FILTER_WINDOW;$('g-time').value=DEFAULT_TIME_FILTER_WINDOW;localStorage.removeItem('tm_global_time');}
+ if(key==='work'){workSessionFilter=null;workFilterRequest++;}
+ paintGlobalFilters();
+ if(LATEST)renderAllSessions(LATEST.xsession);
+};
+$('g-sort').onclick=e=>{ if(e.target.dataset.gsort){ globalSort=e.target.dataset.gsort; localStorage.setItem('tm_global_sort',globalSort); paintGlobalSort(); if(LATEST) renderAllSessions(LATEST.xsession); } };
+paintGlobalSort();
+paintGlobalFilters();
+
diff --git a/dashboard/js/session-detail.js b/dashboard/js/session-detail.js
new file mode 100644
index 00000000..23dc15ba
--- /dev/null
+++ b/dashboard/js/session-detail.js
@@ -0,0 +1,442 @@
+function setCapabilityStatBar(id,value){
+ const bar=$(id);
+ if(!bar)return;
+ const normalized=Math.min(1,Math.max(0,Number(value)||0)),label=pct(normalized),fill=bar.querySelector('i');
+ if(fill)fill.style.width=`${normalized*100}%`;
+ bar.setAttribute('aria-valuenow',String(Math.round(normalized*100)));
+ bar.setAttribute('aria-valuetext',label);
+}
+function renderCurrentOptimization(s){
+ const tools=s.tools||{}, activity=tools.activity||{}, optional=s.optional_capabilities||{};
+ const observed=activity.observed_unique??tools.unique_used??0, calls=activity.total_calls??tools.total_calls??0;
+ const peak=activity.peak_calls_per_execution??tools.peak_calls_per_execution??0;
+ $('ov-activity-tools').textContent=f(observed);
+ $('ov-activity-note').textContent=`observed types · ${f(calls)} calls · peak ${f(peak)}/execution`;
+ const enabled=optional.enabled||0, used=optional.used||0;
+ $('ov-optional-use').textContent=`${f(used)}/${f(enabled)}`;
+ setCapabilityStatBar('ov-optional-bar',enabled?used/enabled:0);
+ $('ov-optional-note').textContent=enabled
+  ? `skill packs ${f(optional.skill_packs_used)}/${f(optional.skill_packs_enabled)} · MCPs are read-only`
+  : 'no removable groups enabled for this runtime';
+ $('ov-unused-packs').textContent=f(optional.unused||0);
+ $('ov-unused-packs-note').textContent=optional.unused
+  ? 'enabled packs with no activation in this run'
+  : 'no unused user-installed packs in this run';
+}
+function sessionAlert(s){
+ const source=s.source||{},capSpend=sessionCapSpend(s);
+ if(!capSpend.available)return {type:'',msg:'',key:''};
+ if(s.provider==='cursor')return {type:'',msg:'',key:''};
+ const budget=dollarInputValue('budget',10);
+ if(capSpend.spend>budget) return {type:'budget',msg:`This session passed your ${money(budget)} cap - now ${capSpend.partial?'at least ':''}${money(capSpend.spend)}`,key:`${source.id||s.session}:budget:${budget}`,budget,current:capSpend.spend};
+ return {type:'',msg:'',key:''};
+}
+function notifyAlertForSession(s,opts={}){
+ if(!s||pinned) return false;
+ const a=sessionAlert(s);
+ if(!a.msg) return false;
+ const key=opts.forceCurrent?a.key+':current:'+Date.now():a.key;
+ return fireNotification('Token Meter session budget',a.msg,key,{requireInteraction:true,renotify:!!opts.forceCurrent,dedupe:!opts.forceCurrent});
+}
+function renderAlertBanner(alert){
+ const banner=$('banner');
+ banner.classList.toggle('on',!!alert.msg);
+ banner.classList.toggle('budget',alert.type==='budget');
+ $('banner-msg').textContent=alert.msg||'';
+ if(alert.type==='budget'){
+  $('budget-add-btn').textContent='Add budget';
+  $('budget-add').setAttribute('aria-label','Budget to add beyond current spend');
+ }
+}
+
+function sessionStartMessage(s){
+ for(const row of (s?.series||[])){
+  const message=String(row?.user_message||row?.user_input||'').trim();
+  if(message)return message;
+ }
+ const event=(s?.trace||[]).find(row=>row?.kind==='user'||row?.label==='User message');
+ return String(event?.detail||'').trim();
+}
+
+function sessionDisplayName(s){
+ const id=stateSessionId(s),key=stateSessionKey(s),rows=[...(s?.xsession?.current_sessions||[]),...(s?.xsession?.sessions||[]),...(allSessionInventory||[])];
+ // Resumed rollouts and subagents share a logical id; only the same trace file may name the header.
+ const row=rows.find(item=>item?.session&&String(item.session)===key)||rows.find(item=>!item?.session&&String(item?.id||'')===String(id||''));
+ const name=String(row?.session_name||row?.title||'').trim();
+ if(name)return name;
+ const start=sessionStartMessage(s);
+ return start&&start.length<=88?start:'Session';
+}
+
+function sessionDisplayThroughput(session){
+ const completed=session?.throughput||{},live=session?.live_throughput||{};
+ return live.available?live:completed;
+}
+function sessionThroughputNote(throughput){
+ if(throughput?.basis==='live_end_to_end'){
+  const steps=Number(throughput.completed_steps)||0;
+  return `live checkpoints · ${f(steps)} completed ${countWord(steps,'step')}`;
+ }
+ return `${throughput?.basis==='tool_free'?'tool-free':'end-to-end'} · ${f(throughput?.sample_count||0)} timed ${countWord(throughput?.sample_count||0,'sample')} · ${pct(throughput?.timing_coverage)} coverage`;
+}
+
+const agentCostObservations=new Map();
+let selectedAgentActivityId='';
+function deriveAgentAttention(group,budget,previousCosts=new Map()){
+ const reasonsByAgent=new Map();
+ const addReason=(agentId,reason)=>{
+  if(!agentId||!reason?.code)return;
+  const reasons=reasonsByAgent.get(agentId)||[];
+  if(!reasons.some(item=>item.code===reason.code))reasons.push({code:String(reason.code),explanation:String(reason.explanation||'')});
+  reasonsByAgent.set(agentId,reasons);
+ };
+ for(const item of group?.attention||[]){
+  for(const reason of item?.reasons||[])addReason(item?.agent_id,reason);
+ }
+ const covered=group?.totals?.cost_available===true&&Number.isFinite(Number(group?.totals?.cost));
+ if(covered){
+  const cap=Number(budget),rootId=String(group?.root_session_id||'');
+  if(Number.isFinite(cap)&&cap>0&&Number(group.totals.cost)>cap){
+   const root=(group?.agents||[]).find(agent=>agent?.kind==='root');
+   if(root)addReason(root.id,{code:'cap_exceeded',explanation:`Covered estimated group spend is above this session's browser-local ${money(cap)} cap.`});
+  }
+  for(const agent of group?.agents||[]){
+   if(agent?.kind==='root'||agent?.cost_available!==true||!Number.isFinite(Number(agent?.cost)))continue;
+   const cost=Number(agent.cost);
+   if(Number.isFinite(cap)&&cap>0&&cost>cap)addReason(agent.id,{code:'cap_exceeded',explanation:`Covered estimated child-agent spend is above this session's browser-local ${money(cap)} cap.`});
+   if(agent.activity_state==='working'){
+    const key=`${rootId}:${agent.id}`,previous=Number(previousCosts.get(key));
+    if(Number.isFinite(previous)&&cost>previous&&cost-previous>=.25)addReason(agent.id,{code:'observed_live_growth',explanation:'Covered estimated cost increased by at least $0.25 while this child was reported working.'});
+    previousCosts.set(key,cost);
+   }
+  }
+ }
+ return (group?.agents||[]).filter(agent=>reasonsByAgent.has(agent?.id)).map(agent=>({
+  agent_id:agent.id,level:'needs_attention',reasons:reasonsByAgent.get(agent.id),
+ }));
+}
+function agentIdentityPresentation(agent,index){
+ if(agent?.kind==='root')return {primary:'Main session',secondary:''};
+ const role=String(agent?.role||'').trim(),label=String(agent?.label||'').trim();
+ if(role)return {primary:role,secondary:label&&label!==role?label:''};
+ return {primary:label||`Agent ${index+1}`,secondary:''};
+}
+function agentDisplayLabel(agent,index){
+ return agentIdentityPresentation(agent,index).primary;
+}
+function subagentCostHeat(cost,maxCost,available){
+ const value=Number(cost),maximum=Number(maxCost);
+ if(available!==true||!Number.isFinite(value)||value<0||!Number.isFinite(maximum)||maximum<=0)return '';
+ const intensity=Math.max(0,Math.min(1,value/maximum));
+ return `--cost-heat:hsl(${Math.round(190-160*intensity)} 88% 69%);--cost-fill:${Math.round(100*intensity)}%`;
+}
+function renderAgentActivity(s){
+ const module=$('agent-activity'),group=s?.agent_group,agents=Array.isArray(group?.agents)?group.agents:[];
+ if(!group||agents.length<2){
+  module.hidden=true;
+  selectedAgentActivityId='';
+  return;
+ }
+ module.hidden=false;
+ const attention=deriveAgentAttention(group,sessionBudgetForSession(s),agentCostObservations),attentionByAgent=new Map(attention.map(item=>[String(item.agent_id),item]));
+ if(!agents.some(agent=>String(agent.id)===String(selectedAgentActivityId)))selectedAgentActivityId=group.selected_agent_id||agents[0].id;
+ const selected=agents.find(agent=>String(agent.id)===String(selectedAgentActivityId))||agents[0];
+ selectedAgentActivityId=selected.id;
+ const selectedIndex=Math.max(0,agents.indexOf(selected)),selectedLabel=agentDisplayLabel(selected,selectedIndex);
+ const childAgents=agents.filter(agent=>agent.kind!=='root'),childTotals=group.child_totals||{},knownChildCost=Number(childTotals.known_cost)||0;
+ const maximumChildCost=Math.max(0,...childAgents.filter(agent=>agent.cost_available===true).map(agent=>Number(agent.cost)||0));
+ const childCostCovered=childTotals.cost_available===true&&Number.isFinite(Number(childTotals.cost));
+ const totals=group.totals||{},coverage=group.coverage||{},hidden=Number(group.hidden_agent_count)||0;
+ $('agent-activity-context').textContent=selected.kind==='root'
+  ? `${f(childAgents.length+hidden)} ${countWord(childAgents.length+hidden,'child agent')} under this session`
+  : `Main session → ${selectedLabel}`;
+ $('agent-activity-coverage').textContent=[coverage.relationships==='complete'?'':`Relationships ${coverage.relationships||'unavailable'}`,['complete','estimated'].includes(coverage.cost)?'':`cost ${coverage.cost||'unavailable'}`,coverage.tokens==='complete'?'':`tokens ${coverage.tokens||'unavailable'}`,hidden?`${f(hidden)} hidden (limit 100)`:''].filter(Boolean).join(' · ');
+ const metric=(label,value,note)=>`<div class="agentActivityMetric metric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
+ $('agent-activity-metrics').innerHTML=[
+  metric('Group cost',totals.cost_available?money(totals.cost):'--',totals.cost_available?'API-rate estimate · all agents cost-covered':totals.known_cost?`${money(totals.known_cost)} covered cost; some agents unavailable`:'cost unavailable'),
+  metric('Child cost',childCostCovered?money(childTotals.cost):'--',childCostCovered?'API-rate estimate · root session excluded':knownChildCost?`${money(knownChildCost)} covered child cost; some agents unavailable`:'child cost unavailable'),
+  metric('Tokens',totals.tokens_available?f(totals.tokens):'--',totals.tokens_available?'all agents token-covered':totals.known_tokens?`${f(totals.known_tokens)} covered tokens; some agents unavailable`:'token evidence unavailable'),
+  metric('Agents',f(totals.agents||agents.length),`${f(childAgents.length+hidden)} children · ${f(attention.length)} ${countWord(attention.length,'signal')}`),
+ ].join('');
+ const rows=agents.map((agent,index)=>{
+  const identity=agentIdentityPresentation(agent,index),label=identity.primary,selectedRow=String(agent.id)===String(selectedAgentActivityId);
+  const model=agent.model&&agent.model!=='unknown'?agent.model:'model unavailable',state=agent.activity_state||'unknown';
+  const tokenValue=agent.tokens_available===true?f(agent.tokens):'--',costValue=agent.cost_available===true?money(agent.cost):'--';
+  const share=agent.group_cost_share==null?'--':pct(agent.group_cost_share),workTime=agent.work_time_s==null?'--':durationShort(agent.work_time_s);
+  const secondary=identity.secondary?`${identity.secondary} · `:'',kind=agent.kind==='root'?'session':agent.kind;
+  const destination=agent.navigable&&agent.session_id?` data-agent-session="${esc(agent.session_id)}"`:'';
+  const heat=agent.kind==='root'?'':subagentCostHeat(agent.cost,maximumChildCost,agent.cost_available);
+  return `<button class="agentRow${selectedRow?' selected':''}" type=button role=treeitem aria-level="${Math.max(1,Number(agent.depth||0)+1)}" aria-selected="${selectedRow?'true':'false'}" style="--agent-depth:${Math.max(0,Number(agent.depth)||0)}" data-agent-id="${esc(agent.id)}"${destination}><span class=agentIdentity><strong><span>${esc(label)}</span></strong><small>${esc(secondary+kind)}</small></span><span class=agentMetric>${esc(model)}</span><span class="agentState ${esc(state)}">${esc(state)}</span><span class=agentMetric>${esc(tokenValue)}</span><span class="agentMetric${heat?' subagentCostHeat':''}"${heat?` style="${heat}" title="Relative child cost in this session"`:''}>${esc(costValue)}</span><span class=agentMetric>${esc(share)}</span><span class=agentMetric>${esc(workTime)}</span></button>`;
+ }).join('');
+ $('agent-activity-tree').innerHTML='<div class=agentTreeHeader><span>Agent</span><span>Model</span><span>Status</span><span>Tokens</span><span class=fieldtip tabindex=0 aria-description="Cost color compares children in this session; it does not judge their work." data-tip="Cost color compares children in this session; it does not judge their work.">Cost</span><span>Share</span><span class=fieldtip tabindex=0 data-tip="Cumulative completed prompt-to-response time. Includes reasoning and tool use; excludes gaps between prompts.">Work time</span></div>'+rows;
+ const selectedAttention=attentionByAgent.get(String(selected.id));
+ $('agent-attention-detail').hidden=!selectedAttention;
+ $('agent-attention-detail').innerHTML=selectedAttention
+  ? `<b>${esc(selectedLabel)} · Cost and retry evidence</b><ul>${selectedAttention.reasons.map(reason=>`<li>${esc(reason.explanation)}</li>`).join('')}</ul>`
+  : '';
+}
+$('agent-activity-tree').addEventListener('click',event=>{
+ const row=event.target.closest('[data-agent-id]');
+ if(!row||!CURRENT)return;
+ selectedAgentActivityId=row.dataset.agentId;
+ const destination=row.dataset.agentSession,currentId=String(stateSessionId(CURRENT)||'');
+ if(destination&&destination!==currentId){selectSession(destination,{returnScope:sessionReturnScope});return;}
+ renderAgentActivity(CURRENT);
+});
+
+function renderCurrentRun(s){
+	 const source=s.source||{},throughput=sessionDisplayThroughput(s),wait=s.wait_time||{},context=s.context||{},tools=s.tools||{},cache=s.cache||{},timing=s.timing||{};
+ const costAvailable=metricAvailable(s,'cost'),cacheAvailable=metricAvailable(s,'cache'),throughputAvailable=metricAvailable(s,'throughput'),cacheSavingsAvailable=costAvailable&&cacheAvailable&&cache.savings_available!==false;
+ const contextPct=Math.max(0,Math.min(1,Number(context.latest_pct)||0)),toolResultTokens=tools.total_output_tokens||0;
+ const alert=sessionAlert(s),capSpend=sessionCapSpend(s),frozen=!!s.ended,cursorEstimate=s.provider==='cursor',cap=dollarInputValue('budget',Infinity),costPerTask=s.analyses?.cost_per_task||{};
+ $('preview-provider').innerHTML=runtimeBadgeContent(s,source.label||s.provider||'source');
+ $('preview-provider').className='badge app '+appBadgeClass(s);
+ $('preview-project').textContent=s.project||source.project||'';
+ $('preview-model').textContent=s.primary_model||'model unavailable';
+ renderWorkTags(s.work_tags);
+ renderDesktopSessionLink(s);
+ $('preview-state').textContent=pinned?'Pinned':(frozen?'Complete':'Live');
+ $('preview-idle').textContent=frozen?'frozen':idleLabel(s.idle_s);
+ setCostValue('preview-cost',money(s.total_cost)+(s.cost_approx?' est':''),costAvailable);
+ $('preview-cost-note').textContent=alert.msg?alert.msg:(capSpend.available&&Number.isFinite(cap)?`${capSpend.partial?'At most ':''}${money(Math.max(0,cap-capSpend.spend))} before the ${money(cap)} session cap`:source.pricing_note||'Cost evidence unavailable.');
+ $('preview-status-card').classList.toggle('warn',!!alert.msg);
+ $('preview-context-pct').textContent=context.window?pct(contextPct):'--';
+ $('preview-context-bar').setAttribute('aria-valuenow',String(Math.round(contextPct*100)));
+ $('preview-context-bar').querySelector('i').style.width=`${Math.round(contextPct*100)}%`;
+ $('preview-started-at').textContent=(dt12(timing.start_local)||'--').replace(' ','\n');
+ $('preview-last-label').textContent=frozen?'Completed':'Last activity';
+ $('preview-last-at').textContent=(dt12(timing.end_local)||'--').replace(' ','\n');
+ $('preview-speed').textContent=throughputAvailable&&throughput.available?`${speedFmt(throughput.output_tps)} tok/s`:'--';
+	 $('preview-speed-note').textContent=throughputAvailable&&throughput.available?sessionThroughputNote(throughput):'timing unavailable';
+ $('preview-wait').textContent=wait.available?waitFmt(wait.total_s):'--';
+ $('preview-wait-note').textContent=wait.available?`${waitFmt(wait.avg_s)} average · ${f(wait.sample_count)} completed`:'wait unavailable';
+ $('preview-context').textContent=context.latest?f(context.latest):'--';
+ $('preview-context-note').textContent=context.window?`${pct(contextPct)} of ${f(context.window)} window`:'window unavailable';
+ $('preview-executions').textContent=f(s.turns||0);
+ $('preview-executions-note').textContent=s.primary_model||'model unavailable';
+ $('preview-tools').textContent=f(tools.total_calls||0);
+ $('preview-tools-note').textContent=`${f(tools.activity?.observed_unique??tools.unique_used??0)} observed types`;
+ $('preview-tool-results').textContent=f(toolResultTokens);
+ $('preview-tool-results-note').textContent=`${f(tools.total_calls||0)} calls · estimated returned tokens`;
+ $('preview-cache-rate').textContent=cacheAvailable?pct(cache.input_share||0):'--';
+ $('preview-cache-rate-note').textContent=cacheAvailable?`${f(cache.total||0)} cached · ${f(cache.fresh||0)} fresh`:'cache accounting unavailable';
+ $('preview-cache-saved').textContent=cacheSavingsAvailable?money(cache.saved||s.cache_saved||0):'--';
+ $('preview-cache-saved-note').textContent=cacheSavingsAvailable?`${money(cache.cost||0)} cache cost · est. avoided spend`:'cache savings unavailable';
+ $('preview-burn').textContent=costAvailable&&timing.duration_available?money(s.burn_usd_min)+(cursorEstimate?' est':''):'--';
+ $('preview-burn-note').textContent=costAvailable&&timing.duration_available?`${f(s.burn_tok_min)} tokens/min · active`:(timing.duration_available?'billing unavailable':'execution timing unavailable');
+ setCostValue('preview-cost-task',money(costPerTask.per_task||0)+(cursorEstimate?' est':''),costAvailable);
+ $('preview-cost-task-note').textContent=costAvailable?`${f(costPerTask.completed||0)} completed tasks${cursorEstimate?'':' · est.'}`:'billing unavailable';
+ const startMessage=sessionStartMessage(s)||(s.provider==='pi'?'Pi message content is not captured.':'No user message captured.');
+ $('preview-start').textContent=startMessage;
+ $('preview-start').dataset.tip=startMessage;
+ $('preview-start').setAttribute('aria-description',startMessage);
+}
+
+function renderSession(s){
+ CURRENT=s;
+ loadBudgetForSession(s);
+ renderCurrentBudgetWarning(s.xsession?.budget||LATEST?.xsession?.budget);
+ const frozen=!!s.ended, source=s.source||{};
+ $('s-provider').innerHTML=runtimeBadgeContent(s,source.label||s.provider||'source');
+ $('s-provider').className='badge app '+appBadgeClass(s);
+ $('s-repo').textContent=s.project||source.project||'';
+ $('s-id').textContent=s.session||source.id||'';
+ $('s-pricing').textContent=source.pricing_note||'';
+ const modelIdentity=source.model_identity||{},modelIdentityAction=$('session-model-identity-action');
+ const assignedModel=modelIdentity.source==='user_assigned';
+ const modelIdentityAssignable=!!modelIdentity.assignable&&!!modelIdentity.key;
+ modelIdentityAction.hidden=!modelIdentityAssignable;
+ modelIdentityAction.style.display=modelIdentityAssignable?'inline-flex':'none';
+ modelIdentityAction.textContent=assignedModel?'Change model':(modelIdentity.kind==='missing_model'?'Add model':'Assign model');
+ modelIdentityAction.onclick=modelIdentityAction.hidden?null:()=>openSessionModelIdentityDialog({
+  label:source.label||s.provider,project:s.project||source.project||'',
+  title:sessionDisplayName(s),primary_model:s.primary_model,
+  models:s.primary_model?[s.primary_model]:[],model_identity:modelIdentity,
+ });
+ const startMessage=sessionStartMessage(s);
+ $('session-start').hidden=!startMessage;
+ $('session-start-text').textContent=startMessage;
+ const sessionActions=s.xsession?.session_actions||{}, deleteButton=$('session-delete');
+ const deleteAvailable=sessionDeleteAvailable(source,sessionActions);
+ deleteButton.hidden=!source.id||!deleteAvailable;
+ deleteButton.disabled=!deleteAvailable;
+ deleteButton.title=deleteAvailable?'Move this session log to the system Trash.':'Session deletion is unavailable for this provider.';
+ $('frozen').classList.toggle('on',frozen);
+ const costAvailable=metricAvailable(s,'cost'),tokensAvailable=metricAvailable(s,'tokens'),inputAvailable=metricAvailable(s,'input_tokens'),outputAvailable=metricAvailable(s,'output_tokens'),cacheAvailable=metricAvailable(s,'cache'),throughputAvailable=metricAvailable(s,'throughput'),cursorEstimate=s.provider==='cursor';
+ setCostValue('cost',money(s.total_cost)+(s.cost_approx?' est':''),costAvailable);
+ const tok=s.tokens||{}, sem=s.semantic||{}, tools=s.tools||{}, cache=s.cache||{}, latestCache=cache.latest||{}, timing=s.timing||{};
+ const cacheSavingsAvailable=costAvailable&&cacheAvailable&&cache.savings_available!==false;
+ $('cost-tip').innerHTML=costTipHtml(s,tok);
+ const inputTokens=(tok.input||0)+(tok.cache_read||0)+(tok.cache_write||0), outputTokens=tok.output||0;
+	 const thinkingTokens=sem.reasoning||0, toolCallTokens=tools.total_output_tokens||0, throughput=sessionDisplayThroughput(s);
+	 const speedPart=throughputAvailable&&throughput.available?` · <b>${speedFmt(throughput.output_tps)}</b> ${cursorEstimate?'visible out tok/s est':'out tok/s'}`:'';
+	 $('sub').innerHTML=`<b>${inputAvailable?f(inputTokens)+(cursorEstimate?' est':''):'--'}</b> in · <b>${outputAvailable?f(outputTokens)+(cursorEstimate?' est':''):'--'}</b> out${speedPart} · <b>${outputAvailable?f(thinkingTokens)+(cursorEstimate?' est':''):'--'}</b> thinking · <b>${f(toolCallTokens)}</b> estimated tool results · <b>${f(s.turns)}</b> executions`;
+ $('input-tok').textContent=inputAvailable?f(inputTokens)+(cursorEstimate?' est':''):'--';
+ $('input-toksm').textContent=inputAvailable?(cursorEstimate?`${f(tok.input||0)} context proxy · cache unknown`:`${f(tok.input||0)} uncached · ${f((tok.cache_read||0)+(tok.cache_write||0))} cache`):'input evidence unavailable';
+ $('cache-hit').textContent=cacheAvailable?pct(cache.input_share||0):'--';
+ $('cache-hitsm').textContent=cacheAvailable?`${f(cache.total||0)} cached · ${f(cache.fresh||0)} uncached`:'cache accounting unavailable';
+ $('cache-tok').textContent=cacheAvailable?f(cache.total||0):'--';
+	 $('cache-toksm').textContent=cacheAvailable?`${f(cache.read||0)} read · ${f(cache.write||0)} write · latest ${f(latestCache.tokens||0)}`:'cache accounting unavailable';
+	 $('output-tok').textContent=outputAvailable?f(outputTokens)+(cursorEstimate?' est':''):'--';
+	 $('output-tps').textContent=throughputAvailable&&throughput.available?speedFmt(throughput.output_tps):'--';
+	 $('output-toksm').textContent=throughputAvailable&&throughput.available?`${sessionThroughputNote(throughput)}${cursorEstimate?' · visible text estimate':''}`:(outputAvailable?`of ${f(s.total_tokens)} total · timing unavailable${cursorEstimate?' · visible text estimate':''}`:'output evidence unavailable');
+ $('think-tok').textContent=outputAvailable?f(thinkingTokens)+(cursorEstimate?' est':''):'--';
+ $('think-toksm').textContent=cursorEstimate?`${f(s.analyses?.reasoning?.think_turns||0)} reasoning exec · hidden reasoning excluded`:outputAvailable?f(s.analyses?.reasoning?.think_turns||0)+' reasoning exec':`${f(s.analyses?.reasoning?.think_turns||0)} reasoning exec · duration only`;
+ $('toolcall-tok').textContent=f(toolCallTokens);
+ $('toolcall-toksm').textContent=f(tools.total_calls||0)+' calls returned';
+ $('cache-saved').textContent=cacheSavingsAvailable?money(cache.saved||s.cache_saved||0):'--';
+ $('cache-savedsm').textContent=cacheSavingsAvailable?`${money(cache.cost||0)} cache cost`:'cache savings unavailable';
+ $('burn').textContent=costAvailable&&timing.duration_available?money(s.burn_usd_min)+(cursorEstimate?' est':''):'--';
+ $('burnsm').textContent=costAvailable&&timing.duration_available?`${f(s.burn_tok_min)} tok/min · active${cursorEstimate?' · local proxy':''}`:(timing.duration_available?'active timing available · billing unavailable':'execution timing unavailable');
+ setCostValue('cpt',money(s.analyses?.cost_per_task?.per_task||0)+(cursorEstimate?' est':''),costAvailable);
+ $('cptsm').textContent=costAvailable?f(s.analyses?.cost_per_task?.completed||0)+` completed${cursorEstimate?' · local proxy':''}`:'billing unavailable';
+ renderOverview(s); renderCurrentOptimization(s); renderCurrentRun(s); renderSessionEfficiency(s); renderAgentActivity(s);
+
+ const semanticAvailable=s.semantic_available!==false,semTot=Object.values(sem).reduce((a,b)=>a+(b||0),0)||1;
+ const segs=[['reasoning','var(--reason)'],['output','var(--output)'],['retrieval','var(--retrieval)'],['coordination','var(--coord)']];
+ $('semhint').textContent=semanticAvailable?'':'semantic data unavailable';
+ $('sembar').innerHTML=tokensAvailable&&semanticAvailable?segs.map(([k,c])=>{const w=100*(sem[k]||0)/semTot; if(w<0.6)return''; return `<span style="width:${w}%;background:${c}">${w>8?f(sem[k]):''}</span>`;}).join(''):'';
+ drawIO(s.series||[]);
+
+ const liveView=!pinned;
+
+ const alert=sessionAlert(s);
+ $('cost').classList.toggle('alert',!!alert.msg);
+ renderAlertBanner(alert);
+ if(alert.msg&&liveView) notifyAlertForSession(s);
+}
+
+let pendingSessionDelete=null;
+function sessionDeleteAvailable(target,actions){
+ const provider=String(target?.provider||target?.client||'').toLowerCase();
+ return Boolean(actions?.available)&&!(actions?.read_only_providers||[]).map(String).map(value=>value.toLowerCase()).includes(provider);
+}
+function sessionDeleteTargetFromState(state){
+ const id=stateSessionId(state),source=state?.source||{},key=stateSessionKey(state);
+ if(!id)return null;
+ const row=(state?.xsession?.sessions||[]).find(item=>sessionRowKey(item)===key);
+ return row||{id,session:state?.session||'',title:sessionStartMessage(state)||id,project:state?.project||source.project||'',label:source.label||state?.provider||'session',provider:source.provider||state?.provider||''};
+}
+function openSessionDeleteDialog(target,actions,returnToAll=false,isLive=false){
+ if(!target?.id||!sessionDeleteAvailable(target,actions))return;
+ pendingSessionDelete={target,actions,returnToAll,isLive};
+ $('session-delete-sub').textContent=`${target.label||target.provider||'Session'} · ${target.project||'No project'}`;
+ $('session-delete-evidence').innerHTML=`<div><b>${esc(target.title||'(untitled session)')}</b></div><div>This removes the underlying local JSONL session record from Token Meter.</div>`;
+ $('session-delete-id').textContent=target.id;
+ $('session-delete-note').textContent=isLive?'This appears to be the live session. Stop its agent first to prevent further writes. The session record will be moved to the system Trash; provider metadata and configuration are not changed.':'The session record will be moved to the system Trash and can be recovered there. Provider metadata and configuration are not changed.';
+ $('session-delete-confirm').disabled=false;
+ $('session-delete-confirm').textContent='Move to Trash';
+ $('session-delete-dialog').showModal();
+}
+$('session-delete').onclick=()=>{
+ const target=sessionDeleteTargetFromState(CURRENT),actions=CURRENT?.xsession?.session_actions||{};
+ if(target)openSessionDeleteDialog(target,actions,sessionReturnScope==='all',Boolean(!pinned&&LATEST&&sessionRowKey(target)===stateSessionKey(LATEST)));
+};
+$('session-delete-cancel').onclick=()=>{$('session-delete-dialog').close();pendingSessionDelete=null;};
+$('session-delete-dialog').addEventListener('cancel',()=>{pendingSessionDelete=null;});
+$('session-delete-confirm').onclick=async()=>{
+ if(!pendingSessionDelete)return;
+ const {target,actions,returnToAll}=pendingSessionDelete,button=$('session-delete-confirm');
+ button.disabled=true;button.textContent='Moving…';
+ try{
+  const response=await fetch('/session/delete',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':actions.token},body:JSON.stringify({session_id:target.id,trace:target.session||''})});
+  const result=await response.json();
+  if(!response.ok||!result.ok)throw new Error(result.error||'Could not delete session.');
+  $('session-delete-dialog').close();pendingSessionDelete=null;sessionRequest++;pinned=null;
+  const stateResponse=await fetch('/state',{cache:'no-store'}),state=await stateResponse.json();
+  adoptFreshDiscounts(state);LATEST=state;CURRENT=state;
+  if(returnToAll||!stateSessionId(state)){
+   sessionScope='all';sessionReturnScope='all';
+   if(history.replaceState)history.replaceState(null,'','/#sessions-all');
+   applyHashRoute();
+   if(state.xsession)renderAllSessions(state.xsession);
+	  }else{
+	   if(history.replaceState)history.replaceState(null,'','/#sessions');
+	   applyHashRoute();
+  }
+  showAppToast({title:'Session moved to Trash',body:`${target.title||target.id} was removed from Token Meter.`,kind:'warn',sticky:true});
+ }catch(error){
+  button.disabled=false;button.textContent='Move to Trash';
+  showAppToast({title:'Session deletion failed',body:error.message||String(error),kind:'warn',sticky:true});
+ }
+};
+
+let pendingSessionModelIdentity=null;
+function sessionModelIdentitySourceLabel(identity){
+ if(identity?.kind==='missing_model')return identity.source==='user_assigned'?'User-assigned Claude model':'Underlying Hermes model unavailable';
+ return ({user_assigned:'User-assigned model',unresolved:'Underlying model unavailable'}[identity?.source]||'Saved model evidence');
+}
+function sessionModelIdentityPresentation(identity){
+ const hermes=identity?.kind==='missing_model'&&identity?.runtime==='hermes';
+ return hermes
+  ? {provider:'hermes',fieldLabel:'Claude model ID',placeholder:'claude-sonnet-5',noun:'Claude model ID',observedLabel:'Bedrock application profile'}
+  : {provider:'codex',fieldLabel:'Codex / OpenAI model ID',placeholder:'gpt-model-version',noun:'Codex / OpenAI model ID',observedLabel:''};
+}
+function openSessionModelIdentityDialog(target){
+ const identity=target?.model_identity||{};
+ if(!identity.assignable||!identity.key)return;
+ const presentation=sessionModelIdentityPresentation(identity),candidates=Array.isArray(identity.candidates)?identity.candidates:[];
+ pendingSessionModelIdentity={target,identity,presentation};
+ $('session-model-identity-sub').textContent=`${target.label||target.provider||'Codex'} · ${target.project||'No project'}`;
+ const observedLabel=identity.observed_label||presentation.observedLabel;
+ const observed=observedLabel?` Observed: ${observedLabel}.`:'';
+ const candidateText=candidates.length?` Configured public ${candidates.length===1?'alias':'aliases'}: ${candidates.join(', ')}.`:'';
+ $('session-model-identity-evidence').innerHTML=`<div><b>${esc(target.title||'(untitled session)')}</b></div><div>${esc(sessionModelIdentitySourceLabel(identity))}.${esc(observed+candidateText)} Token Meter could not verify an exact billable model from the available local aggregate.</div>`;
+ $('session-model-identity-model-label').textContent=presentation.fieldLabel;
+ $('session-model-identity-model').placeholder=presentation.placeholder;
+ $('session-model-identity-candidates').innerHTML=candidates.map(model=>`<option value="${esc(model)}"></option>`).join('');
+ $('session-model-identity-model').value=identity.source==='user_assigned'?(identity.assigned_model||target.primary_model||(target.models||[])[0]||''):(candidates.length===1?candidates[0]:'');
+ $('session-model-identity-remove').hidden=identity.source!=='user_assigned';
+ $('session-model-identity-save').disabled=false;
+ $('session-model-identity-save').textContent='Save model';
+ $('session-model-identity-dialog').showModal();
+ requestAnimationFrame(()=>$('session-model-identity-model').focus());
+}
+function closeSessionModelIdentityDialog(){
+ $('session-model-identity-dialog').close();pendingSessionModelIdentity=null;
+}
+async function requestSessionModelIdentity(payload){
+ const token=agentActionToken();
+ if(!token)throw new Error('Settings are not ready yet. Wait for live state and try again.');
+ const response=await fetch('/settings/session-model-identity',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify(payload)});
+ const result=await response.json();
+ if(!response.ok||!result.ok)throw new Error(result.error||'Could not save the session model.');
+ return result;
+}
+$('session-model-identity-cancel').onclick=closeSessionModelIdentityDialog;
+$('session-model-identity-dialog').addEventListener('cancel',()=>{pendingSessionModelIdentity=null;});
+$('session-model-identity-save').onclick=async()=>{
+ const pending=pendingSessionModelIdentity,button=$('session-model-identity-save');
+ if(!pending)return;
+ const model=$('session-model-identity-model').value.trim();
+ if(!model){$('session-model-identity-model').focus();showAppToast({title:'Model ID required',body:`Enter the exact ${pending.presentation.noun} used for this saved session.`,kind:'warn'});return;}
+ button.disabled=true;button.textContent='Saving…';
+ try{
+  await requestSessionModelIdentity({session_key:pending.identity.key,provider:pending.presentation.provider,model});
+  closeSessionModelIdentityDialog();
+  forceAllSessionRowRefresh=true;
+  await refreshLiveState();
+  if(pinned)await refreshSelectedSession({show:true});
+  showAppToast({title:'Session model assigned',body:'Only this saved session changed. Model prices were not changed.',kind:'good'});
+ }catch(error){
+  button.disabled=false;button.textContent='Save model';
+  showAppToast({title:'Session model could not be saved',body:error.message||String(error),kind:'warn',sticky:true});
+ }
+};
+$('session-model-identity-remove').onclick=async()=>{
+ const pending=pendingSessionModelIdentity,button=$('session-model-identity-remove');
+ if(!pending)return;
+ button.disabled=true;button.textContent='Clearing…';
+ try{
+  await requestSessionModelIdentity({session_key:pending.identity.key,remove:true});
+  closeSessionModelIdentityDialog();
+  forceAllSessionRowRefresh=true;
+  await refreshLiveState();
+  if(pinned)await refreshSelectedSession({show:true});
+  showAppToast({title:'Session model assignment cleared',body:'This saved session remains unavailable until exact local evidence is present.',kind:'good'});
+ }catch(error){
+  button.disabled=false;button.textContent='Clear assignment';
+  showAppToast({title:'Session model could not be cleared',body:error.message||String(error),kind:'warn',sticky:true});
+ }
+};
+
diff --git a/dashboard/js/session-logs-compare.js b/dashboard/js/session-logs-compare.js
new file mode 100644
index 00000000..6de680ab
--- /dev/null
+++ b/dashboard/js/session-logs-compare.js
@@ -0,0 +1,364 @@
+function capabilityCounts(capabilities,key){
+ const counts=capabilities?.[key]||{},loaded=Number.isInteger(counts.loaded)?counts.loaded:null;
+ return {loaded,used:Math.max(0,Number(counts.used)||0),basis:loaded==null?'unavailable':counts.basis==='configured'?'configured':'session'};
+}
+function capabilityRatio(counts){
+ return `${f(counts.used)}/${counts.loaded==null?'—':f(counts.loaded)}${counts.basis==='configured'?'*':''}`;
+}
+function capabilitySummaryText(capabilities){
+ return `Skills ${capabilityRatio(capabilityCounts(capabilities,'skills'))} · MCP ${capabilityRatio(capabilityCounts(capabilities,'mcp_servers'))}`;
+}
+const CAPABILITY_SUMMARY_TIP='Used / loaded skills and MCP servers. * means configured now, not recorded by this session. — means unavailable.';
+function logRowRenderKey(s,active){
+ // Child subagent rows are part of this row's content, so a change in the
+ // children must invalidate the cached innerHTML.
+ return JSON.stringify([active,compareIds.indexOf(compareKeyFor(s)),compareIds.length>=COMPARE_MAX,sessionDeleteAvailable(s,renderedAllSessionActions),s.subagent,s.client,s.provider,s.label,s.title,s.project,s.last,s.start,s.wait_time,s.turns,s.cost,s.availability,s.models,s.model_identity,s.tokens,s.provenance,s.usage_basis,s.token_estimate,s.throughput,s.cost_approx,s.capabilities,childAgentsFor(s).map(c=>[c.id,c.cost,c.tokens,c.title,c.last,c.child_agent_role,c.child_depth,c.availability,c.models])]);
+}
+function logRowContent(s){
+ const rowCost=metricAvailable(s,'cost'),localEstimate=hasLocalEstimate(s),avg=rowCost&&s.turns?money((s.cost||0)/s.turns)+estimateSuffix(s):'--';
+ const wait=s.wait_time||{},waitText=wait.available?`${waitFmt(wait.total_s)} wait · ${waitFmt(wait.avg_s)} avg`:'wait unavailable';
+ const identity=s.model_identity||{},unresolvedIdentity=identity.source==='unresolved',assignedIdentity=identity.source==='user_assigned',identityLabel={verified_parent:' · parent verified',verified_history:' · verified history',user_assigned:' · assigned'}[identity.source]||'';
+ const candidates=Array.isArray(identity.candidates)?identity.candidates:[];
+ const unresolvedModelText=identity.kind==='auto_review'?'Auto-review · model unconfirmed':(candidates.length?`${candidates.join(', ')} · configured alias candidate`:`${identity.observed_label||'Hermes model'} · unconfirmed`);
+ const modelText=unresolvedIdentity?unresolvedModelText:`${(s.models||[]).join(', ')||'--'}${identityLabel}`,throughput=s.throughput||{},speed=throughput.available?` · ${speedFmt(throughput.output_tps)} ${localEstimate?'visible out tok/s est':'out tok/s'}`:'';
+ const identityAction=identity.assignable&&identity.key?`<button class=sessionModelAssign data-session-model-identity="${esc(identity.key)}" type=button>${assignedIdentity?'Change model':(identity.kind==='missing_model'?'Add model':'Assign model')}</button>`:'';
+ return `${compareToggleHtml(s)}<div><span class="badge app ${appBadgeClass(s)}">${runtimeMarkSvg(s)}${esc(s.label||s.provider)}</span></div>
+  <div class=sMain><div class=t>${s.subagent?'<span class="badge subagentTag">Subagent</span> ':''}${esc(s.title)}</div><div class=meta title="${esc(`${waitText} · ${avg}/exec${speed} · ${CAPABILITY_SUMMARY_TIP}`)}">${esc(s.project||'local')} · ${esc(s.last||s.start||'')} · ${esc(capabilitySummaryText(s.capabilities))}</div><div class=sbar><i></i></div>${childAgentSubsection(s)}</div>
+  <div class="badge models">${esc(modelText)}</div>
+  <div class=smetrics><div class="c mono" title="${esc(`${rowCost?(localEstimate?'local estimate':'cost'):(unresolvedIdentity?'model unconfirmed · billing unavailable':'billing unavailable')} · ${f(s.turns)} execs`)}">${costValueHtml(money(s.cost)+(s.cost_approx?' est':''),rowCost)}</div>${identityAction}</div>
+  <div class=sactions>${sessionDeleteAvailable(s,renderedAllSessionActions)?`<button class="sessionDelete sessionDeleteIcon" data-delete-session="${esc(sessionRowKey(s))}" type=button aria-label="Delete session" title="Delete session"><svg viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h16M10 11v6M14 11v6M6 7l1 12a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2l1-12M9 7V4h6v3"/></svg></button>`:''}</div>`;
+}
+const CHILD_SECTION_LIMIT=6;
+function childAgentsFor(s){
+ const children=childSessionMap.get(String(s?.id||''));
+ return Array.isArray(children)?children:[];
+}
+function childRootId(row){return row?.is_child_session?String(row.root_session_id||''):'';}
+function indexChildSessions(rows){
+ // Every descendant is keyed by its root session, so a nested run still renders
+ // under the root card when its intermediate parent is itself a hidden child.
+ childSessionMap=new Map();
+ (rows||[]).forEach(row=>{
+  if(!row?.is_child_session)return;
+  const key=childRootId(row);
+  if(!key)return;
+  if(!childSessionMap.has(key))childSessionMap.set(key,[]);
+  childSessionMap.get(key).push(row);
+ });
+ childSessionMap.forEach(list=>list.sort((a,b)=>(b.cost||0)-(a.cost||0)||(b.mtime||0)-(a.mtime||0)));
+ return childSessionMap;
+}
+function childAgentSubsection(s){
+ const children=childAgentsFor(s);
+ if(!children.length)return '';
+ const shown=children.slice(0,CHILD_SECTION_LIMIT);
+ const hidden=children.length-shown.length;
+ const coveredCost=children.filter(row=>metricAvailable(row,'cost'));
+ const totalCost=coveredCost.reduce((a,b)=>a+(b.cost||0),0);
+ const coveredTokens=children.filter(row=>metricAvailable(row,'tokens'));
+ const totalTokens=coveredTokens.reduce((a,b)=>a+(b.tokens||0),0);
+ const stats=[
+  `<b>${f(children.length)}</b> ${countWord(children.length,'run')}`,
+  coveredCost.length?`<b>${money(totalCost)}</b> covered spend`:'spend unavailable',
+  totalTokens?`<b>${f(totalTokens)}</b> tok`:'',
+ ].filter(Boolean).join(' · ');
+ const rows=shown.map(child=>{
+  const childCost=metricAvailable(child,'cost');
+  const childTokens=metricAvailable(child,'tokens');
+  const role=child.child_agent_role?`<span class=subagentRole>${esc(child.child_agent_role)}</span>`:'';
+  const roleText=child.child_agent_role||'Unreported role';
+  const title=child.title||'Subagent run';
+  const depth=Number(child.child_depth)||1;
+  const detail=[roleText,depth>1?`nested depth ${f(depth)}`:'',(child.models||[]).join(', ')||child.primary_model||'--',child.last||''].filter(Boolean).join(' · ');
+  const costHtml=childCost
+   ?(child.cost>0?costValueHtml(money(child.cost)+(child.cost_approx?' est':''),true):`<span class=subagentZero title="Measured free-tier price">${money(0)}</span>`)
+   :'<span class=subagentZero>cost unavailable</span>';
+  return `<button class=subagentRow type=button data-open-session="${esc(sessionRowKey(child))}" aria-label="Open subagent run ${esc(title)}">
+ <span class=subagentMain><span class=t>${role}${esc(title)}</span><span class=meta>${esc(detail)}</span></span>
+ <span class=subagentTokens>${childTokens?f(child.tokens)+' tok':'tokens --'}</span>
+ <span class=subagentCost>${costHtml}</span></button>`;
+ }).join('');
+ const more=hidden>0?`<div class=subagentMore>${f(hidden)} more ${countWord(hidden,'run')} not shown</div>`:'';
+ return `<div class=subagents><div class=subagentsHead><span class=subagentsTitle>Subagents <b>${f(children.length)}</b></span><span class=subagentsStats>${stats}</span></div><div class=subagentList>${rows}</div>${more}</div>`;
+}
+function reconcileLogRows(sessions,maxCost,liveSessionIds=new Set()){
+ const root=$('slist');
+ const interactingLogRow=forceAllSessionRowRefresh?null:root.querySelector('.srow:hover,.srow:focus-within');
+ if(interactingLogRow)return;
+ forceAllSessionRowRefresh=false;
+ if(!sessions.length){
+  setLogHtml(root,'<div class="signalEmpty emptyState">No sessions match the selected filters</div>');
+  return;
+ }
+ logHtmlCache.delete(root);
+ const existing=new Map([...root.children].filter(row=>row.dataset.rowKey).map(row=>[row.dataset.rowKey,row]));
+ const desired=new Set();
+ let cursor=root.firstElementChild;
+ const pinnedKey=pinned?(renderedAllSessions.has(pinned)?pinned:(stateSessionId(CURRENT)===pinned?stateSessionKey(CURRENT):'')):'';
+ sessions.forEach(s=>{
+  const key=sessionRowKey(s),rowKey=compareKeyFor(s),active=pinned?key===pinnedKey:Boolean(LATEST&&key===stateSessionKey(LATEST));
+  desired.add(rowKey);
+  let row=existing.get(rowKey);
+  if(!row){
+   row=document.createElement('div');
+   row.dataset.id=key;
+   row.dataset.rowKey=rowKey;
+   row.setAttribute('role','button');
+   row.tabIndex=0;
+  }
+  const live=liveSessionIds.has(key),renderKey=logRowRenderKey(s,active),restoreDeleteFocus=document.activeElement?.dataset.deleteSession===key;
+  const hasChildren=childAgentsFor(s).length>0;
+  const compareIndex=compareIds.indexOf(rowKey);
+  const className=`srow${active?' active':''}${live?' live':''}${hasChildren?' hasChildren':''}${compareIndex>=0?' compareSelected':''}`,ariaLabel=`Open ${s.title}`;
+  if(compareIndex>=0)row.style.setProperty('--compare-color',COMPARE_COLORS[compareIndex]);else row.style.removeProperty('--compare-color');
+  if(row.className!==className)row.className=className;
+  if(row.getAttribute('aria-label')!==ariaLabel)row.setAttribute('aria-label',ariaLabel);
+  if(row._logRenderKey!==renderKey){
+   row.innerHTML=logRowContent(s);
+   row._logRenderKey=renderKey;
+   if(restoreDeleteFocus)requestAnimationFrame(()=>row.querySelector('[data-delete-session]')?.focus({preventScroll:true}));
+  }
+  const bar=row.querySelector('.sbar i'),width=metricAvailable(s,'cost')?Math.max(2,100*(s.cost||0)/maxCost):0,widthValue=`${width}%`;
+  if(bar&&bar.style.width!==widthValue)bar.style.width=widthValue;
+  if(row===cursor)cursor=cursor.nextElementSibling;
+  else root.insertBefore(row,cursor);
+ });
+ [...root.children].forEach(row=>{if(!desired.has(row.dataset.rowKey||''))row.remove();});
+}
+function compareColor(index){return COMPARE_COLORS[index%COMPARE_COLORS.length];}
+function compareKeyFor(row){return String(row?.key||row?.id||'');}
+function compareToggleHtml(s){
+ const id=compareKeyFor(s),index=compareIds.indexOf(id),selected=index>=0,full=!selected&&compareIds.length>=COMPARE_MAX;
+ const label=selected?`Remove ${s.title||'session'} from comparison`:full?`Comparison is full (${COMPARE_MAX} sessions)`:`Add ${s.title||'session'} to comparison`;
+ return `<button class=compareToggle data-compare-toggle="${esc(id)}" data-compare-title="${esc(s.title||'')}" type=button aria-pressed="${selected}"${full?' aria-disabled=true':''} aria-label="${esc(label)}" title="${esc(selected?'Remove from comparison':full?`Comparison is full (${COMPARE_MAX})`:'Add to comparison')}"${selected?` style="--compare-color:${compareColor(index)}"`:''}><svg viewBox="0 0 16 16" aria-hidden=true><path d="M3.5 8.5l3 3 6-7"/></svg></button>`;
+}
+function compareTitle(key){
+ if(!compareTitles.has(key)){
+  const row=(compareData?.sessions||[]).find(item=>item.key===key)||(compareData?.matches||[]).find(item=>item.key===key)||(allSessionInventory||[]).find(item=>compareKeyFor(item)===key);
+  if(row?.title)compareTitles.set(key,row.title);
+ }
+ return compareTitles.get(key)||'Session';
+}
+function setCompareIds(ids,{reload=true}={}){
+ compareIds=[...new Set(ids.map(String).filter(Boolean))].slice(0,COMPARE_MAX);
+ localStorage.setItem('tm_compare_ids',JSON.stringify(compareIds));
+ if(!compareIds.includes(compareBaseline)){
+  compareBaseline=compareIds[0]||'';
+  localStorage.setItem('tm_compare_baseline',compareBaseline);
+ }
+ syncCompareSelectionUi();
+ if(reload&&$('view-session').classList.contains('on')&&sessionScope==='compare')loadComparison();
+}
+function toggleCompareId(id){
+ id=String(id||'');
+ if(!id)return;
+ if(compareIds.includes(id))setCompareIds(compareIds.filter(item=>item!==id));
+ else if(compareIds.length<COMPARE_MAX){compareTitle(id);setCompareIds([...compareIds,id]);}
+}
+function syncCompareSelectionUi(){
+ const count=compareIds.length,full=count>=COMPARE_MAX,badge=$('compare-tab-count');
+ badge.hidden=!count;
+ badge.textContent=count?String(count):'';
+ badge.setAttribute('aria-label',`${count} selected`);
+ document.querySelectorAll('#slist [data-compare-toggle]').forEach(button=>{
+  const id=button.dataset.compareToggle,index=compareIds.indexOf(id),selected=index>=0,row=button.closest('.srow');
+  button.setAttribute('aria-pressed',String(selected));
+  if(!selected&&full)button.setAttribute('aria-disabled','true');else button.removeAttribute('aria-disabled');
+  const title=button.dataset.compareTitle||'session';
+  button.setAttribute('aria-label',selected?`Remove ${title} from comparison`:full?`Comparison is full (${COMPARE_MAX} sessions)`:`Add ${title} to comparison`);
+  button.title=selected?'Remove from comparison':full?`Comparison is full (${COMPARE_MAX})`:'Add to comparison';
+  if(selected){button.style.setProperty('--compare-color',compareColor(index));row?.style.setProperty('--compare-color',compareColor(index));}
+  else{button.style.removeProperty('--compare-color');row?.style.removeProperty('--compare-color');}
+  row?.classList.toggle('compareSelected',selected);
+ });
+ const tray=$('compare-tray');
+ tray.hidden=!count;
+ if(!count){setLogHtml(tray,'');return;}
+ const note=count<2?'Select one more session, or open Compare to find runs with the same title.':full?`Comparison is full (${COMPARE_MAX}).`:'';
+ setLogHtml(tray,`<div class=compareTrayItems>${compareIds.map((id,index)=>`<span class=compareChip><b class=compareLetter style="--compare-color:${compareColor(index)}">${COMPARE_LETTERS[index]}</b><span title="${esc(compareTitle(id))}">${esc(compareTitle(id))}</span><button type=button data-compare-remove="${esc(id)}" aria-label="Remove ${esc(compareTitle(id))} from comparison">×</button></span>`).join('')}</div><div class=compareTrayActions>${note?`<span class=compareTrayNote>${esc(note)}</span>`:''}<button class=tbtn type=button data-compare-open>Compare ${count}</button><button class="tbtn compareClear" type=button data-compare-clear>Clear</button></div>`);
+}
+$('compare-tray').onclick=event=>{
+ const remove=event.target.closest('[data-compare-remove]');
+ if(remove){setCompareIds(compareIds.filter(id=>id!==remove.dataset.compareRemove));return;}
+ if(event.target.closest('[data-compare-open]')){openSessionScope('compare');return;}
+ if(event.target.closest('[data-compare-clear]'))setCompareIds([]);
+};
+async function loadComparison({force=false}={}){
+ const key=compareIds.join(',');
+ if(!compareIds.length){compareData=null;compareError='';compareNotice='';compareMissing=[];compareLoadedKey='';renderComparison();return;}
+ if(!force&&key===compareLoadedKey&&(compareData||compareError))return;
+ const request=++compareRequestSeq;
+ compareLoading=true;
+ if(key!==compareLoadedKey){compareError='';compareNotice='';compareMissing=[];renderComparison();}
+ try{
+  const response=await fetch(`/session/compare?ids=${encodeURIComponent(key)}`,{cache:'no-store'});
+  const payload=await response.json().catch(()=>({}));
+  if(request!==compareRequestSeq)return;
+  const missing=Array.isArray(payload.missing)?payload.missing:[];
+  compareMissing=missing;
+  if(!response.ok||!payload.ok){
+   compareData=null;
+   compareError=payload.error||`Comparison request failed (${response.status}).`;
+  }else{
+   compareError='';
+   compareData=payload;
+   [...(payload.sessions||[]),...(payload.matches||[])].forEach(row=>compareTitles.set(row.key,row.title));
+  }
+  compareNotice=missing.length&&payload.ok?`${missing.length} selected ${countWord(missing.length,'session')} could not be loaded right now.`:'';
+  compareLoadedKey=key;
+  compareLoadedAt=Date.now();
+ }catch(error){
+  if(request!==compareRequestSeq)return;
+  compareError='Token Meter could not load the comparison. Check that the local server is running.';
+  compareLoadedKey=key;
+ }finally{
+  if(request===compareRequestSeq){compareLoading=false;renderComparison();}
+ }
+}
+const COMPARE_ROWS=[
+ {group:'Spend'},
+ {key:'cost',label:'Cost',fmt:(v,s)=>money(v)+(s.cost_approx||s.usage_basis!=='reported'?' est':''),lower:true,tip:COST_UNAVAILABLE_TIP},
+ {key:'cost_per_turn',label:'Cost per execution',fmt:v=>money(v),lower:true},
+ {key:'cache_saved',label:'Saved by cache',fmt:v=>money(v),lower:false},
+ {group:'Tokens'},
+ {key:'tokens',label:'Total tokens',fmt:compactNumber,lower:true},
+ {key:'fresh_input_tokens',label:'Fresh input',fmt:compactNumber,lower:true},
+ {key:'cache_read_tokens',label:'Cache reads',fmt:compactNumber},
+ {key:'cache_write_tokens',label:'Cache writes',fmt:compactNumber,lower:true},
+ {key:'output_tokens',label:'Output',fmt:compactNumber},
+ {key:'cache_hit_ratio',label:'Cache hit rate',fmt:pct,lower:false,points:true},
+ {key:'tokens_per_turn',label:'Tokens per execution',fmt:compactNumber,lower:true},
+ {group:'Work'},
+ {key:'turns',label:'Executions',fmt:f,lower:true},
+ {key:'subagent_turns',label:'Subagent executions',fmt:f},
+ {key:'duration_s',label:'Active time',fmt:waitFmt,lower:true},
+ {key:'wall_duration_s',label:'Wall time',fmt:waitFmt,lower:true},
+ {key:'wait_avg_s',label:'Average wait',fmt:waitFmt,lower:true},
+ {key:'output_tps',label:'Output speed',fmt:v=>`${speedFmt(v)} tok/s`,lower:false},
+ {key:'context_peak',label:'Peak context',fmt:(v,s)=>compactNumber(v)+(s.context_window?` · ${pct(v/s.context_window)}`:''),lower:true},
+ {key:'reasoning_share',label:'Reasoning share',fmt:pct,points:true},
+ {group:'Tools'},
+ {key:'tool_calls',label:'Tool calls',fmt:f},
+ {key:'tool_errors',label:'Tool errors',fmt:f,lower:true},
+ {key:'tools_unique',label:'Distinct tools',fmt:f},
+ {key:'top_tools',label:'Most used',text:s=>(s.top_tools||[]).slice(0,3).map(t=>`${t.name} ${f(t.calls)}`).join(' · ')||'none'},
+];
+const COMPARE_SETUP_ROWS=[
+ {label:'App',text:s=>s.label||s.provider||'--'},
+ {label:'Model',text:s=>s.primary_model||(s.models||[]).join(', ')||'--'},
+ {label:'Reasoning effort',text:s=>s.reasoning_effort||'default'},
+ {label:'Project',text:s=>projectFilterLabel(s.project||'')||'local'},
+ {label:'Started',text:s=>s.start||'--',same:true},
+];
+function compareDelta(row,value,base){
+ if(value==null||base==null||row.text)return '';
+ if(row.points){
+  const diff=Math.round(100*(value-base));
+  if(!diff)return '<span class=compareDelta>same</span>';
+  const better=row.lower===undefined?'':(diff<0)===row.lower?' better':' worse';
+  return `<span class="compareDelta${better}">${diff>0?'+':'−'}${Math.abs(diff)} pts</span>`;
+ }
+ if(value===base)return '<span class=compareDelta>same</span>';
+ if(!base)return '';
+ const ratio=(value-base)/Math.abs(base),better=row.lower===undefined?'':(ratio<0)===row.lower?' better':' worse';
+ const text=Math.abs(ratio)>=1.95?`${(value/base).toFixed(1)}×`:`${ratio>0?'+':'−'}${Math.round(Math.abs(ratio)*100)}%`;
+ return `<span class="compareDelta${better}">${text}</span>`;
+}
+function compareTableHtml(sessions,best){
+ const baseline=sessions.find(s=>s.key===compareBaseline)||sessions[0];
+ const head=`<thead><tr><th scope=col>Metric</th>${sessions.map((s,i)=>`<th scope=col><span class=compareLetter style="--compare-color:${compareColor(i)}">${s.letter}</span>${s.key===baseline.key?'Baseline':'vs '+esc(baseline.letter)}</th>`).join('')}</tr></thead>`;
+ const setup=COMPARE_SETUP_ROWS.map(row=>{
+  const values=sessions.map(row.text),differs=!row.same&&new Set(values).size>1;
+  return `<tr${differs?' class=differs':''}><td>${esc(row.label)}</td>${values.map(value=>`<td class=text title="${esc(value)}">${esc(value)}</td>`).join('')}</tr>`;
+ }).join('');
+ const body=COMPARE_ROWS.map(row=>{
+  if(row.group)return `<tr class=compareGroup><th colspan=${sessions.length+1} scope=colgroup>${esc(row.group)}</th></tr>`;
+  if(row.text)return `<tr><td>${esc(row.label)}</td>${sessions.map(s=>`<td class=text title="${esc(row.text(s))}">${esc(row.text(s))}</td>`).join('')}</tr>`;
+  if(sessions.every(s=>s[row.key]==null))return '';
+  return `<tr><td>${esc(row.label)}</td>${sessions.map(s=>{
+   const value=s[row.key];
+   if(value==null)return `<td class="mono compareUnavailable"${row.key==='cost'?` ${tipAttrs(COST_UNAVAILABLE_TIP)}`:' title="Not reported for this session"'}>--</td>`;
+   const isBest=best[row.key]===s.key,delta=s.key===baseline.key?'':compareDelta(row,value,baseline[row.key]);
+   return `<td class=mono>${esc(row.fmt(value,s))}${isBest?'<span class=compareBest>best</span>':''}${delta}</td>`;
+  }).join('')}</tr>`;
+ }).join('');
+ return `<div class=compareTableWrap><table class=compareTable><caption class=compareCaption>Metric comparison against the baseline session</caption>${head}<tbody><tr class=compareGroup><th colspan=${sessions.length+1} scope=colgroup>Setup</th></tr>${setup}${body}</tbody></table></div>`;
+}
+function compareChartHtml(sessions){
+ const metric=compareChartMetric==='cost'&&sessions.some(s=>s.cost!=null)?'cost':'tokens';
+ const lines=sessions.map((s,i)=>({s,i,points:(s.series||[]).filter(p=>p[metric]!=null)})).filter(line=>line.points.length);
+ const toggle=`<div class=seg role=group aria-label="Chart metric"><button type=button data-compare-chart=cost aria-pressed="${metric==='cost'}" class="${metric==='cost'?'on':''}">Cost</button><button type=button data-compare-chart=tokens aria-pressed="${metric==='tokens'}" class="${metric==='tokens'?'on':''}">Tokens</button></div>`;
+ const head=`<div class=compareSectionHead><h3>Cumulative ${metric==='cost'?'cost':'tokens'} by execution</h3>${toggle}</div>`;
+ if(!lines.length)return `<section class="card compareSection">${head}<div class="signalEmpty emptyState">No execution series is available for these sessions.</div></section>`;
+ const VW=1040,VH=250,ML=64,MR=74,MT=14,MB=30,PW=VW-ML-MR,PH=VH-MT-MB;
+ const maxX=Math.max(1,...lines.map(line=>line.points[line.points.length-1].i)),maxY=Math.max(metric==='cost'?.001:1,...lines.map(line=>Math.max(...line.points.map(p=>p[metric]))));
+ const x=v=>ML+PW*(v/maxX),y=v=>MT+PH*(1-v/maxY),fmt=metric==='cost'?money:compactNumber;
+ let svg='';
+ for(let k=0;k<=4;k++){const yy=MT+PH*k/4;svg+=`<line x1="${ML}" x2="${ML+PW}" y1="${yy}" y2="${yy}" stroke="${CHART.grid}"/><text x="${ML-8}" y="${yy+4}" text-anchor="end" fill="${CHART.lbl}" font-size="11">${esc(fmt(maxY*(1-k/4)))}</text>`;}
+ const ticks=Math.min(8,maxX);
+ for(let k=0;k<=ticks;k++){const v=Math.round(maxX*k/ticks);svg+=`<text x="${x(v)}" y="${VH-10}" text-anchor="middle" fill="${CHART.lbl}" font-size="11">${f(v)}</text>`;}
+ lines.forEach(line=>{
+  const pts=[{i:0,[metric]:0},...line.points],color=compareColor(line.i),last=line.points[line.points.length-1];
+  svg+=`<path d="${pts.map((p,k)=>`${k?'L':'M'}${x(p.i).toFixed(1)},${y(p[metric]).toFixed(1)}`).join(' ')}" fill="none" stroke="${color}" stroke-width="2.4" stroke-linejoin="round" stroke-linecap="round"/><circle cx="${x(last.i)}" cy="${y(last[metric])}" r="4" fill="${color}" stroke="${CHART.ink}" stroke-width="2"/><text x="${Math.min(VW-4,x(last.i)+8)}" y="${y(last[metric])+4}" fill="${color}" font-size="11" font-weight="700"${x(last.i)+8>VW-MR?' text-anchor="end"':''}>${line.s.letter} ${esc(fmt(last[metric]))}</text>`;
+ });
+ const label=lines.map(line=>`${line.s.letter}: ${fmt(line.points[line.points.length-1][metric])} over ${f(line.points[line.points.length-1].i)} executions`).join('; ');
+ return `<section class="card compareSection">${head}<svg class=compareChart viewBox="0 0 ${VW} ${VH}" role=img aria-label="${esc(`Cumulative ${metric} by execution. ${label}`)}">${svg}<text x="${ML+PW}" y="${VH-10}" text-anchor="end" fill="${CHART.lbl}" font-size="11" dx="${MR-4}">execution</text></svg><div class=compareLegend>${lines.map(line=>`<span><i style="--compare-color:${compareColor(line.i)}"></i>${line.s.letter} · ${esc(line.s.title)}</span>`).join('')}</div></section>`;
+}
+function compareBreakdownHtml(sessions){
+ const rows=sessions.map((s,i)=>({s,i})).filter(row=>row.s.cost_parts&&row.s.cost>0);
+ if(!rows.length)return '';
+ const parts=[['input','Fresh input','var(--c-input)'],['cache_write','Cache writes','var(--c-cache-write)'],['cache_read','Cache reads','var(--c-cache-read)'],['output','Output','var(--c-output)'],['server_tools','Server tools','var(--faint)']];
+ const max=Math.max(...rows.map(row=>row.s.cost));
+ return `<section class="card compareSection"><h3>Where the cost went</h3><div class=compareBreakdown>${rows.map(({s,i})=>`<div class=compareBreakdownRow><span class=compareLetter style="--compare-color:${compareColor(i)}">${s.letter}</span><div class=compareBreakdownBar role=img aria-label="${esc(`${s.letter}: `+parts.filter(([key])=>s.cost_parts[key]>0).map(([key,label])=>`${label} ${money(s.cost_parts[key])}`).join(', '))}" style="width:${Math.max(4,100*s.cost/max)}%">${parts.filter(([key])=>s.cost_parts[key]>0).map(([key,label,color])=>`<i style="width:${100*s.cost_parts[key]/s.cost}%;background:${color}" title="${esc(`${label}: ${money(s.cost_parts[key])}`)}"></i>`).join('')}</div><b class=mono>${esc(money(s.cost))}</b></div>`).join('')}</div><div class=compareLegend>${parts.filter(([key])=>rows.some(row=>row.s.cost_parts[key]>0)).map(([,label,color])=>`<span><i class=part style="background:${color}"></i>${label}</span>`).join('')}</div></section>`;
+}
+function compareMatchesHtml(matches,sessions){
+ const full=compareIds.length>=COMPARE_MAX,same=sessions.length&&sessions.every(s=>s.title_key&&s.title_key===sessions[0].title_key);
+ const heading=same||sessions.length===1?'Other runs with the same title':'Other runs with a matching title';
+ const body=(matches||[]).length?`<div class=compareMatches>${matches.map(m=>`<div class=compareMatch><div style="min-width:0"><div class=t title="${esc(m.title)}">${esc(m.title)}</div><div class=meta>${esc(m.label)} · ${esc((m.models||[]).join(', ')||'model unknown')} · ${esc(m.last||m.start||'')} · ${f(m.turns)} execs · ${m.cost==null?'cost unavailable':esc(money(m.cost))}</div></div><div class=compareMatchActions><button class=tbtn type=button data-compare-open-session="${esc(m.open_id||m.id)}">Open</button><button class=tbtn type=button data-compare-add="${esc(m.key)}"${full?' disabled title="Comparison is full"':''}>Add</button></div></div>`).join('')}</div>`:'<div class="signalEmpty emptyState">No other recorded sessions share these titles yet. Run the same prompt again and the new session will appear here.</div>';
+ return `<section class="card compareSection"><h3>${heading}</h3>${body}</section>`;
+}
+function renderComparison(){
+ const root=$('compare-body');
+ if(!root)return;
+ const notice=compareNotice?`<div class=compareNote role=status>${esc(compareNotice)} <button class="tbtn compareClear" type=button data-compare-drop-missing>Remove ${compareMissing.length>1?'them':'it'}</button> <button class="tbtn compareClear" type=button data-compare-retry>Try again</button></div>`:'';
+ if(!compareIds.length){
+  root.innerHTML=`${notice}<section class="card compareEmpty emptyState"><h3>No sessions selected</h3><p>Pick up to ${COMPARE_MAX} sessions in All sessions.</p><button class=tbtn type=button data-compare-pick>Choose sessions</button></section>`;
+  return;
+ }
+ if(compareError){root.innerHTML=`${notice}<section class="card compareEmpty emptyState"><h3>Comparison unavailable</h3><p>${esc(compareError)}</p><button class=tbtn type=button data-compare-retry>Try again</button>${compareMissing.length?' <button class="tbtn compareClear" type=button data-compare-drop-missing>Remove unavailable</button>':''}</section>`;return;}
+ if(!compareData||compareLoadedKey!==compareIds.join(',')&&compareLoading){root.innerHTML=`${notice}<section class="card compareEmpty emptyState"><p>Loading comparison…</p></section>`;return;}
+ const sessions=compareData.sessions||[],best=compareData.best||{};
+ if(!sessions.some(s=>s.key===compareBaseline))compareBaseline=sessions[0]?.key||'';
+ const cards=`<div class=compareCards style="grid-template-columns:repeat(${Math.max(2,sessions.length)},minmax(0,1fr))">${sessions.map((s,i)=>{
+  const baseline=s.key===compareBaseline;
+  return `<article class="card compareCard" style="--compare-color:${compareColor(i)}"><div class=compareCardTop><span class=compareLetter>${s.letter}</span><span class="badge app ${appBadgeClass(s)}">${runtimeMarkSvg(s)}${esc(s.label||s.provider)}</span>${baseline&&sessions.length>1?'<span class=compareBaselineTag>Baseline</span>':''}</div><div class=compareCardTitle title="${esc(s.title)}">${esc(s.title)}</div><div class=compareCardMeta>${esc(s.primary_model||(s.models||[]).join(', ')||'model unknown')} · ${esc(s.start||'')}</div><div class="compareCardCost mono">${s.cost==null?costValueHtml('',false):esc(money(s.cost)+(s.cost_approx||s.usage_basis!=='reported'?' est':''))}</div><div class=compareCardMeta>${f(s.turns)} execs · ${s.duration_s==null?'time unavailable':esc(waitFmt(s.duration_s))+' active'} · ${s.tokens==null?'tokens unavailable':esc(compactNumber(s.tokens))+' tok'}</div><div class=compareCardActions><button type=button data-compare-open-session="${esc(s.open_id||s.id)}">Open</button>${sessions.length>1?`<button type=button data-compare-baseline="${esc(s.key)}"${baseline?' disabled':''}>${baseline?'Baseline':'Set as baseline'}</button>`:''}<button type=button data-compare-remove="${esc(s.key)}">Remove</button></div></article>`;
+ }).join('')}</div>`;
+ if(sessions.length<2){
+  root.innerHTML=`${notice}${cards}<section class="card compareEmpty emptyState"><h3>Add one more session</h3><p>Pick another session in All sessions, or add a matching run below, to see side-by-side metrics.</p><button class=tbtn type=button data-compare-pick>Choose sessions</button></section>${compareMatchesHtml(compareData.matches,sessions)}`;
+  return;
+ }
+ const winner=(key,label,fmt)=>{
+  const index=sessions.findIndex(s=>s.key===best[key]),s=sessions[index],known=sessions.filter(row=>row[key]!=null);
+  const value=s?`<span class=compareLetter style="--compare-color:${compareColor(index)}">${s.letter}</span>${esc(fmt(s))}`:known.length>=2?'Tied':'--';
+  const note=s?esc(s.title):known.length>=2?`All at ${esc(fmt(known[0]))}`:'Not reported for enough sessions';
+  return `<div class=metric><span>${label}</span><strong>${value}</strong><small${s?` title="${esc(s.title)}"`:''}>${note}</small></div>`;
+ };
+ const winners=`<section class="card compareSection"><div class=compareWinners>${winner('cost','Cheapest',s=>money(s.cost)+(s.cost_approx||s.usage_basis!=='reported'?' est':''))}${winner('duration_s','Fastest',s=>waitFmt(s.duration_s)+' active')}</div></section>`;
+ const table=`<section class="card compareSection"><div class=compareSectionHead><h3>Side by side</h3><span class=allSessionsHint>Deltas are against baseline ${esc((sessions.find(s=>s.key===compareBaseline)||sessions[0]).letter)} · unavailable evidence shows --</span></div>${compareTableHtml(sessions,best)}</section>`;
+ root.innerHTML=notice+cards+winners+table+compareChartHtml(sessions)+compareBreakdownHtml(sessions)+compareMatchesHtml(compareData.matches,sessions);
+}
+$('session-compare').onclick=event=>{
+ const target=event.target.closest('button');
+ if(!target||target.disabled)return;
+ if(target.id==='compare-pick'||target.hasAttribute('data-compare-pick')){openSessionScope('all');return;}
+ if(target.id==='compare-clear'){compareNotice='';setCompareIds([]);return;}
+ if(target.hasAttribute('data-compare-retry')){loadComparison({force:true});return;}
+ if(target.hasAttribute('data-compare-drop-missing')){const drop=new Set(compareMissing);compareNotice='';compareMissing=[];setCompareIds(compareIds.filter(id=>!drop.has(id)));return;}
+ if(target.dataset.compareRemove){compareNotice='';setCompareIds(compareIds.filter(id=>id!==target.dataset.compareRemove));return;}
+ if(target.dataset.compareAdd){compareNotice='';toggleCompareId(target.dataset.compareAdd);return;}
+ if(target.dataset.compareBaseline){compareBaseline=target.dataset.compareBaseline;localStorage.setItem('tm_compare_baseline',compareBaseline);renderComparison();return;}
+ if(target.dataset.compareChart){compareChartMetric=target.dataset.compareChart;localStorage.setItem('tm_compare_chart',compareChartMetric);renderComparison();return;}
+ if(target.dataset.compareOpenSession)selectSession(target.dataset.compareOpenSession,{returnScope:'compare'});
+};
+compareUiReady=true;
+renderSessionScope();
diff --git a/dashboard/js/spend.js b/dashboard/js/spend.js
new file mode 100644
index 00000000..53f2f89b
--- /dev/null
+++ b/dashboard/js/spend.js
@@ -0,0 +1,535 @@
+function localDayKey(date=new Date()){
+ const y=date.getFullYear(),m=String(date.getMonth()+1).padStart(2,'0'),d=String(date.getDate()).padStart(2,'0');
+ return `${y}-${m}-${d}`;
+}
+function dayLabel(day){
+ if(!day)return 'No date';
+ return new Date(`${day}T12:00:00`).toLocaleDateString([],{weekday:'short',month:'short',day:'numeric',year:'numeric'});
+}
+function shortDayLabel(day){
+ if(!day)return '--';
+ return new Date(`${day}T12:00:00`).toLocaleDateString([],{month:'short',day:'numeric'});
+}
+function dailyDeltaLabel(current,baseline){
+ current=Number(current||0);baseline=Number(baseline||0);
+ if(!baseline)return current?'New':'0%';
+ const value=Math.round(100*(current-baseline)/baseline);
+ return value>0?`+${value}%`:value<0?`\u2212${Math.abs(value)}%`:'0%';
+}
+// spend-range-logic-start
+const SPEND_RUNTIME_COLORS={claude:'var(--provider-claude)',codex:'var(--provider-codex)',cursor:'var(--provider-cursor)',opencode:'var(--provider-opencode)',kiro:'var(--provider-kiro)',unknown:'var(--provider-other)'};
+const SPEND_RUNTIME_ORDER=['claude','codex','cursor','opencode','kiro','unknown'];
+const SPEND_RUNTIME_LABELS={claude:'Claude',codex:'Codex',cursor:'Cursor',opencode:'OpenCode',kiro:'Kiro',unknown:'Unknown'};
+function spendDayDate(day){
+ const match=/^(\d{4})-(\d{2})-(\d{2})$/.exec(String(day||''));
+ if(!match)return null;
+ const date=new Date(Number(match[1]),Number(match[2])-1,Number(match[3]),12,0,0,0);
+ return date.getFullYear()===Number(match[1])&&date.getMonth()===Number(match[2])-1&&date.getDate()===Number(match[3])?date:null;
+}
+function spendDayKey(date){return `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;}
+function spendShiftDay(day,amount){const date=spendDayDate(day);if(!date)return '';date.setDate(date.getDate()+amount);return spendDayKey(date);}
+function spendRangeWindow(range,from='',to='',now=new Date(),earliest=''){
+ const end=spendDayKey(now);
+ if(range==='all'){
+  const start=spendDayDate(earliest)&&earliest<end?earliest:end;
+  return {valid:true,start,end,dayCount:Math.round((spendDayDate(end)-spendDayDate(start))/86400000)+1,error:''};
+ }
+ if(range==='yesterday'){const day=spendShiftDay(end,-1);return {valid:true,start:day,end:day,dayCount:1,error:''};}
+ if(range==='month'){
+  const startDate=new Date(now.getFullYear(),now.getMonth(),1,12,0,0,0),endDate=spendDayDate(end);
+  return {valid:true,start:spendDayKey(startDate),end,dayCount:Math.round((endDate-startDate)/86400000)+1,error:''};
+ }
+ if(range==='last_month'){
+  const startDate=new Date(now.getFullYear(),now.getMonth()-1,1,12,0,0,0),endDate=new Date(now.getFullYear(),now.getMonth(),0,12,0,0,0);
+  return {valid:true,start:spendDayKey(startDate),end:spendDayKey(endDate),dayCount:endDate.getDate(),error:''};
+ }
+ if(range==='custom'){
+  const startDate=spendDayDate(from),endDate=spendDayDate(to);
+  if(!startDate||!endDate)return {valid:false,start:from,end:to,dayCount:0,error:'Choose both From and To dates.'};
+  if(from>to)return {valid:false,start:from,end:to,dayCount:0,error:'From must be on or before To.'};
+  const dayCount=Math.round((endDate-startDate)/86400000)+1;
+  return {valid:true,start:from,end:to,dayCount,error:''};
+ }
+ const dayCount=range==='today'?1:Number(range);
+ const count=[1,7,30,90].includes(dayCount)?dayCount:7;
+ return {valid:true,start:spendShiftDay(end,1-count),end,dayCount:count,error:''};
+}
+function spendPreviousWindow(window){
+ const end=spendShiftDay(window.start,-1),start=spendShiftDay(end,1-window.dayCount);
+ return {valid:true,start,end,dayCount:window.dayCount,error:''};
+}
+function spendCalendarRows(days,window){
+ if(!window?.valid)return [];
+ const byDay=new Map((days||[]).filter(row=>spendDayDate(row?.day)).map(row=>[row.day,row]));
+ const rows=[];
+ for(let day=window.start,guard=0;day&&day<=window.end&&guard<10000;day=spendShiftDay(day,1),guard++){
+  const source=byDay.get(day);
+  rows.push(source?{...source,cost:Number(source.cost||0),providers:source.providers||[],hasActivity:true}:{day,cost:0,providers:[],coverage:{},provenance:{},usage_basis:'unavailable',availability:{cost:true},hasActivity:false});
+ }
+ return rows;
+}
+function spendRuntimeKey(provider){
+ const value=String(provider||'').toLowerCase().replace(/[^a-z0-9]/g,'');
+ return SPEND_RUNTIME_ORDER.slice(0,-1).find(key=>value.includes(key))||'unknown';
+}
+function spendRuntimeIdentity(provider){
+ const raw=String(provider||'unknown').trim()||'unknown',key=spendRuntimeKey(raw);
+ return {id:key==='unknown'?`unknown:${raw.toLowerCase()}`:key,key,label:key==='unknown'&&raw.toLowerCase()!=='unknown'?raw:SPEND_RUNTIME_LABELS[key]};
+}
+function spendRuntimeTotals(rows){
+ const totals=new Map();
+ (rows||[]).forEach(day=>(day.providers||[]).forEach(provider=>{
+  const identity=spendRuntimeIdentity(provider.provider),current=totals.get(identity.id)||{...identity,cost:0,estimated:false,partial:false,unavailable:false};
+  current.cost+=Number(provider.cost||0);
+  current.estimated=current.estimated||['local_estimate','mixed'].includes(provider.usage_basis)||['local_estimate','mixed'].includes(provider.provenance?.usage_basis);
+  current.unavailable=current.unavailable||provider.availability?.cost===false;
+  current.partial=current.partial||provider.coverage?.cost?.complete===false||provider.availability?.cost===false;
+  totals.set(identity.id,current);
+ }));
+ return [...totals.values()].sort((a,b)=>SPEND_RUNTIME_ORDER.indexOf(a.key)-SPEND_RUNTIME_ORDER.indexOf(b.key)||a.label.localeCompare(b.label));
+}
+// Four equal axis divisions on a round step, so every tick reads as a plain number.
+function spendNiceMax(value){
+ value=Math.max(0,Number(value)||0);
+ if(!value||!Number.isFinite(value))return 1;
+ const step=value*1.02/4,magnitude=10**Math.floor(Math.log10(step));
+ const factor=[1,1.25,1.5,2,2.5,3,4,5,6,8,10].find(item=>(item!==1.25||magnitude>=10)&&item*magnitude>=step*(1-1e-12));
+ return Math.max(1,Number((4*factor*magnitude).toPrecision(12)));
+}
+const SPEND_GRANULARITIES=['day','week','month'];
+function normalizeSpendGranularity(value){return SPEND_GRANULARITIES.includes(value)?value:'day';}
+function spendBucketStart(day,granularity){
+ const date=spendDayDate(day);if(!date)return '';
+ if(granularity==='week')date.setDate(date.getDate()-(date.getDay()+6)%7);
+ else if(granularity==='month')date.setDate(1);
+ return spendDayKey(date);
+}
+function spendBucketEnd(start,granularity){
+ if(granularity==='week')return spendShiftDay(start,6);
+ if(granularity==='month'){const date=spendDayDate(start);return date?spendDayKey(new Date(date.getFullYear(),date.getMonth()+1,0,12,0,0,0)):'';}
+ return start;
+}
+function spendIsEstimated(row){return ['local_estimate','mixed'].includes(row?.usage_basis)||['local_estimate','mixed'].includes(row?.provenance?.usage_basis);}
+function spendBucketRows(rows,granularity,today=''){
+ granularity=normalizeSpendGranularity(granularity);
+ if(granularity==='day')return (rows||[]).map(row=>({...row,granularity,start:row.day,end:row.day,bucketStart:row.day,bucketEnd:row.day,days:1,fullDays:1,clipped:false,inProgress:row.day===today,incomplete:row.day===today}));
+ const buckets=[],byKey=new Map();
+ (rows||[]).forEach(row=>{
+  const key=spendBucketStart(row.day,granularity);if(!key)return;
+  let bucket=byKey.get(key);
+  if(!bucket){
+   const bucketEnd=spendBucketEnd(key,granularity);
+   bucket={day:row.day,granularity,start:row.day,end:row.day,bucketStart:key,bucketEnd,days:0,fullDays:Math.round((spendDayDate(bucketEnd)-spendDayDate(key))/86400000)+1,cost:0,providers:[],hasActivity:false,availability:{cost:true},coverage:{cost:{complete:true}},usage_basis:'',provenance:{}};
+   byKey.set(key,bucket);buckets.push(bucket);
+  }
+  bucket.end=row.day;bucket.days+=1;bucket.cost+=Number(row.cost||0);
+  bucket.providers.push(...(row.providers||[]));
+  if(!row.hasActivity)return;
+  bucket.hasActivity=true;
+  if(row.availability?.cost===false)bucket.availability.cost=false;
+  if(row.coverage?.cost?.complete===false)bucket.coverage.cost.complete=false;
+  if(spendIsEstimated(row))bucket.usage_basis='mixed';
+ });
+ return buckets.map(bucket=>{
+  const clipped=bucket.days<bucket.fullDays,inProgress=Boolean(today)&&bucket.start<=today&&today<=bucket.bucketEnd;
+  return {...bucket,clipped,inProgress,incomplete:clipped||inProgress};
+ });
+}
+function spendGranularityOptions(rows,today=''){
+ return Object.fromEntries(SPEND_GRANULARITIES.map(granularity=>{
+  if(granularity==='day')return [granularity,true];
+  const buckets=spendBucketRows(rows,granularity,today);
+  return [granularity,buckets.length>=2&&buckets.some(bucket=>!bucket.incomplete)];
+ }));
+}
+function spendAutoGranularity(dayCount){return dayCount>186?'month':dayCount>35?'week':'day';}
+function spendResolveGranularity(choice,rows,today=''){
+ const options=spendGranularityOptions(rows,today),order=['month','week','day'];
+ const wanted=SPEND_GRANULARITIES.includes(choice)?choice:spendAutoGranularity((rows||[]).length);
+ return {granularity:order.slice(order.indexOf(wanted)).find(granularity=>options[granularity])||'day',options};
+}
+function spendAverageBasis(buckets){
+ return (buckets||[]).filter(row=>row.granularity==='day'||!row.incomplete);
+}
+function spendAverageReference(rows,axisMax){
+ const costs=(rows||[]).map(row=>{const value=Number(row?.cost||0);return Number.isFinite(value)&&value>0?value:0;});
+ if(!costs.length)return {value:0,ratio:0};
+ const value=costs.reduce((sum,cost)=>sum+cost,0)/costs.length,max=Number(axisMax)||0;
+ return {value,ratio:max>0?Math.min(1,Math.max(0,value/max)):0};
+}
+function spendDayNavigation(rows,focusDay=''){
+ const days=(rows||[]).map(row=>row.day),resolved=days.includes(focusDay)?focusDay:(days.at(-1)||'');
+ return {focusDay:resolved,buttons:days.map(day=>({day,tabIndex:day===resolved?0:-1,selected:false}))};
+}
+function spendSessionMetricValue(row,metric){
+ let value=null;
+ if(metric==='cost'&&row?.availability?.cost===true)value=Number(row.cost);
+ else if(metric==='input'&&(row?.availability?.input_tokens===true||row?.availability?.tokens===true))value=Number(row.input_tokens);
+ else if(metric==='executions'&&row?.turns!==null&&row?.turns!==undefined)value=Number(row.turns);
+ else if(metric==='active'&&row?.duration_available===true)value=Number(row.duration_s);
+ return Number.isFinite(value)&&value>=0?value:null;
+}
+function spendQuantile(values,quantile){
+ const sorted=(values||[]).filter(value=>Number.isFinite(value)).slice().sort((a,b)=>a-b);
+ if(!sorted.length)return 0;
+ const position=(sorted.length-1)*quantile,lower=Math.floor(position),upper=Math.ceil(position),weight=position-lower;
+ return sorted[lower]+(sorted[upper]-sorted[lower])*weight;
+}
+function spendDistribution(values){
+ const clean=(values||[]).filter(value=>Number.isFinite(value));
+ if(!clean.length)return {count:0,p10:0,p25:0,median:0,mean:0,p75:0,p90:0};
+ return {count:clean.length,p10:spendQuantile(clean,.1),p25:spendQuantile(clean,.25),median:spendQuantile(clean,.5),mean:clean.reduce((sum,value)=>sum+value,0)/clean.length,p75:spendQuantile(clean,.75),p90:spendQuantile(clean,.9)};
+}
+function spendSessionAnalytics(rows){
+ rows=rows||[];
+ const coveredCosts=rows.map(row=>spendSessionMetricValue(row,'cost')).filter(value=>value!==null).sort((a,b)=>b-a),total=coveredCosts.reduce((sum,value)=>sum+value,0),topCount=coveredCosts.length?Math.ceil(coveredCosts.length*.1):0,topCost=coveredCosts.slice(0,topCount).reduce((sum,value)=>sum+value,0);
+ return {
+  concentration:{covered:coveredCosts.length,total,top_count:topCount,top_cost:topCost,top_share:total?topCost/total:0},
+  distributions:{
+   cost:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'cost')).filter(value=>value!==null)),
+   input:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'input')).filter(value=>value!==null)),
+   executions:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'executions')).filter(value=>value!==null)),
+   active:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'active')).filter(value=>value!==null)),
+  },
+ };
+}
+function spendScatterRows(rows,metric){
+ const valueMetric=metric==='input'?'input':'cost';
+ return (rows||[]).filter(row=>{
+  const active=spendSessionMetricValue(row,'active'),value=spendSessionMetricValue(row,valueMetric);
+  return active!==null&&active>0&&value!==null&&value>=0;
+ });
+}
+function normalizeSpendRangeChoice(value){return ['today','yesterday','7','30','90','month','last_month','all','custom'].includes(value)?value:'30';}
+// spend-range-logic-end
+const SPEND_RANGE_KEY='tm_spend_range_v1';
+const SPEND_SCATTER_METRIC_KEY='tm_spend_scatter_metric_v1';
+let spendGranularityChoice='auto',spendChartRows=[];
+let spendRangeChoice='30',spendCustomFrom='',spendCustomTo='',spendFocusDay='',spendInspectDay='',spendCurrentRows=[],spendCurrentWindow=null,spendCurrentSource=[],spendResizeTimer=0,spendLogsRequestKey='',spendLogsRenderedRange='',spendLogsRequestSeq=0,spendInsightPayload=null,spendInsightRenderKey='',spendScatterMetric=localStorage.getItem(SPEND_SCATTER_METRIC_KEY)==='input'?'input':'cost';
+try{
+ const saved=JSON.parse(localStorage.getItem(SPEND_RANGE_KEY)||'{}');
+ spendRangeChoice=normalizeSpendRangeChoice(saved.range);
+ spendCustomFrom=String(saved.from||'');spendCustomTo=String(saved.to||'');
+}catch(error){}
+function persistSpendRange(){try{localStorage.setItem(SPEND_RANGE_KEY,JSON.stringify({range:spendRangeChoice,from:spendCustomFrom,to:spendCustomTo}));}catch(error){}}
+function openMonthSpend(){
+ spendRangeChoice='month';spendGranularityChoice='auto';persistSpendRange();setHashRoute('spend');
+}
+$('current-month-spend').onclick=openMonthSpend;
+function spendRangeLabel(window){return window.dayCount===1?dayLabel(window.start):`${dayLabel(window.start)} – ${dayLabel(window.end)}`;}
+function spendPct(value){value=Number(value||0);return value>0&&value<.01?'<1%':pct(value);}
+function spendEvidence(rows){
+ const active=rows.filter(row=>row.hasActivity),unavailable=active.some(row=>row.availability?.cost===false);
+ const partial=active.some(row=>row.coverage?.cost?.complete===false||row.availability?.cost===false);
+ const estimated=active.some(row=>['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis));
+ return {active:active.length,unavailable,partial,estimated,allUnavailable:Boolean(active.length)&&active.every(row=>row.availability?.cost===false)};
+}
+function spendDayDetails(row){
+ const runtimes=spendRuntimeTotals([row]),available=row.availability?.cost!==false,total=Number(row.cost||0);
+ if(!row.hasActivity)return {totalText:money(0),note:'no recorded activity',runtimes};
+ if(!available&&!total)return {totalText:'Unavailable',note:'recorded activity has no cost evidence',runtimes};
+ const partial=row.coverage?.cost?.complete===false||!available,estimated=['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis);
+ return {totalText:money(total),note:[partial?'partial coverage':'',estimated?'estimated':''].filter(Boolean).join(' · '),runtimes};
+}
+const SPEND_GRANULARITY_COPY={
+ day:{unit:'day',total:'Daily total',note:'Line = average'},
+ week:{unit:'wk',total:'Weekly total',note:'Line = average'},
+ month:{unit:'mo',total:'Monthly total',note:'Line = average'},
+};
+function spendMonthLabel(day,style='long'){return new Date(`${day}T12:00:00`).toLocaleDateString([],style==='long'?{month:'long',year:'numeric'}:{month:'short'});}
+function spendBucketLabel(row){
+ if(row.granularity==='week')return `Week of ${shortDayLabel(row.bucketStart)}`;
+ if(row.granularity==='month')return spendMonthLabel(row.bucketStart);
+ return dayLabel(row.day);
+}
+function spendBucketNote(row){
+ if(row.granularity==='day')return row.inProgress?'today, still in progress':'';
+ const unit=row.granularity==='week'?'week':'month';
+ if(row.clipped)return `partial ${unit} · ${row.days} of ${row.fullDays} days in range${row.inProgress?' · in progress':''}`;
+ return row.inProgress?`${unit} in progress`:'';
+}
+function spendDayAria(row){
+ const details=spendDayDetails(row),parts=details.runtimes.filter(runtime=>runtime.cost>0||runtime.unavailable).map(runtime=>`${runtime.label} ${runtime.unavailable&&!runtime.cost?'cost unavailable':money(runtime.cost)}${runtime.estimated?' estimated':''}${runtime.partial?' partial':''}`),bucketNote=spendBucketNote(row);
+ return `${spendBucketLabel(row)}, ${details.totalText}${details.note?`, ${details.note}`:''}${bucketNote?`, ${bucketNote}`:''}${parts.length?`, ${parts.join(', ')}`:''}`;
+}
+function spendAxisText(row,spansYears){
+ if(row.granularity==='month'){const label=spendMonthLabel(row.bucketStart,'short');return spansYears||row.bucketStart.endsWith('-01-01')?`${label} ’${row.bucketStart.slice(2,4)}`:label;}
+ return shortDayLabel(row.granularity==='week'?row.bucketStart:row.day);
+}
+function spendAxisLabel(row,index,count,chartWidth,spansYears=false){
+ const maxLabels=Math.max(2,Math.floor(Math.max(1,chartWidth)/54));
+ const step=Math.max(1,Math.ceil(Math.max(1,count-1)/Math.max(1,maxLabels-1)));
+ return index===0||index===count-1||(index%step===0&&count-1-index>=step)?spendAxisText(row,spansYears):'';
+}
+function spendBarBody(row,index,count,axisMax,chartWidth,spansYears){
+ const runtimes=spendRuntimeTotals([row]).filter(runtime=>runtime.cost>0),total=Number(row.cost||0),height=total?Math.max(1.5,100*total/axisMax):0;
+ const segments=runtimes.map(runtime=>`<i class=spendStackSegment data-estimated="${runtime.estimated}" data-partial="${runtime.partial}" style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]};--segment-share:${total?100*runtime.cost/total:0}%"></i>`).join('');
+ const axisLabel=spendAxisLabel(row,index,count,chartWidth,spansYears);
+ return `<span class=spendDayTrack><span class="spendBarValue mono">${total?money(total):''}</span>${total?`<span class=spendDayStack style="--spend-height:${height}%">${segments}</span>`:''}</span><span class=spendDayLabel>${esc(axisLabel)}</span>`;
+}
+function renderSpendAxis(axisMax){
+ const ticks=[1,.75,.5,.25,0].map(ratio=>`<span>${money(axisMax*ratio)}</span>`).join('');
+ if($('s-y-axis')._spendTicks!==ticks){$('s-y-axis').innerHTML=ticks;$('s-y-axis')._spendTicks=ticks;}
+}
+function renderSpendAverage(rows,axisMax){
+ const line=$('s-average-line'),reference=spendAverageReference(spendAverageBasis(rows),axisMax),track=$('s-chart-inner').querySelector('.spendDayTrack');
+ if(!track||reference.value<=0){line.hidden=true;return;}
+ const trackRect=track.getBoundingClientRect(),plotRect=line.parentElement.getBoundingClientRect(),unit=SPEND_GRANULARITY_COPY[rows[0]?.granularity||'day'].unit;
+ const top=trackRect.top-plotRect.top+(1-reference.ratio)*trackRect.height,label=`avg ${money(reference.value)}/${unit}`;
+ line.style.top=`${Math.round(top*10)/10}px`;line.hidden=false;
+ const value=line.querySelector('span');if(value.textContent!==label)value.textContent=label;
+}
+function spendPaintNavigation(){
+ const state=spendDayNavigation(spendChartRows,spendFocusDay);spendFocusDay=state.focusDay;
+ [...$('s-chart-inner').querySelectorAll('[data-spend-day]')].forEach((button,index)=>{
+  const item=state.buttons[index];
+  button.classList.toggle('selected',Boolean(item?.selected));button.tabIndex=item?.tabIndex??-1;button.removeAttribute('aria-pressed');
+ });
+}
+function updateSpendBar(button,row,index,count,axisMax,chartWidth,{peak=false,spansYears=false}={}){
+ const edge=count>1?(index===0?'first':index===count-1?'last':''):'';
+ button.dataset.spendDay=row.day;
+ button.setAttribute('aria-label',spendDayAria(row));
+ if(edge)button.dataset.axisEdge=edge;else delete button.dataset.axisEdge;
+ button.dataset.peak=String(peak);if(peak&&index<=2)button.dataset.peakEdge='first';else if(peak&&index>=count-3)button.dataset.peakEdge='last';else delete button.dataset.peakEdge;
+ button.dataset.incomplete=String(Boolean(row.incomplete));
+ const body=spendBarBody(row,index,count,axisMax,chartWidth,spansYears);
+ if(button._spendBody!==body){button.innerHTML=body;button._spendBody=body;}
+}
+function reconcileSpendBars(rows){
+ const granularity=rows[0]?.granularity||'day',inner=$('s-chart-inner'),keys=`${granularity}:${rows.map(row=>row.day).join('|')}`,costs=rows.map(row=>Number(row.cost||0)),axisMax=spendNiceMax(Math.max(0,...costs)),chartWidth=Math.max(1,inner.clientWidth||$('s-chart').clientWidth||1);
+ const existing=[...inner.querySelectorAll('[data-spend-day]')],same=inner.dataset.keys===keys&&existing.length===rows.length;
+ const peakCost=Math.max(0,...costs),peakIndex=rows.length>1&&peakCost>0?costs.indexOf(peakCost):-1,spansYears=Boolean(rows.length)&&rows[0].bucketStart.slice(0,4)!==rows.at(-1).bucketStart.slice(0,4);
+ inner.dataset.granularity=granularity;inner.dataset.dense=String(rows.length>45);inner.dataset.values=rows.length<=14?'shown':'hover';
+ renderSpendAxis(axisMax);
+ if(!same){
+  inner.innerHTML=rows.map(row=>`<button class=spendDay type=button data-spend-day="${esc(row.day)}"></button>`).join('');
+  inner.dataset.keys=keys;
+ }
+ [...inner.querySelectorAll('[data-spend-day]')].forEach((button,index)=>updateSpendBar(button,rows[index],index,rows.length,axisMax,chartWidth,{peak:index===peakIndex,spansYears}));
+ renderSpendAverage(rows,axisMax);
+ spendPaintNavigation();
+}
+function setSpendLogsHtml(html){
+ const list=$('s-logs');
+ if(list._spendHtml===html)return;
+ const scrollTop=list.scrollTop;
+ list.innerHTML=html;list._spendHtml=html;list.scrollTop=scrollTop;
+}
+function spendInsightMetricFormat(metric,value){
+ if(metric==='cost')return money(value);
+ if(metric==='input')return compactNumber(value);
+ if(metric==='active')return waitFmt(value);
+ const rounded=Math.round(Number(value||0)*10)/10;
+ return Number.isInteger(rounded)?rounded.toLocaleString():rounded.toLocaleString(undefined,{maximumFractionDigits:1});
+}
+function spendShapeRow(metric,label,note,distribution,totalRows){
+ if(!distribution.count)return `<div class=spendShapeRow><div class=spendShapeIdentity><b>${esc(label)}</b><small>${esc(note)}</small></div><div class=spendShapeCoverage>0 / ${f(totalRows)}</div><div class=spendShapeRail></div><div class=spendShapeValues><span data-label=P10>--</span><span data-label=Median>--</span><span data-label=Mean>--</span><span data-label=P90>--</span></div></div>`;
+ const span=Math.max(.000001,distribution.p90-distribution.p10),position=value=>Math.max(0,Math.min(100,100*(value-distribution.p10)/span));
+ const style=`--p25:${position(distribution.p25)}%;--p75:${position(distribution.p75)}%;--median:${position(distribution.median)}%;--mean:${position(distribution.mean)}%`;
+ const format=value=>spendInsightMetricFormat(metric,value);
+ return `<div class=spendShapeRow><div class=spendShapeIdentity><b>${esc(label)}</b><small>${esc(note)}</small></div><div class=spendShapeCoverage>${f(distribution.count)} / ${f(totalRows)}</div><div class=spendShapeRail style="${style}"><i class=spendShapeIqr></i><i class=spendShapeMedian title="Median ${esc(format(distribution.median))}"></i><i class=spendShapeMean title="Mean ${esc(format(distribution.mean))}"></i></div><div class=spendShapeValues><span data-label=P10 title="10th percentile">${esc(format(distribution.p10))}</span><span data-label=Median>${esc(format(distribution.median))}</span><span data-label=Mean>${esc(format(distribution.mean))}</span><span data-label=P90 title="90th percentile">${esc(format(distribution.p90))}</span></div></div>`;
+}
+function renderSpendShape(distributions,totalRows){
+ $('s-shape').innerHTML=`<div class=spendShapeHeader><span>Measure</span><span>Coverage</span><span>Middle 50% · median / mean</span><span><i>P10</i><i>Median</i><i>Mean</i><i>P90</i></span></div>${spendShapeRow('cost','Period spend','selected range',distributions.cost,totalRows)}${spendShapeRow('input','Processed input','full session',distributions.input,totalRows)}${spendShapeRow('executions','Executions','full session',distributions.executions,totalRows)}${spendShapeRow('active','Active time','full session',distributions.active,totalRows)}`;
+}
+function spendScatterTipHtml(row){
+ const selected=spendSessionMetricValue(row,spendScatterMetric),active=spendSessionMetricValue(row,'active'),estimated=['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis);
+ return `<b title="${esc(row.title||'Untitled session')}">${esc(row.title||'Untitled session')}</b><span><em>${spendScatterMetric==='input'?'Processed input':'Period spend'}</em><strong class=mono>${esc(spendInsightMetricFormat(spendScatterMetric,selected))}${spendScatterMetric==='cost'&&estimated?' est':''}</strong></span><span><em>Active time</em><strong class=mono>${esc(waitFmt(active))}</strong></span><span><em>Executions</em><strong class=mono>${f(row.turns)}</strong></span><span><em>${esc(row.label||row.provider||'Runtime')}</em><strong>${esc(row.project||'No project')}</strong></span>`;
+}
+function hideSpendScatterTip(){$('s-scatter-tip').hidden=true;}
+function showSpendScatterTip(row,target,event){
+ const tip=$('s-scatter-tip'),wrap=tip.parentElement,wrapRect=wrap.getBoundingClientRect(),targetRect=target.getBoundingClientRect();
+ tip.innerHTML=spendScatterTipHtml(row);tip.hidden=false;
+ const pointerX=event?.clientX||targetRect.left+targetRect.width/2,pointerY=event?.clientY||targetRect.top;
+ tip.style.left=Math.max(6,Math.min(wrapRect.width-tip.offsetWidth-6,pointerX-wrapRect.left+12))+'px';
+ tip.style.top=Math.max(6,Math.min(wrapRect.height-tip.offsetHeight-6,pointerY-wrapRect.top-tip.offsetHeight-10))+'px';
+}
+function drawSpendScatter(rows,analytics=spendSessionAnalytics(rows)){
+ const svg=$('s-scatter-svg'),points=spendScatterRows(rows,spendScatterMetric),valueMetric=spendScatterMetric==='input'?'input':'cost',metricLabel=spendScatterMetric==='input'?'processed input':'selected-period spend';
+ [...$('s-scatter-metric').querySelectorAll('[data-scatter-metric]')].forEach(button=>{const on=button.dataset.scatterMetric===spendScatterMetric;button.classList.toggle('on',on);button.setAttribute('aria-pressed',String(on));});
+ $('s-scatter-coverage').textContent=`${f(points.length)} of ${f((rows||[]).length)} sessions plotted`;$('s-scatter-missing').hidden=points.length>=(rows||[]).length;
+ svg.setAttribute('aria-label',`${metricLabel} by full-session active time for ${points.length} sessions. Each point opens the session.`);
+ hideSpendScatterTip();
+ const VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(270,Math.round(svg.clientHeight||340)),mobile=VW<560,ML=mobile?54:66,MR=mobile?18:28,MT=26,MB=48,PW=VW-ML-MR,PH=VH-MT-MB;
+ svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
+ if(!points.length){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="12">No sessions have both ${esc(metricLabel)} and active-time evidence</text>`;return;}
+ const xMax=Math.max(1,...points.map(row=>spendSessionMetricValue(row,'active'))),yMax=Math.max(1,...points.map(row=>spendSessionMetricValue(row,valueMetric))),xLog=Math.log1p(xMax),yLog=Math.log1p(yMax),x=value=>ML+PW*Math.log1p(value)/xLog,y=value=>MT+PH-PH*Math.log1p(value)/yLog;
+ let html='';
+ for(let index=0;index<=4;index++){
+  const ratio=index/4,gx=ML+PW*ratio,gy=MT+PH-PH*ratio,xValue=Math.expm1(xLog*ratio),yValue=Math.expm1(yLog*ratio);
+  html+=`<line x1="${gx}" x2="${gx}" y1="${MT}" y2="${MT+PH}" stroke="${CHART.grid}"/><line x1="${ML}" x2="${ML+PW}" y1="${gy}" y2="${gy}" stroke="${CHART.grid}"/><text x="${gx}" y="${VH-24}" text-anchor="middle" fill="${CHART.lbl}" font-size="11">${esc(waitFmt(xValue))}</text><text x="${ML-8}" y="${gy+3}" text-anchor="end" fill="${CHART.lbl}" font-size="11">${esc(spendInsightMetricFormat(valueMetric,yValue))}</text>`;
+ }
+ const activeMedian=analytics.distributions.active.median,valueMedian=analytics.distributions[valueMetric].median;
+ if(activeMedian>0)html+=`<line x1="${x(activeMedian)}" x2="${x(activeMedian)}" y1="${MT}" y2="${MT+PH}" stroke="${tint('signal',.52)}" stroke-dasharray="4 5"/><text x="${Math.min(ML+PW-4,x(activeMedian)+5)}" y="${MT+11}" fill="${CHART.lbl}" font-size="11">median time</text>`;
+ if(valueMedian>0)html+=`<line x1="${ML}" x2="${ML+PW}" y1="${y(valueMedian)}" y2="${y(valueMedian)}" stroke="${tint('signal',.52)}" stroke-dasharray="4 5"/><text x="${ML+5}" y="${Math.max(MT+10,y(valueMedian)-5)}" fill="${CHART.lbl}" font-size="11">median</text>`;
+ const ranked=(rows||[]).filter(row=>spendSessionMetricValue(row,'cost')!==null).slice().sort((a,b)=>spendSessionMetricValue(b,'cost')-spendSessionMetricValue(a,'cost')),topIds=new Set(ranked.slice(0,analytics.concentration.top_count).map(sessionRowKey));
+ points.slice().sort((a,b)=>Number(topIds.has(sessionRowKey(a)))-Number(topIds.has(sessionRowKey(b)))).forEach(row=>{
+  const active=spendSessionMetricValue(row,'active'),value=spendSessionMetricValue(row,valueMetric),runtime=spendRuntimeKey(row.provider),top=topIds.has(sessionRowKey(row)),label=`Open ${row.title||'untitled session'}: ${spendInsightMetricFormat(valueMetric,value)} ${metricLabel}, ${waitFmt(active)} active time`;
+  html+=`<a class=spendScatterLink href="${esc(sessionRoute(sessionRowKey(row)))}" data-spend-insight-session="${esc(sessionRowKey(row))}" aria-label="${esc(label)}"><circle class=spendScatterPoint cx="${x(active)}" cy="${y(value)}" r="${top?6.5:5.5}" style="fill:${SPEND_RUNTIME_COLORS[runtime]}" fill-opacity="${top ? .92 : .7}" stroke="${top?'var(--signal-hi)':CHART.ink}" stroke-width="${top?2.5:1.5}" vector-effect="non-scaling-stroke"><title>${esc(label)}</title></circle></a>`;
+ });
+ html+=`<text x="${ML}" y="13" fill="${CHART.lbl}" font-size="11">${esc(metricLabel)}</text><text x="${ML+PW/2}" y="${VH-6}" text-anchor="middle" fill="${CHART.lbl}" font-size="11">full-session active time · log scale</text>`;
+ svg.innerHTML=html;
+ [...svg.querySelectorAll('[data-spend-insight-session]')].forEach(link=>{
+  const row=points.find(item=>sessionRowKey(item)===link.dataset.spendInsightSession);
+  link.onpointerenter=event=>showSpendScatterTip(row,link,event);link.onpointermove=event=>showSpendScatterTip(row,link,event);link.onpointerleave=hideSpendScatterTip;link.onfocus=()=>showSpendScatterTip(row,link);link.onblur=hideSpendScatterTip;
+ });
+}
+function renderSpendSessionInsights(payload,window){
+ $('s-insights-range').textContent=spendRangeLabel(window);
+ if(payload?.loading||payload?.error){
+  const statusKey=`${window.start}|${window.end}|${payload?.error||'loading'}`;spendInsightPayload=null;if(statusKey===spendInsightRenderKey)return;spendInsightRenderKey=statusKey;$('s-concentration').textContent='--';$('s-concentration-note').textContent=payload?.error||'Loading range evidence…';$('s-concentration-bar').querySelector('i').style.width='0%';$('s-concentration-bar').setAttribute('aria-valuenow','0');$('s-concentration-sessions').innerHTML='';$('s-shape').innerHTML=`<div class="spendShapeEmpty emptyState">${esc(payload?.error||'Loading session distributions…')}</div>`;drawSpendScatter([]);return;
+ }
+ spendInsightPayload=payload;
+ const rows=payload?.sessions||[],renderKey=`${window.start}|${window.end}|`+rows.map(row=>[row.id,row.title,row.project,row.cost,row.input_tokens,row.turns,row.duration_s,row.duration_available,row.duration_basis,row.usage_basis,row.availability?.cost,row.availability?.input_tokens].join('~')).join('|');
+ if(renderKey===spendInsightRenderKey)return;
+ spendInsightRenderKey=renderKey;
+ const focused=document.activeElement?.closest?.('[data-spend-insight-session]'),focusedId=focused?.dataset.spendInsightSession||'',focusedScatter=Boolean(focused?.closest?.('#s-scatter-svg')),analytics=spendSessionAnalytics(rows),concentration=analytics.concentration,share=concentration.top_share;
+ $('s-concentration').textContent=concentration.covered?spendPct(share):'--';
+ $('s-concentration-note').textContent=concentration.covered?`${f(concentration.top_count)} of ${f(concentration.covered)} cost-covered ${countWord(concentration.covered,'session')} account for ${money(concentration.top_cost)} of ${money(concentration.total)}.${rows.some(hasLocalEstimate)?' Includes local estimates.':''}`:'No cost-covered sessions in this period.';
+ $('s-concentration-bar').querySelector('i').style.width=Math.max(0,Math.min(100,100*share))+'%';$('s-concentration-bar').setAttribute('aria-valuenow',String(Math.round(100*share)));
+ const topRows=rows.filter(row=>spendSessionMetricValue(row,'cost')!==null).slice().sort((a,b)=>spendSessionMetricValue(b,'cost')-spendSessionMetricValue(a,'cost')).slice(0,Math.min(3,concentration.top_count));
+ $('s-concentration-sessions').innerHTML=topRows.map(row=>{const cost=spendSessionMetricValue(row,'cost'),estimated=['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis);return `<button class=spendImpactRow data-spend-insight-session="${esc(sessionRowKey(row))}" type=button title="Open ${esc(row.title||'Untitled session')}"><span class=spendImpactName>${esc(row.title||'Untitled session')}</span><span class=spendImpactValue><b class=mono>${money(cost)}${estimated?' est':''}</b><small>${spendPct(concentration.total?cost/concentration.total:0)} of covered spend</small></span></button>`;}).join('');
+ renderSpendShape(analytics.distributions,rows.length);drawSpendScatter(rows,analytics);
+ if(focusedId)requestAnimationFrame(()=>{const root=focusedScatter?$('s-scatter-svg'):$('s-concentration-sessions'),target=[...root.querySelectorAll('[data-spend-insight-session]')].find(element=>element.dataset.spendInsightSession===focusedId);target?.focus({preventScroll:true});});
+}
+function renderSpendLogs(payload,window){
+ const rows=payload?.sessions||[],rangeTotal=Number(payload?.total_cost||0);
+ $('s-log-day').textContent=spendRangeLabel(window);
+ renderSpendSessionInsights(payload,window);
+ if(payload?.loading){$('s-log-count').textContent='';setSpendLogsHtml('<div class="spendLogEmpty emptyState">Loading range logs…</div>');return;}
+ if(payload?.error){$('s-log-count').textContent='';setSpendLogsHtml(`<div class="spendLogEmpty emptyState">${esc(payload.error)}</div>`);return;}
+ $('s-log-count').textContent=`${f(rows.length)} logs`;
+ if(!rows.length){setSpendLogsHtml('<div class="spendLogEmpty emptyState">No spend-contributing logs in this range.</div>');return;}
+ const maxCost=Math.max(.001,...rows.map(row=>Number(row.cost||0)));
+ setSpendLogsHtml(rows.map((row,index)=>{
+  const available=metricAvailable(row,'cost'),estimated=hasLocalEstimate(row),cost=Number(row.cost||0),share=available&&rangeTotal?pct(cost/rangeTotal):'0%',days=Math.max(1,Number(row.active_days)||1);
+  return `<div class=spendLogRow><div class=spendLogRank>${index+1}</div><div class=spendLogMain><div class=spendLogName title="${esc(row.title||'Untitled session')}">${esc(row.title||'Untitled session')}</div><div class=spendLogMeta>${esc(row.project||'No project')} · ${esc(row.label||row.provider||'Unknown runtime')} · ${f(days)} ${countWord(days,'day')}${estimated?' · local est':''}</div><div class=spendLogTrack><i style="width:${available?100*cost/maxCost:0}%"></i></div></div><div class=spendLogValue><strong class=mono>${costValueHtml(money(cost)+estimateSuffix(row),available)}</strong><span>${available?`${share} of range spend`:'cost unavailable'}</span></div><button class=tbtn data-spend-session="${esc(sessionRowKey(row))}" type=button>Open</button></div>`;
+ }).join(''));
+}
+function loadSpendLogs(window,generatedAt){
+ const rangeKey=`${window.start}|${window.end}`,requestKey=`${rangeKey}|${generatedAt||0}`;
+ if(requestKey===spendLogsRequestKey)return;
+ spendLogsRequestKey=requestKey;
+ const request=++spendLogsRequestSeq;
+ if(rangeKey!==spendLogsRenderedRange)renderSpendLogs({loading:true},window);
+ fetch(`/spend/logs?from=${encodeURIComponent(window.start)}&to=${encodeURIComponent(window.end)}`,{cache:'no-store'}).then(response=>{
+  if(!response.ok)throw new Error(`Range logs could not be loaded (${response.status}).`);
+  return response.json();
+ }).then(payload=>{
+  if(request!==spendLogsRequestSeq)return;
+  if(!payload?.ok)throw new Error(payload?.error||'Range logs could not be loaded.');
+  spendLogsRenderedRange=rangeKey;renderSpendLogs(payload,window);
+ }).catch(error=>{
+  if(request!==spendLogsRequestSeq)return;
+  spendLogsRequestKey='';spendLogsRenderedRange=rangeKey;renderSpendLogs({error:error.message||String(error)},window);
+ });
+}
+function hideSpendTip(){
+ spendInspectDay='';$('s-chart-tip').hidden=true;
+}
+function showSpendTip(day,button=$('s-chart-inner').querySelector(`[data-spend-day="${day}"]`)){
+ const row=spendChartRows.find(item=>item.day===day),tip=$('s-chart-tip');
+ if(!row||!button){hideSpendTip();return;}
+ spendInspectDay=day;
+ const details=spendDayDetails(row),total=Number(row.cost||0),note=[details.note,spendBucketNote(row)].filter(Boolean).join(' · ');
+ const span=row.granularity==='day'?'':`<div class=spendTipSpan>${esc(row.start===row.end?dayLabel(row.start):`${shortDayLabel(row.start)} – ${shortDayLabel(row.end)}`)}</div>`;
+ const shownRuntimes=details.runtimes.filter(runtime=>runtime.cost>0||runtime.unavailable),runtimeRows=shownRuntimes.length?shownRuntimes.map(runtime=>`<div class=spendTipRuntime style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]}"><span><i></i>${esc(runtime.label)}</span><b class=mono>${costValueHtml(money(runtime.cost),!(runtime.unavailable&&!runtime.cost))}</b><small>${runtime.unavailable?'unavailable':total?spendPct(runtime.cost/total):'0%'}${runtime.estimated?' · est':''}${runtime.partial?' · partial':''}</small></div>`).join(''):'<div class=spendTipEmpty>No runtime spend recorded.</div>';
+ const html=`<div class=spendTipDate>${esc(spendBucketLabel(row))}</div>${span}<div class=spendTipTotal><span>${SPEND_GRANULARITY_COPY[row.granularity].total}</span><b class=mono>${esc(details.totalText)}</b></div>${note?`<div class=spendTipNote>${esc(note)}</div>`:''}<div class=spendTipRuntimes>${runtimeRows}</div>`;
+ if(tip._spendHtml!==html){tip.innerHTML=html;tip._spendHtml=html;}
+ tip.hidden=false;
+ const card=tip.closest('.spendChartCard'),barRect=button.getBoundingClientRect(),cardRect=card.getBoundingClientRect();
+ const left=Math.max(8,Math.min(cardRect.width-tip.offsetWidth-8,barRect.left-cardRect.left+barRect.width/2-tip.offsetWidth/2));
+ tip.style.left=`${left}px`;tip.style.top=`${Math.max(8,Math.min(cardRect.height-tip.offsetHeight-8,Math.max(54,barRect.top-cardRect.top-tip.offsetHeight-8)))}px`;
+}
+function selectSpendDay(day,{focus=false}={}){
+ if(!spendChartRows.some(row=>row.day===day))return;
+ spendFocusDay=day;spendPaintNavigation();
+ const button=$('s-chart-inner').querySelector(`[data-spend-day="${day}"]`);
+ if(focus)button?.focus();
+}
+function renderSpend(xs){
+ const source=xs?.spend?.days||xs?.daily||[],today=spendDayKey(new Date()),availableDays=source.map(row=>row.day).filter(day=>spendDayDate(day)).sort();
+ const earliest=availableDays[0]||today;
+ let window=spendRangeWindow(spendRangeChoice,spendCustomFrom,spendCustomTo,new Date(),earliest);
+ const savedCustomInvalid=spendRangeChoice==='custom'&&(!window.valid||window.start<earliest||window.end>today);
+ if(savedCustomInvalid){spendRangeChoice='30';spendGranularityChoice='auto';window=spendRangeWindow('30');persistSpendRange();}
+ spendCurrentSource=source;spendCurrentWindow=window;spendCurrentRows=spendCalendarRows(source,window);
+ $('s-range').value=spendRangeChoice;
+ $('s-custom').hidden=spendRangeChoice!=='custom';
+ ['s-from','s-to'].forEach(id=>{$(id).min=earliest;$(id).max=today;});
+ if(!$('s-range-error').textContent){$('s-from').value=spendCustomFrom;$('s-to').value=spendCustomTo;}
+	 const rows=spendCurrentRows,total=rows.reduce((sum,row)=>sum+Number(row.cost||0),0),dailyAverage=window.dayCount?total/window.dayCount:0,evidence=spendEvidence(rows),runtimeTotals=spendRuntimeTotals(rows),topRuntime=runtimeTotals.reduce((best,row)=>!best||row.cost>best.cost?row:best,null),highest=rows.reduce((best,row)=>!best||Number(row.cost||0)>Number(best.cost||0)?row:best,null);
+ const rangeText=spendRangeLabel(window),periodUnavailable=evidence.allUnavailable&&!total;
+ const periodDiscount=source.filter(row=>row.day>=window.start&&row.day<=window.end).reduce((sum,row)=>sum+Number(row.discount_usd||0),0);
+ setCostValue('s-total',money(total),!periodUnavailable);
+ $('s-total-note').textContent=periodUnavailable?'Cost unavailable for recorded activity':`${rangeText} · ${periodDiscount>0?`Estimate after discounts · list ${money(total+periodDiscount)}`:'API-equivalent estimate'}${evidence.partial?' · lower bound':''}`;
+	 setCostValue('s-average',money(dailyAverage),!periodUnavailable);
+ const previousWindow=spendPreviousWindow(window),previousRows=spendCalendarRows(source,previousWindow),previousEvidence=source.some(row=>row.day>=previousWindow.start&&row.day<=previousWindow.end),previousCoverage=spendEvidence(previousRows),previousTotal=previousRows.reduce((sum,row)=>sum+Number(row.cost||0),0);
+ $('s-average-note').textContent=periodUnavailable?'Daily average unavailable':previousEvidence&&!evidence.partial&&!previousCoverage.partial?`${dailyDeltaLabel(total,previousTotal)} vs preceding ${window.dayCount}d`:`${window.dayCount} calendar ${countWord(window.dayCount,'day')}${evidence.partial||previousCoverage.partial?' · comparison withheld for partial coverage':''}`;
+ $('s-top-runtime').textContent=periodUnavailable?'Unavailable':topRuntime&&topRuntime.cost?topRuntime.label:'No spend';
+ $('s-top-runtime-note').textContent=topRuntime&&topRuntime.cost?`${money(topRuntime.cost)} · ${spendPct(total?topRuntime.cost/total:0)}${topRuntime.estimated?' · est':''}${topRuntime.partial?' · partial':''}`:evidence.active?'No covered runtime cost':'No recorded activity';
+ $('s-highest-day').textContent=periodUnavailable?'Unavailable':highest&&highest.cost?shortDayLabel(highest.day):'No spend';
+ $('s-highest-day-note').textContent=highest&&highest.cost?`${money(highest.cost)} · ${dayLabel(highest.day)}`:evidence.active?'No covered daily cost':'No recorded activity';
+ const visibleRuntimes=runtimeTotals.filter(runtime=>runtime.cost||runtime.unavailable);
+ $('s-legend').innerHTML=visibleRuntimes.map(runtime=>`<span style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]}"><i></i>${esc(runtime.label)}</span>`).join('')+(visibleRuntimes.some(runtime=>runtime.estimated)?'<span class=spendEstimateKey><i></i>Local estimate</span>':'')+(evidence.partial?'<span class=spendPartialKey><i></i>Partial coverage</span>':'');
+ const {granularity,options:granularityOptions}=spendResolveGranularity(spendGranularityChoice,rows,today);
+ [...$('s-granularity').querySelectorAll('[data-spend-granularity]')].forEach(button=>{
+  const value=button.dataset.spendGranularity,on=value===granularity;
+  button.classList.toggle('on',on);button.setAttribute('aria-pressed',String(on));button.setAttribute('aria-disabled',String(!granularityOptions[value]));
+  button.title=granularityOptions[value]?'':`Needs a range with at least two ${value}s, one of them complete`;
+ });
+ $('s-chart-note').textContent=SPEND_GRANULARITY_COPY[granularity].note;
+ spendChartRows=spendBucketRows(rows,granularity,today);
+ if(spendChartRows.some(row=>row.incomplete&&row.hasActivity))$('s-legend').insertAdjacentHTML('beforeend',`<span class=spendIncompleteKey><i></i>${granularity==='day'?'In progress':'Partial or in progress'}</span>`);
+ reconcileSpendBars(spendChartRows);
+	 $('s-chart').setAttribute('aria-label',`${rangeText}. ${periodUnavailable?'Spend unavailable':`${money(total)} estimated spend, daily average ${money(dailyAverage)}`}${evidence.partial?', partial coverage':''}. Use arrow keys to inspect ${granularity}s.`);
+ $('s-platforms').innerHTML=visibleRuntimes.length?`<div class=spendPlatformRows>${visibleRuntimes.map(runtime=>`<div class=spendPlatformRow style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]}"><div class=spendPlatformName><i></i><span>${esc(runtime.label)}</span></div><div class=spendPlatformTrack><i style="width:${total?100*runtime.cost/total:0}%"></i></div><div class="spendPlatformValue mono">${costValueHtml(money(runtime.cost),!(runtime.unavailable&&!runtime.cost))}<span>${runtime.unavailable?'unavailable':total?spendPct(runtime.cost/total):'0%'}${runtime.estimated?' · est':''}${runtime.partial?' · partial':''}</span></div></div>`).join('')}</div>`:`<div class="spendEmpty emptyState">${evidence.active?'Recorded activity has no runtime cost evidence.':'No spend recorded in this range.'}</div>`;
+ loadSpendLogs(window,xs?.generated_at);
+ const hovered=$('s-chart-inner').querySelector('.spendDay:hover');
+ if(hovered)showSpendTip(hovered.dataset.spendDay,hovered);else hideSpendTip();
+}
+function validateSpendCustomDraft(){
+ const from=$('s-from').value,to=$('s-to').value,window=spendRangeWindow('custom',from,to),earliest=spendCurrentSource.map(row=>row.day).filter(day=>spendDayDate(day)).sort()[0]||spendDayKey(new Date()),today=spendDayKey(new Date());
+ let error=window.error;
+ if(window.valid&&from<earliest)error=`From cannot be earlier than ${dayLabel(earliest)}.`;
+ if(window.valid&&to>today)error='To cannot be later than today.';
+ const valid=!error;
+ $('s-range-error').textContent=error;['s-from','s-to'].forEach(id=>$(id).setAttribute('aria-invalid',String(!valid)));
+ if(!valid)return;
+ spendCustomFrom=from;spendCustomTo=to;spendRangeChoice='custom';spendGranularityChoice='auto';persistSpendRange();renderSpend(LATEST?.xsession);
+}
+$('s-range').onchange=event=>{
+ const range=normalizeSpendRangeChoice(event.target.value);
+ $('s-range-error').textContent='';['s-from','s-to'].forEach(id=>$(id).setAttribute('aria-invalid','false'));
+ if(range==='custom'){
+  const fallback=spendCurrentWindow?.valid?spendCurrentWindow:spendRangeWindow('30');
+  if(!spendCustomFrom)spendCustomFrom=fallback.start;if(!spendCustomTo)spendCustomTo=fallback.end;
+ }
+ spendRangeChoice=range;spendGranularityChoice='auto';persistSpendRange();if(LATEST)renderSpend(LATEST.xsession);
+};
+$('s-from').onchange=validateSpendCustomDraft;$('s-to').onchange=validateSpendCustomDraft;
+$('s-granularity').onclick=event=>{
+ const button=event.target.closest('[data-spend-granularity]');if(!button||button.getAttribute('aria-disabled')==='true')return;
+ spendGranularityChoice=normalizeSpendGranularity(button.dataset.spendGranularity);
+ hideSpendTip();if(LATEST)renderSpend(LATEST.xsession);
+};
+function handleSpendInspect(event){
+ const button=event.target.closest('[data-spend-day]');if(!button)return;
+ if(spendInspectDay===button.dataset.spendDay&&!$('s-chart-tip').hidden)return;
+ showSpendTip(button.dataset.spendDay,button);
+}
+$('s-chart-inner').addEventListener('pointerover',handleSpendInspect);
+$('s-chart-inner').addEventListener('pointerleave',hideSpendTip);
+$('s-chart-inner').onclick=event=>{const button=event.target.closest('[data-spend-day]');if(button)selectSpendDay(button.dataset.spendDay,{focus:true});};
+$('s-logs').onclick=event=>{const button=event.target.closest('[data-spend-session]');if(button)selectSession(button.dataset.spendSession);};
+$('s-scatter-metric').onclick=event=>{const button=event.target.closest('[data-scatter-metric]');if(!button)return;spendScatterMetric=button.dataset.scatterMetric==='input'?'input':'cost';localStorage.setItem(SPEND_SCATTER_METRIC_KEY,spendScatterMetric);drawSpendScatter(spendInsightPayload?.sessions||[]);};
+function openSpendInsightSession(event){const button=event.target.closest('[data-spend-insight-session]');if(!button)return;event.preventDefault();selectSession(button.dataset.spendInsightSession);}
+$('s-concentration-sessions').onclick=openSpendInsightSession;$('s-scatter-svg').onclick=openSpendInsightSession;
+$('s-chart-inner').onkeydown=event=>{
+ if(!['ArrowLeft','ArrowRight','Home','End','Escape'].includes(event.key))return;
+ if(event.key==='Escape'){hideSpendTip();return;}
+ event.preventDefault();const buttons=[...$('s-chart-inner').querySelectorAll('[data-spend-day]')],current=event.target.closest('[data-spend-day]'),index=Math.max(0,buttons.indexOf(current));
+ const next=event.key==='Home'?0:event.key==='End'?buttons.length-1:Math.max(0,Math.min(buttons.length-1,index+(event.key==='ArrowRight'?1:-1)));
+ if(buttons[next])selectSpendDay(buttons[next].dataset.spendDay,{focus:true});
+};
diff --git a/dashboard/js/subagents-explorer.js b/dashboard/js/subagents-explorer.js
new file mode 100644
index 00000000..669c7f38
--- /dev/null
+++ b/dashboard/js/subagents-explorer.js
@@ -0,0 +1,295 @@
+function subagentGroupHtml(group,index,parentSessions,issuesOnly=false){
+ const parent=subagentParentPresentation(group.rootSessionId,group.project,parentSessions),selected=group.rows.some(row=>String(row?.id||'')===selectedSubagentId),open=selected||expandedSubagentRoot===group.rootSessionId||(expandedSubagentRoot===null&&index<1);
+ const cost=group.costCovered?money(group.cost):'--',tokens=group.tokenCovered?compactNumber(group.knownTokens):'--',workTime=group.workTimeCovered===group.agents?durationShort(group.workTime):'--';
+ const badges=[group.incomplete?`<span class="subagentSessionBadge chip tone-warn">${f(group.incomplete)} incomplete</span>`:'',group.working?`<span class="subagentSessionBadge chip">${f(group.working)} working</span>`:''].filter(Boolean).join('');
+ const visibleRows=issuesOnly?group.rows.filter(row=>row?.activity_state==='incomplete'||Array.isArray(row?.attention)&&row.attention.length):group.rows;
+ const maximumChildCost=Math.max(0,...group.rows.filter(row=>row?.cost_available===true).map(row=>Number(row.cost)||0));
+ const children=visibleRows.map((row,rowIndex)=>{
+  const identity=agentIdentityPresentation(row,rowIndex),state=String(row?.activity_state||'unknown'),model=row?.model&&row.model!=='unknown'?row.model:'model unavailable',costValue=row?.cost_available===true?money(row.cost):'--',tokenValue=row?.tokens_available===true?compactNumber(row.tokens):'tokens --',workTimeValue=row?.work_time_s==null?'work time --':`work time ${durationShort(row.work_time_s)}`,id=String(row?.id||''),isSelected=id&&id===selectedSubagentId,heat=subagentCostHeat(row.cost,maximumChildCost,row.cost_available);
+  return `<button class="subagentChildRow${isSelected?' selected':''}" type=button data-subagent-id="${esc(id)}"${isSelected?' aria-current=true':''} aria-label="Inspect ${esc(identity.primary)}"><span class=subagentChildIdentity><strong><span>${esc(identity.primary)}</span></strong><small>${esc([identity.secondary,row.kind,tokenValue,workTimeValue].filter(Boolean).join(' · '))}</small></span><span class=subagentChildMetric>${esc(model)}</span><span class="agentState ${esc(state)}">${esc(state)}</span><span class="subagentChildMetric${heat?' subagentCostHeat':''}"${heat?` style="${heat}" title="Relative child cost in this session"`:''}>${esc(costValue)}</span></button>`;
+ }).join('');
+ const hiddenSiblings=group.agents-visibleRows.length,footer=issuesOnly&&hiddenSiblings?`<button class=subagentSiblingLink type=button data-subagent-show-session="${esc(group.rootSessionId)}">View ${f(hiddenSiblings)} other ${hiddenSiblings===1?'child':'children'} in Sessions</button>`:'',spawnedRunMetric=issuesOnly?'':`<span class=subagentSessionMetric><span>Spawned runs</span><b>${f(group.agents)}</b></span>`;
+ return `<details class=subagentSessionGroup data-subagent-root="${esc(group.rootSessionId)}"${open?' open':''}><summary aria-label="${esc(`${parent.title}, ${group.agents} child agents, ${group.incomplete} incomplete`)}"><div class=subagentSessionIdentity><strong><span title="${esc(parent.title)}">${esc(parent.title)}</span>${badges}</strong><small title="${esc(parent.project)} · ${f(group.agents)} ${countWord(group.agents,'child agent')}">${esc(parent.project)} · ${f(group.agents)} ${countWord(group.agents,'child agent')}</small></div><div class=subagentSessionMetrics>${spawnedRunMetric}<span class=subagentSessionMetric><span>Child cost</span><b>${esc(cost)}</b></span><span class=subagentSessionMetric><span>Tokens</span><b>${esc(tokens)}</b></span><span class=subagentSessionMetric><span>Work time</span><b>${esc(workTime)}</b></span></div></summary><div class=subagentChildHeader><span>Agent</span><span>Model</span><span>Status</span><span>Est. cost</span></div>${children}${footer}</details>`;
+}
+function renderSubagentInspector(row,allRows,parentSessions=subagentParentSessionMap()){
+ const inspector=$('subagent-inspector');
+ if(!row){inspector.innerHTML='<div class="subagentInspectorEmpty emptyState"><div><svg viewBox="0 0 40 40" aria-hidden=true><circle cx="20" cy="11" r="5"/><circle cx="10" cy="29" r="4"/><circle cx="30" cy="29" r="4"/><path d="M20 16v6M10 25v-4h20v4"/></svg><strong>Select a child agent</strong><p>See its parent, cost, work time, and available retry evidence.</p></div></div>';return;}
+ const identity=agentIdentityPresentation(row,0),parent=subagentParentPresentation(row.root_session_id,row.project,parentSessions),siblings=(allRows||[]).filter(item=>String(item?.root_session_id||'')===String(row.root_session_id||'')),siblingIndex=Math.max(0,siblings.findIndex(item=>String(item?.id||'')===String(row.id||'')))+1;
+ const state=String(row.activity_state||'unknown'),model=row.model&&row.model!=='unknown'?row.model:'model unavailable',cost=row.cost_available===true?money(row.cost):'--',tokens=row.tokens_available===true?f(row.tokens):'--',workTime=row.work_time_s==null?'--':durationShort(row.work_time_s),attempts=Number(row.retries||0)+Number(row.failed_attempts||0),attention=Array.isArray(row.attention)&&row.attention.length;
+ const peers=(allRows||[]).filter(item=>item?.cost_available===true&&item?.runtime===row.runtime&&item?.model===row.model&&item?.kind===row.kind&&Number(item?.depth||0)===Number(row.depth||0)).map(item=>Number(item.cost)||0).sort((a,b)=>a-b),middle=Math.floor(peers.length/2),peerMedian=!peers.length?null:peers.length%2?peers[middle]:(peers[middle-1]+peers[middle])/2,comparison=row.cost_available===true&&peerMedian>0&&peers.length>1?`${(Number(row.cost)/peerMedian).toFixed(1)}× cohort median · ${f(peers.length)} comparable agents`:'Comparable cost baseline unavailable';
+ const reasons=attention?`<ul>${row.attention.map(reason=>`<li><strong>${esc(String(reason?.code||'').replaceAll('_',' '))}:</strong> ${esc(reason?.explanation||'Evidence threshold met.')}</li>`).join('')}</ul>`:'';
+ const metric=(label,value)=>`<div class=subagentInspectorMetric><span>${esc(label)}</span><b>${esc(value)}</b></div>`;
+ inspector.innerHTML=`<div class=subagentInspectorHead><div><h3>${esc(identity.primary)}</h3><p>${esc(identity.secondary?`Provider role · nickname ${identity.secondary}`:'Child-agent evidence')}</p></div><button class=subagentInspectorClose type=button data-subagent-close-detail aria-label="Close agent inspector">×</button></div><div class=subagentInspectorParent><span>Parent session</span><strong title="${esc(parent.title)}">${esc(parent.title)}</strong><small>${esc(parent.project)} · child ${f(siblingIndex)} of ${f(siblings.length)}</small></div><div class=subagentInspectorTags><span>${esc(appFilterLabel({provider:row.runtime}))}</span><span>${esc(model)}</span><span>${esc(row.kind||'child')}</span><span>${esc(state)}</span></div><div class=subagentInspectorGrid>${metric('Estimated cost',cost)}${metric('Tokens',tokens)}${metric('Work time',workTime)}${metric('Executions',f(row.executions||0))}${metric('Tool calls',f(row.tool_calls||0))}${metric('Retry evidence',f(attempts))}</div><div class=subagentInspectorSignals><strong>Cost and retry evidence</strong>${reasons}<p>${esc(comparison)}</p></div><button class="subagentOpenParent subagentInspectorAction" type=button data-subagent-open-parent="${esc(row.root_session_id)}">Open parent session</button>`;
+}
+function renderSubagentRoles(rows){
+ const roles=buildSubagentRoleRows(rows);
+ if(!roles.length)return '<div class="subagentResultsEmpty emptyState"><div><strong>No provider-reported roles match</strong>Adjust the filters or inspect Sessions for anonymous child agents.</div></div>';
+ return `<div class=subagentRoleTable><div class=subagentRoleHeader><span>Role</span><span>Runs</span><span>Total spend</span><span>Incomplete</span><span>Median / P95</span><span>Tokens</span></div>${roles.map(row=>{const coverage=row.costCovered===row.agents?'complete':`${f(row.costCovered)} / ${f(row.agents)} covered`,tokenValue=row.tokenCovered?compactNumber(row.knownTokens):'--',totalSpend=row.costCovered?money(row.knownCost):'--';return `<div class=subagentRoleRow><div class=subagentRoleIdentity><strong>${esc(row.role)}</strong><small>${esc(appFilterLabel({provider:row.runtime}))} · ${esc(row.kind)} · ${esc(row.topModel)} · ${esc(coverage)}</small></div><div class=subagentRoleMetric><span>Runs</span><b>${f(row.agents)}</b></div><div class=subagentRoleMetric><span>Total spend</span><b>${esc(totalSpend)}</b></div><div class="subagentRoleMetric${row.incomplete?' warn':''}"><span>Incomplete</span><b>${pct(row.incompleteRate)}</b></div><div class=subagentRoleMetric><span>Median / P95</span><b>${row.medianCost==null?'--':`${money(row.medianCost)} / ${money(row.p95Cost)}`}</b></div><div class=subagentRoleMetric><span>Tokens</span><b>${esc(tokenValue)}</b></div></div>`;}).join('')}</div>`;
+}
+function renderSubagentExplorer(usage){
+ const inventory=Array.isArray(usage?.inventory)?usage.inventory:[],filters=subagentFilters;
+ if($('subagent-explorer').parentElement===$('subagent-page-home')){subagentView='roles';if(filters.role||filters.kind){filters.role='';filters.kind='';persistSubagentFilter('role');persistSubagentFilter('kind');}}
+ else if(subagentView==='roles')subagentView='sessions';
+ localStorage.setItem('tm_subagent_view',subagentView);
+ const values=key=>[...new Set(inventory.map(row=>String(row?.[key]||'')).filter(Boolean))].sort((a,b)=>a.localeCompare(b,undefined,{sensitivity:'base'}));
+ const runtimes=values('runtime'),projects=values('project'),models=values('model');
+ if(filters.runtime&&!runtimes.includes(filters.runtime))filters.runtime='';
+ if(filters.project&&!projects.includes(filters.project))filters.project='';
+ if(filters.model&&!models.includes(filters.model))filters.model='';
+ setLogSelectOptions($('subagent-filter-app'),'<option value="">All apps</option>'+runtimes.map(value=>`<option value="${esc(value)}">${esc(appFilterLabel({provider:value}))}</option>`).join(''),filters.runtime);
+ setLogSelectOptions($('subagent-filter-project'),'<option value="">All projects</option>'+projects.map(value=>`<option value="${esc(value)}">${esc(projectFilterLabel(value))}</option>`).join(''),filters.project);
+ setLogSelectOptions($('subagent-filter-model'),'<option value="">All models</option>'+models.map(value=>`<option value="${esc(value)}">${esc(value)}</option>`).join(''),filters.model);
+ $('subagent-filter-search').value=filters.query;$('subagent-filter-status').value=filters.status;$('subagent-filter-signal').value=filters.signal;$('subagent-filter-time').value=filters.window;$('subagent-filter-sort').value=filters.sort;
+ const advancedCount=[filters.model,filters.status!=='all',filters.signal!=='all',filters.sort!=='recent'].filter(Boolean).length;
+ $('subagent-filter-advanced').hidden=!subagentAdvancedOpen;$('subagent-filter-more').setAttribute('aria-expanded',String(subagentAdvancedOpen));$('subagent-filter-more-count').textContent=advancedCount?String(advancedCount):'';
+ const filterItems=subagentActiveFilterItems(filters);
+ $('subagent-active-filters').innerHTML=filterItems.length?'<span>Filtered by</span>'+filterItems.map(item=>`<button class=subagentFilterChip type=button data-subagent-clear-filter="${esc(item.key)}" aria-label="Remove ${esc(item.label)} filter"><b>${esc(item.label)}: ${esc(item.value)}</b><i aria-hidden=true>×</i></button>`).join(''):'';
+ $('subagent-filter-footer').hidden=!filterItems.length;
+ $('subagent-filter-clear').disabled=!filterItems.length;
+ const contextFilters={...filters,status:'all',signal:'all'},context=filterSubagentInventory(usage,contextFilters),result=filterSubagentInventory(usage,filters),summary=result.summary,exact=summary.complete,parentSessions=subagentParentSessionMap();
+ const roleQuery=String(filters.query||'').trim().toLowerCase(),roleVisibleRows=context.rows.filter(row=>!roleQuery||String(row?.role||'').toLowerCase().includes(roleQuery));
+ const issueGroups=groupSubagentSessions(context.rows,true,'priority'),sessionGroups=groupSubagentSessions(context.rows,false,filters.sort),roleRows=buildSubagentRoleRows(roleVisibleRows);
+ $('subagent-view-issues-count').textContent=context.summary.complete?f(issueGroups.length):'--';$('subagent-view-sessions-count').textContent=context.summary.complete?f(sessionGroups.length):'--';$('subagent-view-roles-count').textContent=context.summary.complete?f(roleRows.length):'--';
+ [...$('subagent-view-tabs').querySelectorAll('[data-subagent-view]')].forEach(button=>{const active=button.dataset.subagentView===subagentView;button.setAttribute('aria-selected',String(active));button.tabIndex=active?0:-1;if(active)$('subagent-results-panel').setAttribute('aria-labelledby',subagentView==='roles'?'subagent-results-title':button.id);});
+ $('subagent-explorer-meta').hidden=false;$('subagent-explorer-meta').textContent=result.truncated?`${f(result.rows.length)} visible of ${f(result.inventoryCount)} child runs`:result.rows.length===result.inventoryCount?`${f(result.inventoryCount)} child runs`:`${f(result.rows.length)} of ${f(result.inventoryCount)} child runs`;
+ const compact=(label,value,kind='',filter='')=>filter?`<button class="subagentCompactMetric actionable ${kind}" type=button data-subagent-summary-filter="${esc(filter)}" aria-pressed="${String(filter==='incomplete'?filters.status==='incomplete':filters.signal===filter)}"><span>${esc(label)}</span><b>${esc(value)}</b></button>`:`<span class="subagentCompactMetric ${kind}"><span>${esc(label)}</span><b>${esc(value)}</b></span>`;
+ const signalLabels={peer_cost_outlier:'cost outliers',active_cost_concentration:'active concentrations',retry_pressure:'retry pressure'};
+ const signalPills=Object.entries(context.signalCounts).filter(([,count])=>count>0).map(([code,count])=>compact(signalLabels[code]||code.replaceAll('_',' '),f(count),'warn',code));
+ const incompletePill=compact('Incomplete',context.summary.complete?f(context.summary.incomplete):'--',context.summary.incomplete?'warn':'dim','incomplete');
+  $('subagent-compact-summary').innerHTML=(subagentView==='roles'?[incompletePill]:[incompletePill,compact('Matching child cost',exact&&summary.costCovered?money(summary.cost):'--'),compact('Cost evidence',exact?`${f(summary.costCovered)} / ${f(summary.agents)}`:'--'),...signalPills]).join('');
+  const warning=$('subagent-inventory-warning');warning.hidden=!result.truncated;warning.textContent=result.truncated?'Display limit reached — filtered totals withheld.':'';
+  const unresolved=Number(usage?.totals?.unresolved_agents)||0,unresolvedCost=Number(usage?.totals?.unresolved_known_cost)||0,coverageNote=$('subagent-coverage-note');
+  coverageNote.hidden=!unresolved;
+  const coverageDetail='The parent session record is missing from the local history. These child runs are counted in global totals, but the hierarchy and spend-share rollups leave them out.';
+  coverageNote.innerHTML=unresolved
+   ?`<span class=fieldtip tabindex=0 aria-description="${esc(coverageDetail)}" data-tip="${esc(coverageDetail)}"><b>${f(unresolved)}</b> ${countWord(unresolved,'child run')}${unresolvedCost?` (${money(unresolvedCost)})`:''} ${unresolved===1?'has':'have'} no parent session; left out of the rollups above.</span>`
+   :'';
+ if(selectedSubagentId&&!result.rows.some(row=>String(row?.id||'')===selectedSubagentId))selectedSubagentId='';
+ const copy={issues:['Issues','Incomplete runs and cost/retry signals.'],sessions:['Parent sessions','Child runs grouped by parent. Cost color is relative within each session.'],roles:['Roles','']}[subagentView];
+ $('subagent-results-title').textContent=copy[0];$('subagent-results-description').textContent=copy[1];
+ $('subagent-filter-search').placeholder=subagentView==='roles'?'Find a role or model':'Role, nickname, model, or project';
+ const roleView=subagentView==='roles';$('subagent-workspace').classList.toggle('roleView',roleView);$('subagent-inspector').hidden=roleView;
+ renderSubagentModelDistribution(result.rows,result.truncated);
+ if(subagentView==='roles'){
+  const economics=buildSubagentRoleEconomics(usage,filters),filteredRoleRows=result.rows.filter(row=>!roleQuery||String(row?.role||'').toLowerCase().includes(roleQuery)),roles=economics.reason?buildSubagentRoleRows(filteredRoleRows):economics.roles;$('subagent-results-count').textContent=`${f(roles.length)} ${countWord(roles.length,'role')}`;$('subagent-results').innerHTML=economics.reason==='filtered'?renderSubagentRoleEconomics(economics)+renderSubagentRoles(filteredRoleRows):renderSubagentRoleEconomics(economics);
+ }else{
+  const groups=groupSubagentSessions(result.rows,subagentView==='issues',subagentView==='issues'?'priority':filters.sort),agentCount=groups.reduce((total,group)=>total+group.agents,0);
+  const signalCount=groups.reduce((total,group)=>total+group.attention,0),incompleteCount=groups.reduce((total,group)=>total+group.incomplete,0);
+  $('subagent-results-count').textContent=subagentView==='issues'?`${f(groups.length)} ${countWord(groups.length,'session')} · ${f(incompleteCount)} incomplete · ${f(signalCount)} with cost/retry signals`:`${f(groups.length)} ${countWord(groups.length,'session')} · ${f(agentCount)} ${countWord(agentCount,'agent')}`;
+  $('subagent-results').innerHTML=groups.length?groups.map((group,index)=>subagentGroupHtml(group,index,parentSessions,subagentView==='issues')).join(''):`<div class="subagentResultsEmpty emptyState"><div><strong>${subagentView==='issues'?'No matching runs':'No parent sessions match'}</strong>${subagentView==='issues'?'No incomplete children or cost/retry signals match these filters.':'Adjust the filters to restore child-agent sessions.'}</div></div>`;
+ }
+ const selected=result.rows.find(row=>String(row?.id||'')===selectedSubagentId)||null;
+ renderSubagentInspector(selected,result.rows,parentSessions);
+}
+function selectSubagentUsageScope(usage,runtime,window,project,hasTextFilter){
+ if(hasTextFilter)return {usage:null,reason:'filtered'};
+ if(!usage||typeof usage!=='object')return {usage:null,reason:'unavailable'};
+ runtime=String(runtime||'');
+ window=String(window||'all');
+ project=String(project||'');
+ const scopes=Array.isArray(usage.scopes)?usage.scopes:[];
+ if(scopes.length){
+  const selected=scopes.find(item=>String(item?.runtime||'')===runtime&&String(item?.window||'all')===window&&String(item?.project||'')===project);
+  if(selected)return {usage:selected,reason:null};
+  return {usage:null,reason:usage.scope_truncated===true?'unavailable':'empty'};
+ }
+ return !runtime&&window==='all'&&!project?{usage,reason:null}:{usage:null,reason:'empty'};
+}
+function renderSubagentUsage(usage,filters=subagentFilters,hasRowFilters=false){
+ const module=$('subagent-usage'),baseAgentCount=Number(usage?.totals?.agents)||0;
+ if(!usage||baseAgentCount<1){module.hidden=true;return;}
+ module.hidden=false;
+ [...$('subagent-usage-dimension').querySelectorAll('[data-subagent-dimension]')].forEach(button=>{
+  const active=button.dataset.subagentDimension===subagentUsageDimension;
+  button.classList.toggle('on',active);
+  button.setAttribute('aria-pressed',String(active));
+ });
+ [...$('subagent-usage-sort').querySelectorAll('[data-subagent-sort]')].forEach(button=>{
+  const active=button.dataset.subagentSort===subagentUsageSort;
+  button.classList.toggle('on',active);
+  button.setAttribute('aria-pressed',String(active));
+ });
+ const selection=selectSubagentUsageScope(usage,filters.runtime,filters.window,filters.project,hasRowFilters);
+ if(!selection.usage){
+  $('subagent-usage-summary').innerHTML='';
+  const message=selection.reason==='filtered'
+   ?'Usage patterns are shown when role, nickname, model, status, and signal filters are clear.'
+   :selection.reason==='empty'
+    ?'No child-agent usage matches the selected project, app, and activity window.'
+    :'Subagent statistics are unavailable for this filter.';
+  $('subagent-usage-rows').innerHTML=`<div class="subagentUsageEmpty emptyState">${message}</div>`;
+  return;
+ }
+ const scoped=selection.usage,totals=scoped.totals||{},agentCount=Number(totals.agents)||0;
+ if(!agentCount){
+  $('subagent-usage-summary').innerHTML='';
+  $('subagent-usage-rows').innerHTML='<div class="subagentUsageEmpty emptyState">No child-agent usage matches the selected app and activity window.</div>';
+  return;
+ }
+ const costSummary=totals.cost_available===true
+  ? money(totals.cost)
+  : Number(totals.known_cost)>0?`${money(totals.known_cost)} known`:'--';
+ const tokenSummary=totals.tokens_available===true
+  ? f(totals.tokens)
+  : Number(totals.known_tokens)>0?`${f(totals.known_tokens)} known`:'--';
+ const metric=(label,value,note)=>`<div class="subagentUsageStat metric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
+ const share=totals.agent_spend_share==null?'--':pct(totals.agent_spend_share),coveredGroups=Number(totals.group_cost_covered_sessions)||0,totalGroups=Number(totals.parent_sessions)||0,shareNote=coveredGroups===totalGroups?'of covered group spend':`${f(coveredGroups)} of ${f(totalGroups)} parent sessions have complete group cost`;
+ const median=totals.median_cost==null?'--':money(totals.median_cost),p95=totals.p95_cost==null?'cost distribution unavailable':`P95 ${money(totals.p95_cost)} API-rate estimate`;
+ const outputPerDollar=totals.output_per_dollar==null?'--':compactNumber(totals.output_per_dollar);
+ const input=totals.input_tokens==null?'--':f(totals.input_tokens),output=totals.output_tokens==null?'--':f(totals.output_tokens),cache=totals.cache_read_tokens==null?'--':f(Number(totals.cache_read_tokens||0)+Number(totals.cache_write_tokens||0));
+ $('subagent-usage-summary').innerHTML=[
+  metric('Child agents',f(agentCount),`${f(totals.parent_sessions||0)} ${countWord(totals.parent_sessions||0,'parent session')}`),
+  metric('Estimated cost',costSummary,totals.cost_available===true?'complete cost coverage':`${f(totals.cost_covered_agents||0)} of ${f(agentCount)} cost-covered`),
+  metric('Tokens',tokenSummary,`${input} in · ${output} out · ${cache} cache`),
+  metric('Child spend share',share,shareNote),
+  metric('Median / agent',median,p95),
+  metric('Output / $',outputPerDollar,totals.output_per_dollar==null?'complete output and cost required':'covered output tokens per dollar'),
+  metric('Needs attention',f(totals.attention_agents||0),'server evidence signals'),
+ ].join('');
+ let rows=Array.isArray(scoped[subagentUsageDimension])?[...scoped[subagentUsageDimension]]:[];
+ if(!rows.length){
+  $('subagent-usage-rows').innerHTML=`<div class="subagentUsageEmpty emptyState">${subagentUsageDimension==='roles'?'No provider-reported roles are available.':'No child-agent usage is available for this grouping.'}</div>`;
+  return;
+ }
+ const rowMetric=row=>({cost:Number(row?.known_cost)||0,tokens:Number(row?.known_tokens)||0,agents:Number(row?.agents)||0,output:Number(row?.output_per_dollar)||0}[subagentUsageSort]||0);
+ rows.sort((left,right)=>rowMetric(right)-rowMetric(left)||String(left.id||'').localeCompare(String(right.id||'')));
+ const maximum=Math.max(1,...rows.map(rowMetric));
+ $('subagent-usage-rows').innerHTML=rows.map(row=>{
+  const identity=subagentUsageIdentity(row,subagentUsageDimension),agents=Number(row.agents)||0,width=100*rowMetric(row)/maximum;
+  const tokens=row.tokens_available===true?f(row.tokens):Number(row.known_tokens)>0?`${f(row.known_tokens)} known`:'--';
+  const cost=row.cost_available===true?money(row.cost):Number(row.known_cost)>0?`${money(row.known_cost)} known`:'--';
+  const efficiency=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar);
+  return `<div class=subagentUsageRow><div class=subagentUsageIdentity><strong>${esc(identity.label)}</strong><small>${esc(identity.detail)}</small></div><div class=subagentUsageBar aria-hidden=true><i style="width:${Math.max(0,Math.min(100,width))}%"></i></div><div class=subagentUsageValue><span>Agents</span><b>${f(agents)}</b></div><div class=subagentUsageValue><span>Tokens</span><b>${esc(tokens)}</b></div><div class=subagentUsageValue><span>Cost</span><b>${esc(cost)}</b></div><div class=subagentUsageValue><span>Output / $</span><b>${esc(efficiency)}</b></div></div>`;
+ }).join('');
+}
+$('subagent-usage-dimension')?.addEventListener('click',event=>{
+ const dimension=event.target.closest('[data-subagent-dimension]')?.dataset.subagentDimension;
+ if(!['runtimes','models','depths','kinds','roles'].includes(dimension))return;
+ subagentUsageDimension=dimension;
+ localStorage.setItem('tm_subagent_usage_dimension',dimension);
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+});
+$('subagent-usage-sort')?.addEventListener('click',event=>{
+ const sort=event.target.closest('[data-subagent-sort]')?.dataset.subagentSort;
+ if(!['cost','tokens','agents','output'].includes(sort))return;
+ subagentUsageSort=sort;
+ localStorage.setItem('tm_subagent_usage_sort',sort);
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+});
+const subagentFilterBindings={
+ 'subagent-filter-app':['runtime','tm_subagent_filter_app'],
+ 'subagent-filter-project':['project','tm_subagent_filter_project'],
+ 'subagent-filter-model':['model','tm_subagent_filter_model'],
+ 'subagent-filter-status':['status','tm_subagent_filter_status'],
+ 'subagent-filter-signal':['signal','tm_subagent_filter_signal'],
+ 'subagent-filter-time':['window','tm_subagent_filter_time'],
+ 'subagent-filter-sort':['sort','tm_subagent_filter_sort'],
+};
+const subagentFilterStorage={query:'tm_subagent_filter_search',role:'tm_subagent_filter_role',kind:'tm_subagent_filter_kind',runtime:'tm_subagent_filter_app',project:'tm_subagent_filter_project',model:'tm_subagent_filter_model',status:'tm_subagent_filter_status',signal:'tm_subagent_filter_signal',window:'tm_subagent_filter_time',sort:'tm_subagent_filter_sort'};
+const subagentFilterDefaults={query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'};
+function persistSubagentFilter(key){
+ const storage=subagentFilterStorage[key],value=subagentFilters[key],fallback=subagentFilterDefaults[key];
+ if(!storage)return;
+ if(value===fallback)localStorage.removeItem(storage);else localStorage.setItem(storage,value);
+}
+function resetSubagentResultView(){subagentVisibleLimit=SUBAGENT_PAGE_SIZE;selectedSubagentId='';}
+function normalizedSubagentNavigationState(view,filters){
+ const allowed={status:['all','working','complete','incomplete','waiting','recent','unknown'],signal:['all','attention','peer_cost_outlier','active_cost_concentration','retry_pressure'],window:['today','yesterday','7d','30d','90d','month','last_month','all'],sort:['recent','cost','tokens','work','name']},rawSource=filters&&typeof filters==='object'?(filters.window==='24h'?{...filters,window:'today'}:filters):{},source=rawSource.sort==='elapsed'?{...rawSource,sort:'work'}:rawSource;
+ const normalized={...subagentFilterDefaults};
+ ['query','role','kind','runtime','project','model'].forEach(key=>normalized[key]=String(source[key]??subagentFilterDefaults[key]??''));
+ Object.entries(allowed).forEach(([key,values])=>normalized[key]=values.includes(source[key])?source[key]:subagentFilterDefaults[key]);
+ return {view:['issues','sessions','roles'].includes(view)?view:'roles',filters:normalized};
+}
+function restoreSubagentNavigationState(state){
+ if(!state||typeof state!=='object')return false;
+ const snapshot=normalizedSubagentNavigationState(state.view,state.filters);
+ subagentView=snapshot.view;subagentFilters=snapshot.filters;localStorage.setItem('tm_subagent_view',subagentView);
+ Object.keys(subagentFilterDefaults).forEach(persistSubagentFilter);expandedSubagentRoot=null;resetSubagentResultView();
+ return true;
+}
+function openSubagentModelRuns(model,runtime){
+ const current=normalizedSubagentNavigationState(subagentView,subagentFilters),next=normalizedSubagentNavigationState('sessions',{...subagentFilters,query:'',role:'',kind:'',model:String(model||''),runtime:String(runtime||subagentFilters.runtime||'')});
+ history.replaceState({...history.state,subagent:current},'',location.href);
+ history.pushState({...history.state,subagent:next},'',`/#sessions-subagents`);
+ restoreSubagentNavigationState(next);
+}
+function openSubagentRoleRuns(role,runtime,kind){
+ const current=normalizedSubagentNavigationState(subagentView,subagentFilters),next=normalizedSubagentNavigationState('sessions',{...subagentFilters,query:'',role:String(role||''),kind:String(kind||''),runtime:String(runtime||subagentFilters.runtime||'')});
+ history.replaceState({...history.state,subagent:current},'',location.href);
+ history.pushState({...history.state,subagent:next},'',`/#sessions-subagents`);
+ restoreSubagentNavigationState(next);
+}
+window.addEventListener('popstate',event=>{
+ if(!['subagents','sessions-subagents'].includes((location.hash||'').replace(/^#/,''))||!restoreSubagentNavigationState(event.state?.subagent))return;
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+});
+$('subagent-filter-search').addEventListener('input',event=>{
+ subagentFilters.query=event.target.value;persistSubagentFilter('query');resetSubagentResultView();renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+});
+Object.entries(subagentFilterBindings).forEach(([id,[key,storage]])=>$(id).addEventListener('change',event=>{
+ subagentFilters[key]=event.target.value;persistSubagentFilter(key);resetSubagentResultView();renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+}));
+$('subagent-filter-more').onclick=()=>{
+ subagentAdvancedOpen=!subagentAdvancedOpen;
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+ if(subagentAdvancedOpen)requestAnimationFrame(()=>$('subagent-filter-advanced').querySelector('select')?.focus());
+};
+$('subagent-view-tabs').onclick=event=>{
+ const view=event.target.closest('[data-subagent-view]')?.dataset.subagentView;
+ if(!['issues','sessions','roles'].includes(view))return;
+ subagentView=view;localStorage.setItem('tm_subagent_view',view);selectedSubagentId='';expandedSubagentRoot=null;renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+};
+$('subagent-view-tabs').onkeydown=event=>{
+ if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;
+ event.preventDefault();
+ const buttons=[...$('subagent-view-tabs').querySelectorAll('[data-subagent-view]')].filter(button=>button.dataset.subagentView!=='roles'),index=buttons.indexOf(event.target.closest('[data-subagent-view]'));
+ if(index<0)return;
+ const next=event.key==='Home'?0:event.key==='End'?buttons.length-1:(index+(event.key==='ArrowRight'?1:-1)+buttons.length)%buttons.length;
+ buttons[next].focus();buttons[next].click();
+};
+$('subagent-compact-summary').onclick=event=>{
+ const filter=event.target.closest('[data-subagent-summary-filter]')?.dataset.subagentSummaryFilter;
+ if(!filter)return;
+ subagentFilters=toggleSubagentSummaryFilter(subagentFilters,filter);
+ persistSubagentFilter('status');persistSubagentFilter('signal');resetSubagentResultView();
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+};
+$('subagent-active-filters').onclick=event=>{
+ const key=event.target.closest('[data-subagent-clear-filter]')?.dataset.subagentClearFilter;
+ if(!(key in subagentFilterDefaults))return;
+ subagentFilters[key]=subagentFilterDefaults[key];persistSubagentFilter(key);resetSubagentResultView();
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+};
+$('subagent-filter-clear').onclick=()=>{
+ subagentFilters={...subagentFilterDefaults};
+ ['tm_subagent_filter_search','tm_subagent_filter_role','tm_subagent_filter_kind',...Object.values(subagentFilterBindings).map(([,storage])=>storage)].forEach(key=>localStorage.removeItem(key));
+ subagentAdvancedOpen=false;
+ resetSubagentResultView();
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+};
+$('subagent-results').onclick=event=>{
+ const chart=event.target.closest('[data-subagent-role-chart]')?.dataset.subagentRoleChart;
+ if(['spend','average','runs'].includes(chart)){subagentRoleChartMode=chart;localStorage.setItem('tm_subagent_role_chart',chart);renderSubagentExplorer(LATEST?.xsession?.agent_usage);return;}
+ const roleButton=event.target.closest('[data-subagent-inspect-role]');
+ if(roleButton){openSubagentRoleRuns(roleButton.dataset.subagentInspectRole,roleButton.dataset.subagentInspectRuntime,roleButton.dataset.subagentInspectKind);applyHashRoute();return;}
+ const modelButton=event.target.closest('[data-subagent-inspect-model]');
+ if(modelButton){openSubagentModelRuns(modelButton.dataset.subagentInspectModel,modelButton.dataset.subagentInspectRuntime);applyHashRoute();return;}
+ const root=event.target.closest('[data-subagent-show-session]')?.dataset.subagentShowSession;
+ if(root){
+  subagentView='sessions';localStorage.setItem('tm_subagent_view',subagentView);selectedSubagentId='';expandedSubagentRoot=root;renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+  const group=[...$('subagent-results').querySelectorAll('[data-subagent-root]')].find(item=>item.dataset.subagentRoot===root);group?.scrollIntoView({block:'start'});return;
+ }
+ const row=event.target.closest('[data-subagent-id]');
+ if(!row)return;
+ selectedSubagentId=selectedSubagentId===row.dataset.subagentId?'':row.dataset.subagentId;
+ renderSubagentExplorer(LATEST?.xsession?.agent_usage);
+};
+$('subagent-results').addEventListener('toggle',event=>{
+ const group=event.target;if(!(group instanceof HTMLDetailsElement)||!group.matches('[data-subagent-root]'))return;
+ if(group.open)expandedSubagentRoot=group.dataset.subagentRoot;else if(expandedSubagentRoot===group.dataset.subagentRoot)expandedSubagentRoot='';
+},true);
+$('subagent-inspector').onclick=event=>{
+ const root=event.target.closest('[data-subagent-open-parent]')?.dataset.subagentOpenParent;
+ if(root){selectSession(root,{returnScope:'subagents'});return;}
+ if(event.target.closest('[data-subagent-close-detail]')){selectedSubagentId='';renderSubagentExplorer(LATEST?.xsession?.agent_usage);}
+};
diff --git a/dashboard/js/subagents.js b/dashboard/js/subagents.js
new file mode 100644
index 00000000..e4a0187c
--- /dev/null
+++ b/dashboard/js/subagents.js
@@ -0,0 +1,365 @@
+function mergeAllSessionInventory(inventory,liveSessions){
+ // One row per trace file: the server's opaque trace key when present, else the session id.
+ const key=row=>row?.key?compareKeyFor(row):sessionRowKey(row);
+ const rows=new Map((inventory||[]).map(row=>[key(row),row]));
+ (liveSessions||[]).forEach(row=>rows.set(key(row),row));
+ return [...rows.values()];
+}
+function subagentUsageIdentity(row,dimension){
+ const runtime=appFilterLabel({provider:row?.runtime});
+ const kind=String(row?.kind||''),kindLabel=kind?kind[0].toUpperCase()+kind.slice(1):'All kinds';
+ if(dimension==='models')return {label:row?.model||'Unknown model',detail:`${runtime} · ${kindLabel}`};
+ if(dimension==='depths')return {label:`Depth ${Number(row?.depth)||0}`,detail:`${runtime} · ${kindLabel}`};
+ if(dimension==='kinds')return {label:kindLabel,detail:runtime};
+ if(dimension==='roles')return {label:row?.role||'Unreported role',detail:`${runtime} · ${kindLabel} · provider-reported`};
+ return {label:runtime,detail:'all child-agent kinds'};
+}
+function applySubagentPreset(filters,preset){
+ const next={...(filters||{})};
+ if(preset==='incomplete'){next.status='incomplete';next.signal='all';}
+ else if(preset==='attention'){next.status='all';next.signal='attention';}
+ else if(preset==='all'){next.status='all';next.signal='all';}
+ return next;
+}
+function subagentPresetForFilters(filters){
+ const status=String(filters?.status||'all'),signal=String(filters?.signal||'all');
+ if(status==='incomplete'&&signal==='all')return 'incomplete';
+ if(status==='all'&&signal==='attention')return 'attention';
+ if(status==='all'&&signal==='all')return 'all';
+ return 'custom';
+}
+function toggleSubagentSummaryFilter(filters,key){
+ const next={...(filters||{})},filter=String(key||'');
+ if(filter==='incomplete'){
+  next.status=next.status==='incomplete'?'all':'incomplete';
+  next.signal='all';
+ }else if(filter){
+  next.status='all';
+  next.signal=next.signal===filter?'all':filter;
+ }
+ return next;
+}
+function paginateSubagentRows(rows,limit){
+ rows=Array.isArray(rows)?rows:[];
+ const total=rows.length,shown=Math.min(total,Math.max(0,Number(limit)||0));
+ return {rows:rows.slice(0,shown),shown,total,hasMore:shown<total,nextLimit:Math.min(total,shown+50)};
+}
+function subagentActiveFilterItems(filters){
+ const items=[];
+ if(filters.query)items.push({key:'query',label:'Search',value:filters.query});
+ if(filters.role)items.push({key:'role',label:'Role',value:filters.role});
+ if(filters.kind)items.push({key:'kind',label:'Kind',value:filters.kind});
+ if(filters.runtime)items.push({key:'runtime',label:'App',value:appFilterLabel({provider:filters.runtime})});
+ if(filters.project)items.push({key:'project',label:'Project',value:projectFilterLabel(filters.project)});
+ if(filters.window!==DEFAULT_TIME_FILTER_WINDOW)items.push({key:'window',label:'Time',value:TIME_FILTER_LABELS[filters.window]||filters.window});
+ if(filters.model)items.push({key:'model',label:'Model',value:filters.model});
+ if(filters.status!=='all')items.push({key:'status',label:'Status',value:filters.status});
+ if(filters.signal!=='all')items.push({key:'signal',label:'Signal',value:filters.signal==='attention'?'Cost/retry signal':String(filters.signal).replaceAll('_',' ')});
+ if(filters.sort!=='recent')items.push({key:'sort',label:'Sort',value:filters.sort==='work'?'Work time':filters.sort});
+ return items;
+}
+function filterSubagentInventory(usage,filters,nowSeconds){
+ filters=filters||{};nowSeconds=nowSeconds==null?Date.now()/1000:Number(nowSeconds);
+ const inventory=Array.isArray(usage?.inventory)?usage.inventory:[],query=String(filters.query||'').trim().toLowerCase();
+ const runtime=String(filters.runtime||''),project=String(filters.project||''),model=String(filters.model||''),role=String(filters.role||''),kind=String(filters.kind||''),status=String(filters.status||'all'),signal=String(filters.signal||'all'),window=String(filters.window||'all'),sort=String(filters.sort||'recent');
+ const {start:rangeStart,end:rangeEnd}=timeFilterBounds(window,Number(nowSeconds)*1000);
+ const rows=inventory.filter(row=>{
+  const reasons=Array.isArray(row?.attention)?row.attention:[];
+  if(runtime&&String(row?.runtime||'')!==runtime)return false;
+  if(project&&String(row?.project||'')!==project)return false;
+  if(model&&String(row?.model||'')!==model)return false;
+  if(role&&String(row?.role||'')!==role)return false;
+  if(kind&&String(row?.kind||'')!==kind)return false;
+  if(status!=='all'&&String(row?.activity_state||'unknown')!==status)return false;
+  if(signal==='attention'&&!reasons.length)return false;
+  if(signal!=='all'&&signal!=='attention'&&!reasons.some(reason=>String(reason?.code||'')===signal))return false;
+  if(rangeStart&&Number(row?.last_activity_at||0)<rangeStart)return false;
+  if(rangeEnd&&Number(row?.last_activity_at||0)>=rangeEnd)return false;
+  if(query&&!['role','label','model','project','runtime','client'].some(key=>String(row?.[key]||'').toLowerCase().includes(query)))return false;
+  return true;
+ });
+ const name=row=>String(row?.role||row?.label||row?.id||'').toLowerCase();
+ const sorters={
+  recent:(a,b)=>Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0)||name(a).localeCompare(name(b)),
+  cost:(a,b)=>Number(b?.cost||0)-Number(a?.cost||0)||Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0),
+  tokens:(a,b)=>Number(b?.tokens||0)-Number(a?.tokens||0)||Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0),
+  work:(a,b)=>Number(b?.work_time_s!=null)-Number(a?.work_time_s!=null)||Number(b?.work_time_s||0)-Number(a?.work_time_s||0)||Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0),
+  name:(a,b)=>name(a).localeCompare(name(b))||String(a?.id||'').localeCompare(String(b?.id||'')),
+ };
+ rows.sort(sorters[sort]||sorters.recent);
+ const truncated=usage?.inventory_truncated===true,inventoryCount=Math.max(inventory.length,Number(usage?.inventory_count)||0),complete=!truncated;
+ const reasons=rows.flatMap(row=>Array.isArray(row?.attention)?row.attention:[]),signalCounts={};
+ reasons.forEach(reason=>{const code=String(reason?.code||'');if(code)signalCounts[code]=(signalCounts[code]||0)+1;});
+ const summary=complete?{
+  complete:true,agents:rows.length,parentSessions:new Set(rows.map(row=>String(row?.root_session_id||'')).filter(Boolean)).size,
+  incomplete:rows.filter(row=>row?.activity_state==='incomplete').length,working:rows.filter(row=>row?.activity_state==='working').length,
+  attention:rows.filter(row=>Array.isArray(row?.attention)&&row.attention.length).length,
+  costCovered:rows.filter(row=>row?.cost_available===true).length,cost:rows.reduce((total,row)=>total+(row?.cost_available===true?Number(row?.cost)||0:0),0),
+ }: {complete:false,agents:null,parentSessions:null,incomplete:null,working:null,attention:null,costCovered:null,cost:null};
+ return {rows,summary,signalCounts,inventoryCount,truncated};
+}
+function subagentModelDistribution(rows){
+ const groups=new Map();
+ (Array.isArray(rows)?rows:[]).forEach(row=>{
+  const runtime=String(row?.runtime||''),model=String(row?.model||''),key=`${runtime}\n${model}`;
+  if(!groups.has(key))groups.set(key,{runtime,model,runs:0,costCovered:0,cost:0});
+  const group=groups.get(key);group.runs++;
+  if(row?.cost_available===true){group.costCovered++;group.cost+=Number(row.cost)||0;}
+ });
+ return [...groups.values()].sort((a,b)=>b.runs-a.runs||a.runtime.localeCompare(b.runtime)||a.model.localeCompare(b.model));
+}
+function renderSubagentModelDistribution(rows,truncated){
+ const target=$('subagent-model-distribution');
+ if(subagentView!=='sessions'){target.hidden=true;return;}
+ target.hidden=false;
+ const models=subagentModelDistribution(rows),maximum=Math.max(1,...models.map(item=>item.runs));
+ const qualifier=truncated?'Visible runs only · inventory limit reached':'Matching runs';
+ target.innerHTML=`<div class=subagentModelHead><h3>Model distribution</h3><small>${esc(qualifier)} · ${f(rows.length)} ${countWord(rows.length,'run')}</small></div>${models.length?`<div class=subagentModelRows>${models.map(item=>{const label=item.model||'Unknown model',app=appFilterLabel({provider:item.runtime})||'Unknown app',coverage=item.costCovered===item.runs?'':`${f(item.costCovered)} / ${f(item.runs)} cost-covered`;return `<div class=subagentModelRow><span class=subagentModelIdentity title="${esc(`${app} · ${label}`)}"><strong>${esc(label)}</strong> · ${esc(app)}</span><span class=subagentModelTrack aria-hidden=true><i style="width:${(item.runs/maximum*100).toFixed(1)}%"></i></span><span class=subagentModelNumber>${f(item.runs)}</span><span class=subagentModelCost>${item.costCovered?esc(money(item.cost)):'--'}${coverage?`<small>${esc(coverage)}</small>`:''}</span></div>`;}).join('')}</div>`:'<div class="subagentResultsEmpty emptyState">No matching models</div>'}`;
+}
+function renderSubagentExplorerLegacy(usage){
+ const inventory=Array.isArray(usage?.inventory)?usage.inventory:[],filters=subagentFilters;
+ const values=key=>[...new Set(inventory.map(row=>String(row?.[key]||'')).filter(Boolean))].sort((a,b)=>a.localeCompare(b,undefined,{sensitivity:'base'}));
+ const runtimes=values('runtime'),projects=values('project'),models=values('model');
+ if(filters.runtime&&!runtimes.includes(filters.runtime))filters.runtime='';
+ if(filters.project&&!projects.includes(filters.project))filters.project='';
+ if(filters.model&&!models.includes(filters.model))filters.model='';
+ setLogSelectOptions($('subagent-filter-app'),'<option value="">All apps</option>'+runtimes.map(value=>`<option value="${esc(value)}">${esc(appFilterLabel({provider:value}))}</option>`).join(''),filters.runtime);
+ setLogSelectOptions($('subagent-filter-project'),'<option value="">All projects</option>'+projects.map(value=>`<option value="${esc(value)}">${esc(projectFilterLabel(value))}</option>`).join(''),filters.project);
+ setLogSelectOptions($('subagent-filter-model'),'<option value="">All models</option>'+models.map(value=>`<option value="${esc(value)}">${esc(value)}</option>`).join(''),filters.model);
+ $('subagent-filter-search').value=filters.query;$('subagent-filter-status').value=filters.status;$('subagent-filter-signal').value=filters.signal;$('subagent-filter-time').value=filters.window;$('subagent-filter-sort').value=filters.sort;
+ const advancedCount=[filters.model,filters.status!=='all',filters.signal!=='all',filters.sort!=='recent'].filter(Boolean).length;
+ $('subagent-filter-advanced').hidden=!subagentAdvancedOpen;
+ $('subagent-filter-more').setAttribute('aria-expanded',String(subagentAdvancedOpen));
+ $('subagent-filter-more-count').textContent=advancedCount?String(advancedCount):'';
+ const filterItems=subagentActiveFilterItems(filters);
+ $('subagent-active-filters').innerHTML=filterItems.length?'<span>Filtered by</span>'+filterItems.map(item=>`<button class=subagentFilterChip type=button data-subagent-clear-filter="${esc(item.key)}" aria-label="Remove ${esc(item.label)} filter"><b>${esc(item.label)}: ${esc(item.value)}</b><i aria-hidden=true>×</i></button>`).join(''):'';
+ $('subagent-filter-footer').hidden=!filterItems.length;
+ $('subagent-filter-clear').disabled=!filterItems.length;
+ const triageResult=filterSubagentInventory(usage,applySubagentPreset(filters,'all')),triageExact=triageResult.summary.complete;
+ $('subagent-triage-all').textContent=triageExact?f(triageResult.summary.agents):'--';
+ $('subagent-triage-incomplete').textContent=triageExact?f(triageResult.summary.incomplete):'--';
+ $('subagent-triage-attention').textContent=triageExact?f(triageResult.summary.attention):'--';
+ const activePreset=subagentPresetForFilters(filters);
+ [...$('subagent-triage').querySelectorAll('[data-subagent-preset]')].forEach(button=>button.setAttribute('aria-pressed',String(button.dataset.subagentPreset===activePreset)));
+ const result=filterSubagentInventory(usage,filters),summary=result.summary,exact=summary.complete;
+ $('subagent-explorer-meta').hidden=false;$('subagent-explorer-meta').textContent=result.truncated?`${f(result.rows.length)} visible of ${f(result.inventoryCount)} child runs`:result.rows.length===result.inventoryCount?`${f(result.inventoryCount)} child runs`:`${f(result.rows.length)} of ${f(result.inventoryCount)} child runs`;
+ const metric=(label,value,note)=>`<div class="subagentExplorerStat metric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
+ $('subagent-explorer-summary').innerHTML=[
+  metric('Matching agents',exact?f(summary.agents):'--',exact?`${f(summary.incomplete)} incomplete · ${f(summary.working)} working`:'exact filtered total withheld'),
+  metric('Parent sessions',exact?f(summary.parentSessions):'--','open an agent to inspect its parent'),
+  metric('Estimated cost',exact&&summary.costCovered?money(summary.cost):'--','local API-rate estimate'),
+  metric('Cost evidence',exact?`${f(summary.costCovered)} / ${f(summary.agents)}`:'--',exact?'agents with estimated cost available':'exact filtered total withheld'),
+ ].join('');
+ const warning=$('subagent-inventory-warning');warning.hidden=!result.truncated;warning.textContent=result.truncated?'Display limit reached — filtered totals withheld.':'';
+ const insights=[
+  ['Peer cost outlier','peer_cost_outlier','Covered estimated cost is at least $0.50 and 3× the median of at least three comparable peers.'],
+  ['Active cost concentration','active_cost_concentration','A working child has at least $1.00 of covered estimated spend and at least 50% of covered group spend.'],
+  ['Retry pressure','retry_pressure','Provider evidence reports at least three retries or failed attempts in the recent execution window.'],
+ ];
+ $('subagent-insights').innerHTML=insights.map(([label,code,description])=>`<button class=subagentInsight type=button data-subagent-signal="${esc(code)}" aria-pressed="${String(filters.signal===code)}"><strong><span>${esc(label)}</span><b>${triageExact?f(triageResult.signalCounts[code]||0):'--'}</b></strong><p>${esc(description)}</p></button>`).join('');
+ if(selectedSubagentId&&!result.rows.some(row=>String(row?.id||'')===selectedSubagentId))selectedSubagentId='';
+ const page=paginateSubagentRows(result.rows,subagentVisibleLimit);
+ $('subagent-inventory-count').textContent=result.truncated?`${f(page.rows.length)} visible rows from a limited inventory`:`Showing ${f(page.rows.length)} of ${f(page.total)} ${countWord(page.total,'agent')}`;
+ const evidenceMetric=(label,value)=>`<div class="subagentEvidenceMetric metric"><span>${esc(label)}</span><strong>${esc(value)}</strong></div>`;
+ const rows=page.rows.map((row,index)=>{
+  const identity=agentIdentityPresentation(row,index),attention=Array.isArray(row.attention)&&row.attention.length,state=String(row.activity_state||'unknown'),model=row.model&&row.model!=='unknown'?row.model:'model unavailable';
+  const tokens=row.tokens_available===true?f(row.tokens):'--',cost=row.cost_available===true?money(row.cost):'--',workTime=row.work_time_s==null?'--':durationShort(row.work_time_s),secondary=[identity.secondary,row.kind].filter(Boolean).join(' · '),id=String(row.id||''),selected=id&&id===selectedSubagentId,evidenceId=`subagent-evidence-${index}`;
+  let html=`<button class="subagentInventoryRow${attention?' attention':''}${selected?' selected':''}" type=button data-subagent-id="${esc(id)}" aria-expanded="${String(selected)}" aria-controls="${evidenceId}" aria-label="Inspect evidence for ${esc(identity.primary)}"><span class=subagentInventoryIdentity><strong><span>${esc(identity.primary)}</span>${attention?'<span class="agentAttentionBadge chip tone-warn">Needs attention</span>':''}</strong><small>${esc(secondary)}</small></span><span class=subagentInventoryProject title="${esc(row.project||'')}">${esc(projectFilterLabel(row.project)||'No project')}</span><span class=subagentInventoryMetric>${esc(model)}</span><span class="agentState ${esc(state)}">${esc(state)}</span><span class=subagentInventoryMetric>${esc(tokens)}</span><span class=subagentInventoryMetric>${esc(cost)}</span><span class=subagentInventoryMetric>${esc(workTime)}</span></button>`;
+  if(selected){
+   const reasons=attention?row.attention.map(reason=>`<li><strong>${esc(String(reason?.code||'').replaceAll('_',' '))}:</strong> ${esc(reason?.explanation||'Evidence threshold met.')}</li>`).join(''):'';
+   const attempts=Number(row.retries||0)+Number(row.failed_attempts||0),runtime=appFilterLabel({provider:row.runtime});
+   html+=`<div class=subagentEvidence id="${evidenceId}" role=region aria-label="Evidence for ${esc(identity.primary)}"><div class=subagentEvidenceHead><div><h4>${esc(identity.primary)}</h4><p>${esc(identity.secondary?`Provider role · nickname ${identity.secondary}`:'Child-agent evidence')}</p></div><button class=subagentEvidenceClose type=button data-subagent-close-detail aria-label="Close agent evidence">×</button></div><div class=subagentEvidenceContext><span>${esc(runtime)}</span><span>${esc(projectFilterLabel(row.project)||'No project')}</span><span>${esc(model)}</span><span>${esc(row.kind||'child')}</span><span>${esc(state)}</span></div><div class=subagentEvidenceGrid>${evidenceMetric('Estimated cost',cost)}${evidenceMetric('Tokens',tokens)}${evidenceMetric('Work time',workTime)}${evidenceMetric('Executions',f(row.executions||0))}${evidenceMetric('Tool calls',f(row.tool_calls||0))}${evidenceMetric('Retry evidence',f(attempts))}</div><div class=subagentEvidenceSignals><strong>${attention?'Why this needs attention':'Attention evidence'}</strong>${attention?`<ul>${reasons}</ul>`:'<p>No deterministic attention signal is present in the available local evidence.</p>'}</div><div class=subagentEvidenceActions><p>Only content-free local metadata is shown here.</p><button class=subagentOpenParent type=button data-subagent-open-parent="${esc(row.root_session_id)}">Open parent session</button></div></div>`;
+  }
+  return html;
+ }).join('');
+ $('subagent-inventory').innerHTML=result.rows.length?'<div class=subagentInventoryHeader><span>Agent</span><span>Project</span><span>Model</span><span>Status</span><span>Tokens</span><span>Estimated cost</span><span>Work time</span></div>'+rows:'<div class="subagentInventoryEmpty emptyState">No child agents match these filters.</div>';
+ $('subagent-inventory-footer').hidden=!page.hasMore;
+ $('subagent-inventory-more').textContent=page.hasMore?`Show ${f(Math.min(SUBAGENT_PAGE_SIZE,page.total-page.shown))} more · ${f(page.total-page.shown)} remaining`:'';
+ const fineFilter=Boolean(filters.query||filters.model||filters.status!=='all'||filters.signal!=='all');
+ renderSubagentUsage(usage,filters,fineFilter);
+}
+function groupSubagentSessions(rows,issuesOnly=false,sort='priority'){
+ const grouped=new Map();
+ (Array.isArray(rows)?rows:[]).forEach(row=>{
+  const rootSessionId=String(row?.root_session_id||'');
+  if(!rootSessionId)return;
+  const group=grouped.get(rootSessionId)||{rootSessionId,rows:[],agents:0,attention:0,incomplete:0,working:0,cost:0,costCovered:0,knownTokens:0,tokenCovered:0,lastActivity:0,workTime:0,workTimeCovered:0,project:String(row?.project||'')};
+  group.rows.push(row);group.agents+=1;
+  if(Array.isArray(row?.attention)&&row.attention.length)group.attention+=1;
+  if(row?.activity_state==='incomplete')group.incomplete+=1;
+  if(row?.activity_state==='working')group.working+=1;
+  if(row?.cost_available===true){group.cost+=Number(row.cost)||0;group.costCovered+=1;}
+  if(row?.tokens_available===true){group.knownTokens+=Number(row.tokens)||0;group.tokenCovered+=1;}
+  group.lastActivity=Math.max(group.lastActivity,Number(row?.last_activity_at)||0);
+  if(row?.work_time_s!=null){group.workTime+=Number(row.work_time_s)||0;group.workTimeCovered+=1;}
+  grouped.set(rootSessionId,group);
+ });
+ let groups=[...grouped.values()];
+ if(issuesOnly){
+  groups=groups.filter(group=>group.attention||group.incomplete);
+  groups.forEach(group=>group.rows.sort((a,b)=>
+   Number(b?.activity_state==='incomplete')-Number(a?.activity_state==='incomplete')||
+   Number(Boolean(b?.attention?.length))-Number(Boolean(a?.attention?.length))||
+   (Number(b?.cost)||0)-(Number(a?.cost)||0)||
+   (Number(b?.last_activity_at)||0)-(Number(a?.last_activity_at)||0)
+  ));
+ }
+ const sorters={
+  priority:(a,b)=>b.attention-a.attention||b.incomplete-a.incomplete||b.cost-a.cost||b.lastActivity-a.lastActivity||a.rootSessionId.localeCompare(b.rootSessionId),
+  recent:(a,b)=>b.lastActivity-a.lastActivity||b.attention-a.attention||a.rootSessionId.localeCompare(b.rootSessionId),
+  cost:(a,b)=>b.cost-a.cost||b.costCovered-a.costCovered||b.lastActivity-a.lastActivity,
+  tokens:(a,b)=>b.knownTokens-a.knownTokens||b.lastActivity-a.lastActivity,
+  work:(a,b)=>Number(b.workTimeCovered===b.agents)-Number(a.workTimeCovered===a.agents)||b.workTime-a.workTime||b.workTimeCovered-a.workTimeCovered||b.lastActivity-a.lastActivity,
+  name:(a,b)=>a.project.localeCompare(b.project)||a.rootSessionId.localeCompare(b.rootSessionId),
+ };
+ groups.sort(sorters[sort]||sorters.priority);
+ return groups;
+}
+function buildSubagentRoleRows(rows){
+ const grouped=new Map();
+ (Array.isArray(rows)?rows:[]).forEach(row=>{
+  const role=String(row?.role||'').trim();
+  if(!role)return;
+  const runtime=String(row?.runtime||''),kind=String(row?.kind||'child'),key=`${runtime}\n${kind}\n${role}`;
+  const group=grouped.get(key)||{id:key,role,runtime,kind,agents:0,incomplete:0,attention:0,knownCost:0,costCovered:0,knownTokens:0,tokenCovered:0,costs:[],models:new Map()};
+  group.agents+=1;
+  if(row?.activity_state==='incomplete')group.incomplete+=1;
+  if(Array.isArray(row?.attention)&&row.attention.length)group.attention+=1;
+  if(row?.cost_available===true){const cost=Number(row.cost)||0;group.knownCost+=cost;group.costCovered+=1;group.costs.push(cost);}
+  if(row?.tokens_available===true){group.knownTokens+=Number(row.tokens)||0;group.tokenCovered+=1;}
+  const model=String(row?.model||'model unavailable');group.models.set(model,(group.models.get(model)||0)+1);
+  grouped.set(key,group);
+ });
+ return [...grouped.values()].map(group=>{
+  const costs=group.costs.slice().sort((a,b)=>a-b),middle=Math.floor(costs.length/2),medianCost=!costs.length?null:costs.length%2?costs[middle]:(costs[middle-1]+costs[middle])/2,p95Cost=!costs.length?null:costs[Math.max(0,Math.ceil(.95*costs.length)-1)];
+  const topModel=[...group.models].sort((a,b)=>b[1]-a[1]||a[0].localeCompare(b[0]))[0]?.[0]||'model unavailable';
+  return {id:group.id,role:group.role,runtime:group.runtime,kind:group.kind,agents:group.agents,incomplete:group.incomplete,attention:group.attention,incompleteRate:group.agents?group.incomplete/group.agents:0,attentionRate:group.agents?group.attention/group.agents:0,knownCost:group.knownCost,costCovered:group.costCovered,medianCost,p95Cost,knownTokens:group.knownTokens,tokenCovered:group.tokenCovered,topModel};
+ }).sort((a,b)=>b.knownCost-a.knownCost||b.agents-a.agents||a.role.localeCompare(b.role)||a.runtime.localeCompare(b.runtime));
+}
+function subagentRoleKey(row){return `${String(row?.runtime||'')}\n${String(row?.kind||'')}\n${String(row?.role||'')}`;}
+function subagentRoleFineFilters(filters){
+ return Boolean(filters?.model||(filters?.status&&filters.status!=='all')||(filters?.signal&&filters.signal!=='all'));
+}
+function subagentRoleDayRows(usage,filters,nowMs=Date.now()){
+ let rows=(Array.isArray(usage?.role_days)?usage.role_days:[]).filter(row=>(!filters?.runtime||row?.runtime===filters.runtime)&&(!filters?.project||row?.project===filters.project));
+ const query=String(filters?.query||'').trim().toLowerCase();
+ if(query)rows=rows.filter(row=>String(row?.role||'').toLowerCase().includes(query));
+ const dayCount={today:1,"7d":7,"30d":30,"90d":90}[filters?.window];
+ if(['yesterday','month','last_month'].includes(filters?.window)){
+  const range=modelRangeWindow(filters.window,new Date(nowMs));
+  rows=rows.filter(row=>range.daySet.has(String(row?.day||'')));
+ }else if(dayCount){
+  const cutoff=new Date(nowMs);cutoff.setHours(0,0,0,0);cutoff.setDate(cutoff.getDate()-(dayCount-1));
+  const year=cutoff.getFullYear(),month=String(cutoff.getMonth()+1).padStart(2,'0'),day=String(cutoff.getDate()).padStart(2,'0'),cutoffKey=`${year}-${month}-${day}`;
+  rows=rows.filter(row=>String(row?.day||'')>=cutoffKey);
+ }
+ return rows.sort((a,b)=>String(a?.day||'').localeCompare(String(b?.day||''))||subagentRoleKey(a).localeCompare(subagentRoleKey(b)));
+}
+function subagentModelKey(row){return `${String(row?.runtime||'')}\n${String(row?.model||'')}`;}
+function subagentModelDayRows(usage,filters,nowMs=Date.now()){
+ let rows=(Array.isArray(usage?.model_days)?usage.model_days:[]).filter(row=>(!filters?.runtime||row?.runtime===filters.runtime)&&(!filters?.project||row?.project===filters.project));
+ const query=String(filters?.query||'').trim().toLowerCase();
+ if(query)rows=rows.filter(row=>String(row?.model||'').toLowerCase().includes(query));
+ const dayCount={today:1,"7d":7,"30d":30,"90d":90}[filters?.window];
+ if(['yesterday','month','last_month'].includes(filters?.window)){
+  const range=modelRangeWindow(filters.window,new Date(nowMs));
+  rows=rows.filter(row=>range.daySet.has(String(row?.day||'')));
+ }else if(dayCount){
+  const cutoff=new Date(nowMs);cutoff.setHours(0,0,0,0);cutoff.setDate(cutoff.getDate()-(dayCount-1));
+  const cutoffKey=`${cutoff.getFullYear()}-${String(cutoff.getMonth()+1).padStart(2,'0')}-${String(cutoff.getDate()).padStart(2,'0')}`;
+  rows=rows.filter(row=>String(row?.day||'')>=cutoffKey);
+ }
+ return rows.sort((a,b)=>String(a?.day||'').localeCompare(String(b?.day||''))||subagentModelKey(a).localeCompare(subagentModelKey(b)));
+}
+function buildSubagentModelTrends(usage,filters,nowMs=Date.now()){
+ const selected=selectSubagentUsageScope(usage,filters?.runtime,filters?.window,filters?.project,false);
+ if(!selected.usage)return {models:[],days:[]};
+ const query=String(filters?.query||'').trim().toLowerCase(),matches=row=>row?.model&&row.model!=='unknown'&&(!query||String(row.model).toLowerCase().includes(query));
+ const cohort=usage=>Array.isArray(usage?.model_runtimes)?usage.model_runtimes:[];
+ const previous=new Map(cohort(selected.usage.comparison).filter(matches).map(row=>[subagentModelKey(row),row]));
+ const relative=(value,baseline)=>value!=null&&baseline!=null&&baseline>0?(value-baseline)/baseline:null;
+ const models=cohort(selected.usage).filter(matches).map(row=>{
+  const prior=previous.get(subagentModelKey(row)),covered=Number(row?.cost_covered_agents||0),priorCovered=Number(prior?.cost_covered_agents||0);
+  const complete=row?.cost_available===true&&covered===Number(row?.agents||0),priorComplete=prior?.cost_available===true&&priorCovered===Number(prior?.agents||0);
+  return {...row,costChange:prior&&complete&&priorComplete?relative(Number(row.known_cost||0),Number(prior.known_cost||0)):null,
+   averageCostChange:complete&&priorComplete&&covered&&priorCovered?relative(Number(row.known_cost||0)/covered,Number(prior.known_cost||0)/priorCovered):null,
+   runChange:prior?Number(row.agents||0)-Number(prior.agents||0):null};
+ }).sort((a,b)=>Number(b.known_cost||0)-Number(a.known_cost||0)||Number(b.agents||0)-Number(a.agents||0)||String(a.model).localeCompare(String(b.model)));
+ return {models,days:subagentModelDayRows(usage,filters,nowMs),trendTruncated:usage?.model_days_truncated===true};
+}
+function renderSubagentModelTrends(trends){
+ if(!trends?.models?.length)return '';
+ const comparisonsAvailable=!trends.trendTruncated,change=value=>value==null?'--':`${value>0?'↑ ':value<0?'↓ ':''}${Math.abs(value*100).toFixed(0)}%`,changeClass=value=>value==null?'':value<0?' good':value>0?' warn':'';
+ const rows=trends.models.map(row=>{
+  const runs=Number(row.agents||0),covered=Number(row.cost_covered_agents||0),total=covered?money(row.known_cost||0):'--',average=covered?money(Number(row.known_cost||0)/covered):'--';
+  const primary=subagentRoleChartMode==='runs'?f(runs):subagentRoleChartMode==='average'?average:total;
+  const delta=subagentRoleChartMode==='runs'?(!comparisonsAvailable||row.runChange==null?'':`${row.runChange>0?'+':''}${f(row.runChange)} vs prior`):change(comparisonsAvailable?(subagentRoleChartMode==='average'?row.averageCostChange:row.costChange):null);
+  const deltaClass=subagentRoleChartMode==='average'?changeClass(comparisonsAvailable?row.averageCostChange:null):'';
+  const label={spend:covered===runs?'Spend':'Covered spend',average:covered===runs?'Cost / run':'Cost / covered run',runs:'Runs'}[subagentRoleChartMode]||'Cost / run';
+  const distribution=row.median_cost==null||row.p95_cost==null?'--':`${money(row.median_cost)} / ${money(row.p95_cost)}`,incomplete=Number(row.incomplete_agents||0),app=appFilterLabel({provider:row.runtime});
+  return `<div class=subagentRoleTrendRow><div class=subagentRoleIdentity><strong title="${esc(row.model)}">${esc(row.model)}</strong><small>${esc(appFilterLabel({provider:row.runtime}))} · ${esc(`${f(runs)} ${runs===1?'run':'runs'}`)}<br>${esc(`${f(covered)}/${f(runs)} priced`)}</small></div><div class="subagentRolePrimary${deltaClass}"><span>${esc(label)}</span><b>${esc(primary)}</b>${delta&&delta!=='--'?`<small>${esc(delta)}</small>`:''}</div>${renderSubagentTrendSparkline(trends.days,trends.trendTruncated,subagentModelKey,row,row.model)}<div class=subagentRoleMeta><span>Median / P95</span><b>${esc(distribution)}</b>${incomplete?`<span class="subagentRoleSignal warn">${f(incomplete)} incomplete</span>`:''}</div><button class=subagentRoleInspect type=button data-subagent-inspect-model="${esc(row.model)}" data-subagent-inspect-runtime="${esc(row.runtime)}" aria-label="${esc(`View runs for ${row.model} in ${app}`)}">View runs</button></div>`;
+ }).join('');
+ return `<div class=subagentRoleTrendHead><div><h4>Model trends</h4><p>Child runs by the model they ran on · same metric as above</p></div></div><div class=subagentRoleTrendList>${rows}</div>`;
+}
+function buildSubagentRoleEconomics(usage,filters,nowMs=Date.now()){
+ if(subagentRoleFineFilters(filters))return {reason:'filtered',roles:[],days:[]};
+ const selected=selectSubagentUsageScope(usage,filters?.runtime,filters?.window,filters?.project,false);
+ if(!selected.usage)return {reason:selected.reason||'unavailable',roles:[],days:[]};
+ const query=String(filters?.query||'').trim().toLowerCase(),matchesRole=row=>!query||String(row?.role||'').toLowerCase().includes(query);
+ const roles=(Array.isArray(selected.usage.roles)?selected.usage.roles:[]).filter(matchesRole),previousRoles=(Array.isArray(selected.usage.comparison?.roles)?selected.usage.comparison.roles:[]).filter(matchesRole),previousByKey=new Map(previousRoles.map(row=>[subagentRoleKey(row),row]));
+ if(!roles.length)return {reason:'empty',roles:[],days:[]};
+ const totals=items=>{
+  const runs=items.reduce((sum,row)=>sum+Number(row?.agents||0),0),costCovered=items.reduce((sum,row)=>sum+Number(row?.cost_covered_agents||0),0),costComplete=Boolean(runs)&&costCovered===runs&&items.every(row=>row?.cost_available===true),knownCost=items.reduce((sum,row)=>sum+Number(row?.known_cost||0),0);
+  return {runs,costCovered,costComplete,cost:costCovered?knownCost:null,averageCost:costCovered?knownCost/costCovered:null,incomplete:items.reduce((sum,row)=>sum+Number(row?.incomplete_agents||0),0),attention:items.reduce((sum,row)=>sum+Number(row?.attention_agents||0),0)};
+ };
+ const current=totals(roles),previous=totals(previousRoles),hasPrevious=previousRoles.length>0;
+ const relative=(value,baseline)=>value!=null&&baseline!=null&&baseline>0?(value-baseline)/baseline:null;
+ const comparedRoles=roles.map(row=>{
+  const prior=previousByKey.get(subagentRoleKey(row)),currentCovered=Number(row?.cost_covered_agents||0),priorCovered=Number(prior?.cost_covered_agents||0),currentComplete=row?.cost_available===true&&currentCovered===Number(row?.agents||0),priorComplete=prior?.cost_available===true&&priorCovered===Number(prior?.agents||0),currentAverage=currentCovered?Number(row.known_cost||0)/currentCovered:null,priorAverage=priorCovered?Number(prior.known_cost||0)/priorCovered:null;
+  return {...row,previousAgents:prior?Number(prior.agents||0):null,previousCost:priorComplete?Number(prior.known_cost||0):null,costChange:prior&&currentComplete&&priorComplete?relative(Number(row.known_cost||0),Number(prior.known_cost||0)):null,averageCostChange:currentComplete&&priorComplete?relative(currentAverage,priorAverage):null,runChange:prior?Number(row.agents||0)-Number(prior.agents||0):null};
+ }).sort((a,b)=>Number(b.known_cost||0)-Number(a.known_cost||0)||Number(b.agents||0)-Number(a.agents||0)||String(a.role).localeCompare(String(b.role)));
+ return {reason:null,window:String(filters?.window||'all'),...current,previousRuns:hasPrevious?previous.runs:null,previousCost:hasPrevious?previous.cost:null,previousAverageCost:hasPrevious?previous.averageCost:null,previousIncomplete:hasPrevious?previous.incomplete:null,costChange:hasPrevious&&current.costComplete&&previous.costComplete?relative(current.cost,previous.cost):null,averageCostChange:hasPrevious&&current.costComplete&&previous.costComplete?relative(current.averageCost,previous.averageCost):null,runChange:hasPrevious?current.runs-previous.runs:null,roles:comparedRoles,days:subagentRoleDayRows(usage,filters,nowMs),trendTruncated:usage?.role_days_truncated===true,roleDayCount:Number(usage?.role_day_count||0),modelTrends:buildSubagentModelTrends(usage,filters,nowMs)};
+}
+function renderSubagentRoleSparkline(economics,role){
+ return renderSubagentTrendSparkline(economics?.days,economics?.trendTruncated,subagentRoleKey,role,role.role);
+}
+function renderSubagentTrendSparkline(dayRows,truncated,keyFn,role,name){
+ if(truncated)return '<div class=subagentRoleSparkEmpty>Trend unavailable · daily history was truncated</div>';
+ const allRows=Array.isArray(dayRows)?dayRows:[],key=keyFn(role),roleRows=allRows.filter(row=>keyFn(row)===key),days=[...new Set(roleRows.map(row=>String(row?.day||'')).filter(Boolean))].sort();
+ if(!days.length)return '<div class=subagentRoleSparkEmpty>Trend unavailable</div>';
+ const points=new Map();
+ roleRows.forEach(row=>{const day=String(row?.day||''),point=points.get(day)||{cost:0,runs:0,complete:true};point.cost+=Number(row?.known_cost||0);point.runs+=Number(row?.agents||0);point.complete=point.complete&&row?.cost_available===true;points.set(day,point);});
+ if(subagentRoleChartMode!=='runs'&&[...points.values()].some(point=>!point.complete))return '<div class=subagentRoleSparkEmpty>Spend trend hidden: some runs have no price. Switch to Runs to see the trend.</div>';
+ const value=day=>{const point=points.get(day);if(subagentRoleChartMode==='runs')return point.runs;if(subagentRoleChartMode==='average')return point.runs?point.cost/point.runs:0;return point.cost;},values=days.map(value),maximum=Math.max(.000001,...values),width=220,height=62,pad=5;
+ const x=index=>days.length===1?width/2:pad+index*(width-2*pad)/(days.length-1),y=item=>height-pad-(item/maximum)*(height-2*pad),line=values.map((item,index)=>`${x(index).toFixed(1)},${y(item).toFixed(1)}`).join(' '),area=days.length>1?`M ${x(0).toFixed(1)} ${height-pad} L ${line.replaceAll(' ',', ')} L ${x(days.length-1).toFixed(1)} ${height-pad} Z`:'';
+ const modeLabel={spend:'spend',average:'cost per run',runs:'runs'}[subagentRoleChartMode]||'spend',mark=days.length===1?`<circle cx="${x(0)}" cy="${y(values[0])}" r=3 fill=var(--accent)/>`:`<path d="${area}" style="fill:rgb(var(--signal-rgb)/.08)"/><polyline points="${line}" fill=none stroke=var(--accent) stroke-width=2.2 vector-effect=non-scaling-stroke/>`;
+ return `<div class=subagentRoleSpark><svg viewBox="0 0 ${width} ${height}" preserveAspectRatio=none role=img aria-label="${esc(name)} ${esc(modeLabel)} trend">${mark}</svg><div class=subagentRoleSparkDates><span>${esc(days[0])}</span><span>${esc(days[days.length-1])}</span></div></div>`;
+}
+function renderSubagentRoleEconomics(economics){
+ if(economics?.reason==='filtered')return '<div class=subagentRoleAnalyticsEmpty><strong>Role trends unavailable for these row filters</strong><p>Clear Model, Status, and Signal to compare exact role periods. The filtered role table remains available below.</p></div>';
+ if(!economics||economics.reason)return `<div class="subagentResultsEmpty emptyState"><div><strong>No provider-reported roles match</strong>${economics?.reason==='unavailable'?'Exact role aggregates are unavailable for this scope.':'Adjust the app, project, or time range, or inspect Sessions for anonymous child agents.'}</div></div>`;
+ const change=value=>value==null?'--':`${value>0?'↑ ':value<0?'↓ ':''}${Math.abs(value*100).toFixed(0)}%`,changeClass=value=>value==null?'':value<0?' good':value>0?' warn':'';
+ const comparisonsAvailable=!economics.trendTruncated,comparisonUnavailable='Comparison unavailable: daily series truncated';
+ const coverage=`${f(economics.costCovered)} / ${f(economics.runs)} cost-covered`,costComplete=economics.costCovered===economics.runs,baseline=!comparisonsAvailable?comparisonUnavailable:economics.previousRuns==null?'':economics.costChange==null?'Comparison unavailable':`${change(economics.costChange)} vs prior`;
+ const kpi=(label,value,note,kind='')=>`<div class="subagentRoleKpi metric ${kind}"><span>${esc(label)}</span><strong>${esc(value)}</strong>${note?`<small>${esc(note)}</small>`:''}</div>`;
+ const rows=economics.roles.map(row=>{
+  const runs=Number(row.agents||0),covered=Number(row.cost_covered_agents||0),roleCoverage=`${f(covered)}/${f(runs)} priced`,total=covered?money(row.known_cost||0):'--',average=covered?money(Number(row.known_cost||0)/covered):'--',incomplete=Number(row.incomplete_agents||0);
+  const primary=subagentRoleChartMode==='runs'?f(runs):subagentRoleChartMode==='average'?average:total;
+  const delta=subagentRoleChartMode==='runs'?(!comparisonsAvailable||row.runChange==null?'':`${row.runChange>0?'+':''}${f(row.runChange)} vs prior`):change(comparisonsAvailable?(subagentRoleChartMode==='average'?row.averageCostChange:row.costChange):null);
+  const deltaClass=subagentRoleChartMode==='average'?changeClass(comparisonsAvailable?row.averageCostChange:null):'';
+  const label={spend:covered===runs?'Spend':'Covered spend',average:covered===runs?'Cost / run':'Cost / covered run',runs:'Runs'}[subagentRoleChartMode]||'Cost / run';
+  const distribution=row.median_cost==null||row.p95_cost==null?'--':`${money(row.median_cost)} / ${money(row.p95_cost)}`;
+  return `<div class=subagentRoleTrendRow><div class=subagentRoleIdentity><strong>${esc(row.role)}</strong><small>${esc(appFilterLabel({provider:row.runtime}))} · ${esc(row.kind||'child')} · ${esc(`${f(runs)} ${runs===1?'run':'runs'}`)}<br>${esc(roleCoverage)}</small></div><div class="subagentRolePrimary${deltaClass}"><span>${esc(label)}</span><b>${esc(primary)}</b>${delta&&delta!=='--'?`<small>${esc(delta)}</small>`:''}</div>${renderSubagentRoleSparkline(economics,row)}<div class=subagentRoleMeta><span>Median / P95</span><b>${esc(distribution)}</b>${incomplete?`<span class="subagentRoleSignal warn">${f(incomplete)} incomplete</span>`:''}</div><button class=subagentRoleInspect type=button data-subagent-inspect-role="${esc(row.role)}" data-subagent-inspect-runtime="${esc(row.runtime)}" data-subagent-inspect-kind="${esc(row.kind)}" aria-label="${esc(`View runs for ${row.role} in ${appFilterLabel({provider:row.runtime})}`)}">View runs</button></div>`;
+ }).join('');
+ const averageNote=!comparisonsAvailable?comparisonUnavailable:economics.previousRuns==null?'':economics.averageCostChange==null?'Comparison unavailable':`${change(economics.averageCostChange)} vs prior`,runsNote=!comparisonsAvailable?comparisonUnavailable:economics.runChange==null?'':`${economics.runChange>0?'+':''}${f(economics.runChange)} vs prior`;
+ return `<div class=subagentRoleEconomics><div class=subagentRoleKpis>${kpi(costComplete?'Cost / run':'Cost / covered run',economics.averageCost==null?'--':money(economics.averageCost),costComplete?averageNote:coverage,changeClass(comparisonsAvailable?economics.averageCostChange:null))}${kpi(costComplete?'Role spend':'Covered role spend',economics.cost==null?'--':money(economics.cost),costComplete?baseline:coverage)}${kpi('Named runs',f(economics.runs),runsNote)}</div><div class=subagentRoleTrendHead><div><h4>Role trends</h4></div><div class="seg subagentRoleChartModes"><button class="${subagentRoleChartMode==='average'?'on':''}" type=button data-subagent-role-chart=average>Cost / run</button><button class="${subagentRoleChartMode==='spend'?'on':''}" type=button data-subagent-role-chart=spend>Spend</button><button class="${subagentRoleChartMode==='runs'?'on':''}" type=button data-subagent-role-chart=runs>Runs</button></div></div><div class=subagentRoleTrendList>${rows}</div>${renderSubagentModelTrends(economics.modelTrends)}<p class=subagentRoleEconomicsFoot>Local API-rate estimates · Cost per run is not a quality score.</p></div>`;
+}
+function subagentParentSessionMap(){
+ const rows=[...(allSessionInventory||[]),...(LATEST?.xsession?.sessions||[]),...(LATEST?.xsession?.current_sessions||[])],result=new Map();
+ rows.forEach(row=>{const id=String(row?.id||'');if(id&&!result.has(id))result.set(id,row);});
+ return result;
+}
+function subagentParentPresentation(rootSessionId,project,parentSessions=subagentParentSessionMap()){
+ const row=parentSessions.get(String(rootSessionId||'')),title=String(row?.title||row?.session_name||'').trim();
+ return {title:title||'Parent session',project:projectFilterLabel(project||row?.project)||'No project',runtime:appFilterLabel(row||{})};
+}
diff --git a/dashboard/js/theme-navigation.js b/dashboard/js/theme-navigation.js
new file mode 100644
index 00000000..05bd0720
--- /dev/null
+++ b/dashboard/js/theme-navigation.js
@@ -0,0 +1,288 @@
+const THEMES=[
+ {id:'classic',label:'Classic',tagline:'The original cyan instrument field'},
+ {id:'nebula',label:'Nebula',tagline:'Ultraviolet glass with ion-cyan and mint highlights'},
+ {id:'monolith',label:'Monolith',tagline:'Graphite and platinum with one vermilion tip'},
+ {id:'voltage',label:'Voltage',tagline:'Volt yellow on carbon with cyan and magenta sparks'},
+ {id:'phosphor',label:'Phosphor',tagline:'Terminal green with falling-code rain'},
+ {id:'omarchy',label:'Omarchy',tagline:'Deep indigo with blue, violet, and sky neon'},
+ {id:'jadehorse',label:'Jade Horse',tagline:'Deep pine surfaces with celadon jade and pale green-white text'},
+ {id:'ferrous',label:'Ferrous',tagline:'Oxidized red rust with molten amber and coolant-teal sparks'},
+ {id:'afterglow',label:'Afterglow',tagline:'Plum dusk with a pink-to-amber sunset horizon'},
+];
+const THEME_STORAGE_KEY='tm_theme';
+const normalizeThemeId=value=>THEMES.some(theme=>theme.id===value)?value:'classic';
+const themeLabel=id=>THEMES.find(theme=>theme.id===id)?.label||'Classic';
+const resolveTheme=preference=>window.tokenMeterTheme?.resolve(preference)||preference;
+let themePreference=(()=>{try{return normalizeThemeId(localStorage.getItem(THEME_STORAGE_KEY));}catch(error){return 'classic';}})();
+let activeTheme=document.documentElement.dataset.theme||'classic';
+function renderThemePicker(){
+ const host=$('theme-picker');
+ host.innerHTML=THEMES.map(theme=>`<button type=button class=themeOption aria-pressed=false data-theme-option="${theme.id}" title="${esc(theme.tagline)}" style="--theme-swatch:var(--swatch-${theme.id});--theme-swatch-bg:var(--swatch-${theme.id}-bg)"><span class=themePreview aria-hidden=true><i></i><i></i><i></i></span><span class=themeCopy><b>${esc(theme.label)}</b><small>${esc(theme.tagline)}</small></span></button>`).join('');
+ paintThemePicker();
+}
+function paintThemePicker(){
+ [...$('theme-picker').querySelectorAll('[data-theme-option]')].forEach(option=>{
+  option.setAttribute('aria-pressed',String(option.dataset.themeOption===themePreference));
+ });
+ $('theme-current-badge').textContent=themeLabel(activeTheme);
+}
+function repaintThemedSurfaces(){
+ document.querySelector('meta[name=theme-color]')?.setAttribute('content',cssVar('--bg'));
+ readChartTokens();
+ if(activeModelStats&&activeModelScope===modelProject)renderModelStats(activeModelStats);
+ if(activeEfficiencyStats&&activeEfficiencyScope===efficiencyProject)renderEfficiency(activeEfficiencyStats);
+ if(CURRENT)drawIO(CURRENT.series||[]);
+ if(spendInsightPayload)drawSpendScatter(spendInsightPayload.sessions||[]);
+ if(deliveryPayload)drawDeliveryChart(deliveryPayload.days||[]);
+ if(compareData)renderComparison();
+ syncActivePageSignalEffects();
+}
+function setTheme(preference,{persist=true,origin=null}={}){
+ preference=normalizeThemeId(preference);
+ if(persist){try{localStorage.setItem(THEME_STORAGE_KEY,preference);}catch(error){}}
+ themePreference=preference;
+ const id=resolveTheme(preference);
+ if(id===activeTheme){paintThemePicker();return;}
+ activeTheme=id;
+ paintThemePicker();
+ // The latest choice wins even if an earlier transition callback is still queued.
+ const commit=()=>{document.documentElement.dataset.theme=activeTheme;repaintThemedSurfaces();};
+ if(!document.startViewTransition||pageSignalReducedMotionQuery.matches){commit();return;}
+ const root=document.documentElement,generation=setTheme.revealGeneration=(setTheme.revealGeneration||0)+1;
+ root.classList?.toggle('themeReveal',!!origin);
+ const transition=document.startViewTransition(commit);
+ // A pointer pick grows the new theme out of the option that was pressed.
+ if(origin&&transition?.ready)transition.ready.then(()=>{
+  const radius=Math.hypot(Math.max(origin.x,innerWidth-origin.x),Math.max(origin.y,innerHeight-origin.y));
+  root.animate({clipPath:[`circle(0px at ${origin.x}px ${origin.y}px)`,`circle(${Math.ceil(radius)}px at ${origin.x}px ${origin.y}px)`]},{duration:480,easing:cssVar('--ease-in-out'),pseudoElement:'::view-transition-new(root)'});
+ }).catch(()=>{});
+ transition?.finished?.catch(()=>{}).finally(()=>{if(generation===setTheme.revealGeneration)root.classList.remove('themeReveal');});
+}
+renderThemePicker();
+document.querySelector('meta[name=theme-color]')?.setAttribute('content',getComputedStyle(document.documentElement).getPropertyValue('--bg').trim());
+$('theme-picker').onclick=event=>{const option=event.target.closest('[data-theme-option]');if(option)setTheme(option.dataset.themeOption,{origin:event.detail?{x:event.clientX,y:event.clientY}:null});};
+window.addEventListener('storage',event=>{if(event.key===THEME_STORAGE_KEY)setTheme(event.newValue,{persist:false});});
+
+const NAV_COMMANDS=[
+ {id:'sessions',label:'Sessions',description:'Choose a recently active local session',section:'Navigate',action:'sessions'},
+ {id:'all-sessions',label:'All sessions',description:'Search, filter, and open recorded session history',aliases:'logs',section:'Navigate',route:'sessions-all',glyph:'All'},
+ {id:'compare-sessions',label:'Compare sessions',description:'Put selected sessions side by side',aliases:'diff same prompt runs',section:'Navigate',route:'sessions-compare',glyph:'A|B'},
+ {id:'spend',label:'Spend',description:'Review spend across days and runtimes',section:'Navigate',route:'spend'},
+ {id:'models',label:'Models',description:'Compare model spend, speed, and cache efficiency',section:'Navigate',route:'models'},
+ {id:'subagents',label:'Subagents',description:'Track custom-agent spend and inspect child runs',section:'Navigate',route:'subagents'},
+ {id:'efficiency',label:'Efficiency',description:'Review token efficiency overall and by model runtime',section:'Navigate',route:'efficiency'},
+ {id:'work',label:'Work',description:'See where spend went, how sessions ended, and right-sizing',section:'Navigate',route:'work'},
+ {id:'git',label:'Git',description:'Compare locally observed pushed code with covered AI spend',section:'Navigate',route:'git'},
+ {id:'learn',label:'Learn',description:'Learn what drives cost and how to measure it',section:'Navigate',route:'learn'},
+ {id:'capabilities',label:'Tools',description:'Inspect tools, MCPs, and optional skill packs',section:'Navigate',route:'capabilities'},
+ {id:'settings',label:'Settings',description:'Configure pricing, analytics, connections, and updates',section:'Navigate',route:'settings'},
+ {id:'spend-budgets',label:'Spend · Monthly budget',description:'Set runtime budgets and track their monthly total',section:'Navigate',route:'spend-budgets',glyph:'$'},
+ {id:'spend-discounts',label:'Spend · Discounts',description:'Add the discount you pay so spend and budgets match your bill',section:'Navigate',route:'spend-discounts',glyph:'$'},
+ {id:'session-run',label:'Session · Run',description:'Review cost, context, and pace for the selected session',section:'Selected session',route:'summary',action:'selected-session',glyph:'R'},
+ {id:'appearance',label:'Settings · Appearance',description:'Choose the dashboard theme',aliases:'theme colors look',section:'Appearance',route:'settings-appearance',glyph:'◐'},
+ ...THEMES.map(theme=>({id:`theme-${theme.id}`,label:`Theme · ${theme.label}`,description:theme.tagline,aliases:'appearance theme colors look',section:'Appearance',action:'theme',theme:theme.id,glyph:'◑'})),
+ {id:'welcome',label:'Open welcome tour',description:'Replay the 12-slide tour of Token Meter pages',aliases:'getting started onboarding intro help tour',section:'Help',action:'welcome',glyph:'?'},
+];
+let visibleCommands=[],commandIndex=0,commandReturnFocus=null;
+function setCommandIndex(index,{scroll=true}={}){
+ const items=[...$('command-list').querySelectorAll('[data-command-index]')];
+ if(!items.length){commandIndex=0;$('command-search').removeAttribute('aria-activedescendant');return;}
+ commandIndex=(index+items.length)%items.length;
+ items.forEach((item,i)=>{const selected=i===commandIndex;item.classList.toggle('selected',selected);item.setAttribute('aria-selected',String(selected));});
+ const active=items[commandIndex];
+ $('command-search').setAttribute('aria-activedescendant',active.id);
+ if(scroll)active.scrollIntoView({block:'nearest'});
+}
+function renderCommandPalette(query=''){
+ const terms=query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+ visibleCommands=NAV_COMMANDS.filter(command=>{
+  if(command.id==='work'&&workSupported!==true)return false;
+  const haystack=`${command.label} ${command.description} ${command.aliases||''} ${command.section}`.toLowerCase();
+  return terms.every(term=>haystack.includes(term));
+ });
+ let section='';
+ $('command-list').innerHTML=visibleCommands.length?visibleCommands.map((command,index)=>{
+  const heading=command.section!==section?`<div class=commandGroup role=presentation>${esc(command.section)}</div>`:'';
+  section=command.section;
+  return `${heading}<button class=commandItem id="command-option-${index}" type=button role=option aria-selected=false data-command-index="${index}"><span class=commandGlyph>${esc(command.action==='theme'&&command.theme===themePreference?'✓':command.glyph||'→')}</span><span class=commandCopy><span class=commandLabel>${esc(command.label)}</span><span class=commandDescription>${esc(command.description)}</span></span></button>`;
+ }).join(''):'<div class="commandEmpty emptyState">No matching commands</div>';
+ setCommandIndex(0,{scroll:false});
+}
+function openCommandPalette(){
+ const dialog=$('command-palette'),other=document.querySelector('dialog[open]');
+ if(other&&other!==dialog)return false;
+ if(dialog.open)return true;
+ commandReturnFocus=document.activeElement;
+ $('command-search').value='';
+ renderCommandPalette();
+ dialog.showModal();
+ requestAnimationFrame(()=>$('command-search').focus());
+ return true;
+}
+function closeCommandPalette(){if($('command-palette').open)$('command-palette').close();}
+function runNavigationCommand(command){
+ if(!command)return;
+ closeCommandPalette();
+ if(command.action==='welcome'){const returnFocus=commandReturnFocus;commandReturnFocus=null;openWelcome(null,{returnFocus});return;}
+ if(command.action==='theme'){setTheme(command.theme);return;}
+ if(command.action==='sessions'){openCurrentSessions();return;}
+ if(command.action==='selected-session'){openSelectedSessionRoute(command.route);return;}
+ if(command.latest)goToLatestSession();
+ else openTopLevelRoute(command.route);
+}
+$('command-search').addEventListener('input',event=>renderCommandPalette(event.target.value));
+$('command-list').onclick=event=>{const item=event.target.closest('[data-command-index]');if(item)runNavigationCommand(visibleCommands[Number(item.dataset.commandIndex)]);};
+$('command-palette').addEventListener('click',event=>{if(event.target===$('command-palette'))closeCommandPalette();});
+$('command-palette').addEventListener('close',()=>{
+ const target=commandReturnFocus;
+ commandReturnFocus=null;
+ if(target?.focus&&target.offsetParent!==null)target.focus();
+});
+document.addEventListener('keydown',event=>{
+ const palette=$('command-palette'),key=String(event.key||'').toLowerCase();
+ if($('welcome-dialog').open){handleWelcomeKey(event);return;}
+ if((event.metaKey||event.ctrlKey)&&!event.altKey&&!event.shiftKey&&key==='k'){
+  event.preventDefault();
+  if(palette.open)closeCommandPalette();else openCommandPalette();
+  return;
+ }
+ if(palette.open){
+  if(event.key==='Escape'){event.preventDefault();closeCommandPalette();}
+  else if(event.key==='ArrowDown'){event.preventDefault();setCommandIndex(commandIndex+1);}
+  else if(event.key==='ArrowUp'){event.preventDefault();setCommandIndex(commandIndex-1);}
+  else if(event.key==='Enter'&&!event.isComposing){event.preventDefault();runNavigationCommand(visibleCommands[commandIndex]);}
+  return;
+ }
+ handleLearnDeckKey(event);
+});
+
+const PANEL_KEYS=['summary'];
+const PANEL_ALIAS={overview:'summary',flow:'summary',analysis:'summary',settings:'summary',activity:'summary',tools:'summary',alerts:'summary'};
+const CURRENT_PANEL_KEYS=['sessions','run'];
+const CURRENT_PANEL_ROUTES={sessions:'sessions',run:'summary'};
+const storedSessionPanel=PANEL_ALIAS[localStorage.getItem('tm_session_panel')]||localStorage.getItem('tm_session_panel')||'summary';
+let sessionPanel=PANEL_KEYS.includes(storedSessionPanel)?storedSessionPanel:'summary';
+let currentPanel=sessionPanel==='summary'?'run':sessionPanel;
+function restoreCurrentModules(){
+ const homes=[
+  ['session-chart-home','session-chart-module'],
+  ['session-efficiency-home','session-efficiency'],
+  ['session-budget-home','session-budget-control'],
+  ['session-token-split-home','session-token-split-module'],
+ ];
+ homes.forEach(([homeId,moduleId])=>{const home=$(homeId),module=$(moduleId);if(home&&module&&module.parentElement!==home)home.appendChild(module);});
+}
+function mountCurrentModule(slotId,moduleId){
+ const slot=$(slotId),module=$(moduleId);
+ if(slot&&module&&module.parentElement!==slot)slot.appendChild(module);
+}
+function showCurrentPanel(panel){
+ panel=PANEL_ALIAS[panel]||panel;
+ if(panel==='summary')panel='run';
+ if(!CURRENT_PANEL_KEYS.includes(panel))panel='run';
+ currentPanel=panel;
+ if(panel!=='sessions'){
+  sessionPanel=CURRENT_PANEL_ROUTES[panel];
+  localStorage.setItem('tm_session_panel',sessionPanel);
+ }
+ const overview=panel==='sessions';
+ $('view-session').classList.toggle('sessionOverview',overview);
+ $('view-session').classList.toggle('sessionDetail',!overview);
+ document.querySelectorAll('[data-current-detail]').forEach(element=>element.classList.toggle('currentOverviewHidden',overview));
+ if(!overview)renderSessionBack();
+ $('session-page-title').textContent=overview?'Sessions':sessionDisplayName(CURRENT);
+ const pageHelp=overview?sessionScopeCopy(sessionScope)[1]:'Review this session.';
+ $('session-page-title').setAttribute('aria-description',pageHelp);
+ $('session-page-title').dataset.tip=pageHelp;
+ $('current-description').textContent=overview?sessionScopeCopy(sessionScope)[0]:(pinned?'Pinned run · updates every two seconds.':'Live run · updates with the trace.');
+ CURRENT_PANEL_KEYS.forEach(key=>$(`preview-surface-${key}`).classList.toggle('on',key===panel));
+ restoreCurrentModules();
+ if(panel==='sessions'){
+  renderCurrentSessions();
+  renderSessionScope();
+ }else if(panel==='run'){
+ mountCurrentModule('preview-run-chart-slot','session-chart-module');
+  mountCurrentModule('preview-run-efficiency-slot','session-efficiency');
+  mountCurrentModule('preview-run-budget-slot','session-budget-control');
+  mountCurrentModule('preview-token-split-slot','session-token-split-module');
+  if(CURRENT)requestAnimationFrame(()=>drawIO(CURRENT.series||[]));
+ }
+}
+
+function showTab(t){
+ if(t!=='session')restoreCurrentModules();
+ if(t!=='git')dismissGitChartInspector();
+ const spend=t==='spend'||t==='daily';
+ document.body.classList.toggle('sessionRoute',t==='session');
+ $('tab-session').classList.toggle('on',t==='session');
+	 $('tab-models').classList.toggle('on',t==='models');
+ $('tab-subagents').classList.toggle('on',t==='subagents');
+ $('tab-daily').classList.toggle('on',spend);
+ $('tab-capabilities').classList.toggle('on',t==='capabilities');
+ $('tab-efficiency').classList.toggle('on',t==='efficiency');
+ $('tab-work').classList.toggle('on',t==='work');
+ $('tab-git').classList.toggle('on',t==='git');
+ $('tab-learn').classList.toggle('on',t==='learn');
+ $('tab-settings').classList.toggle('on',t==='settings');
+ $('view-session').classList.toggle('on',t==='session');
+	 $('view-models').classList.toggle('on',t==='models');
+ $('view-subagents').classList.toggle('on',t==='subagents');
+ $('view-daily').classList.toggle('on',spend);
+ $('view-capabilities').classList.toggle('on',t==='capabilities');
+ $('view-efficiency').classList.toggle('on',t==='efficiency');
+ $('view-work').classList.toggle('on',t==='work');
+ $('view-git').classList.toggle('on',t==='git');
+ $('view-learn').classList.toggle('on',t==='learn');
+ $('view-settings').classList.toggle('on',t==='settings');
+ [...document.querySelectorAll('.top .tab')].forEach(button=>{
+  if(button.id===(spend?'tab-daily':`tab-${t}`))button.setAttribute('aria-current','page');
+  else button.removeAttribute('aria-current');
+ });
+ const activeTop=$(spend?'tab-daily':`tab-${t}`);
+ if(window.matchMedia('(max-width:760px)').matches&&activeTop?.scrollIntoView)requestAnimationFrame(()=>activeTop.scrollIntoView({block:'nearest',inline:'center'}));
+ requestAnimationFrame(syncActivePageSignalEffects);
+ const activeView=$(spend?'view-daily':`view-${t}`);
+ requestAnimationFrame(()=>playRouteMotion(activeView));
+}
+function openTopLevelRoute(route){
+ window.scrollTo(0,0);
+ if(routedSessionId()&&history.pushState){history.pushState(null,'',`/#${route}`);applyHashRoute();return;}
+ setHashRoute(route);
+}
+$('tab-session').onclick=()=>{window.scrollTo(0,0);openCurrentSessions();};
+$('tab-models').onclick=()=>openTopLevelRoute('models');
+$('tab-subagents').onclick=()=>openTopLevelRoute('subagents');
+$('tab-daily').onclick=()=>openTopLevelRoute('spend');
+$('tab-capabilities').onclick=()=>openTopLevelRoute('capabilities');
+$('tab-efficiency').onclick=()=>openTopLevelRoute('efficiency');
+$('tab-work').onclick=()=>openTopLevelRoute('work');
+$('tab-git').onclick=()=>openTopLevelRoute('git');
+$('tab-read').onclick=()=>window.open(TOKENOMICS_SEARCH_URL,'_blank','noopener');
+$('tab-learn').onclick=()=>openTopLevelRoute('learn');
+$('tab-settings').onclick=()=>openTopLevelRoute('settings');
+$('session-back').onclick=openSessionBack;
+$('session-scope-tabs').onclick=event=>{
+ const button=event.target.closest('[data-session-scope]');
+ if(button)openSessionScope(button.dataset.sessionScope);
+};
+$('session-scope-tabs').onkeydown=event=>{
+ if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;
+ event.preventDefault();
+ const buttons=[...$('session-scope-tabs').querySelectorAll('[data-session-scope]')];
+ const index=buttons.indexOf(event.target.closest('[data-session-scope]'));
+ if(index<0)return;
+ const next=event.key==='Home'?0:event.key==='End'?buttons.length-1:(index+(event.key==='ArrowRight'?1:-1)+buttons.length)%buttons.length;
+ buttons[next].focus();
+ openSessionScope(buttons[next].dataset.sessionScope);
+};
+$('view-settings').onclick=event=>{
+ const targetButton=event.target.closest('[data-settings-target]');
+ if(!targetButton)return;
+ if(targetButton.dataset.settingsTarget==='update-settings'){setHashRoute('settings-updates');return;}
+ if(targetButton.dataset.settingsTarget==='work-insights-settings'){setHashRoute('settings-work-insights');return;}
+ if(targetButton.dataset.settingsTarget==='appearance-settings'){setHashRoute('settings-appearance');return;}
+ $(targetButton.dataset.settingsTarget)?.scrollIntoView({behavior:'smooth',block:'start'});
+};
+
+showCurrentPanel(currentPanel);
+
diff --git a/dashboard/js/work-insights.js b/dashboard/js/work-insights.js
new file mode 100644
index 00000000..1046e78c
--- /dev/null
+++ b/dashboard/js/work-insights.js
@@ -0,0 +1,407 @@
+function workFlagReason(cell){
+ return {possible_overspend:'premium model on routine work',possible_false_economy:'light model on complex work',possible_overthinking:'high effort on routine work'}[cell?.flag]||'worth reviewing';
+}
+function workSuggestion(item){
+ const work=WORK_TYPE_LABELS[item.work_type]||item.work_type||'';
+ switch(item.kind){
+  case 'premium_routine':{
+   const from=(item.from_models||[]).map(entry=>entry.model).join(', ');
+   const to=(item.to_models||[]).map(entry=>`${entry.model} in ${entry.runtime}`).join(' or ');
+   return{title:to?`Try ${to} for routine work`:'Use a cheaper model for routine work',detail:`${item.requests.toLocaleString()} routine request${item.requests===1?'':'s'} ran on your most expensive models${from?` (${from})`:''}.${to?` ${item.to_models.length===1?'That model is':'Those are'} your most-used mid-priced model${item.to_models.length===1?'':'s'} in the same app.`:''}`,drill:{complexity:item.complexity,tier:item.tier}};
+  }
+  case 'family_upgrade':return{title:`Use ${item.to_model} instead of ${item.model}`,detail:`A newer version in ${item.runtime}: ${Math.round(100*(1-item.to_price/item.from_price))}% cheaper per token. It resolved ${workPercent(item.to_rate)} of your tasks, vs ${workPercent(item.from_rate)} on ${item.model}.`,drill:{model:item.model,model_runtime:item.runtime}};
+  case 'effort_routine':return{title:`Lower reasoning effort on routine work`,detail:`${item.requests.toLocaleString()} routine request${item.requests===1?'':'s'} used ${item.effort} effort.`,drill:{complexity:item.complexity,effort:item.effort}};
+  case 'light_complex':return{title:'Use a stronger model for complex work',detail:`Complex work on light models got pushback on ${workPercent(item.rework?.rate)} of follow-ups.`,drill:{complexity:item.complexity,tier:item.tier}};
+  case 'switch_model':{
+   const level={routine:'routine',everyday:'everyday',complex:'complex'}[item.complexity]||'',app=item.to_runtime&&item.to_runtime!==item.runtime?` in ${item.to_runtime}`:'';
+   return{title:`Try ${item.to_model}${app} for ${level} ${item.work_type==='other'?'non-software requests':work.toLowerCase()}`,detail:`On ${level} requests: ${workPercent(item.to_rate)} resolved at ${money(item.to_cost)} per resolved task, vs ${workPercent(item.from_rate)} at ${money(item.from_cost)} on ${item.model} (${item.runtime})${item.to_pushback!=null&&item.from_pushback!=null?`; pushback ${workPercent(item.to_pushback)} vs ${workPercent(item.from_pushback)}`:''}.${item.to_untested_harder?` Keep ${item.model} for harder work: ${item.to_model} hasn’t been used on it yet.`:''}`,drill:{work_type:item.work_type,complexity:item.complexity,model:item.model,model_runtime:item.runtime}};
+  }
+  case 'long_threads':return{title:'Start a fresh session sooner',detail:`Sessions with ${item.threshold_turns}+ requests cost ${item.ratio.toFixed(1)}× more per request than short ones, because each request re-sends the growing context.`,drill:{tag:'long_thread'}};
+  default:return{title:item.kind,detail:'',drill:null};
+ }
+}
+function workSuggestionBasis(item){
+ const [count,unit]=item.requests!=null?[item.requests,'request']:item.tasks!=null?[item.tasks,'task']:[item.sessions||0,'session'];
+ return `${count.toLocaleString()} ${unit}${count===1?'':'s'}`;
+}
+const WORK_MODEL_SUGGESTIONS=['family_upgrade','switch_model','premium_routine','light_complex'];
+function workDollars(value){return value>0&&value<1?money(value):`$${Math.round(value||0).toLocaleString()}`;}
+function workModelSwap(item){
+ const short=name=>String(name||'').replace(/^claude-/,'');
+ switch(item.kind){
+  case 'family_upgrade':return{from:short(item.model),to:short(item.to_model),note:`resolves ${item.to_rate>=item.from_rate?'as often':'about as often'} · ${workPercent(item.from_rate)} → ${workPercent(item.to_rate)}`};
+  case 'switch_model':return{from:short(item.model),to:short(item.to_model),note:`${item.complexity?`${item.complexity} work · `:''}${workPercent(item.from_rate)} → ${workPercent(item.to_rate)}`};
+  case 'premium_routine':return{from:'premium models',to:short(item.to_models?.[0]?.model)||'mid-priced',note:`routine work · ${(item.requests||0).toLocaleString()} requests`};
+  case 'light_complex':return{from:'light models',to:'a stronger model',note:`complex work · ${workPercent(item.rework?.rate)} pushback`};
+  default:return{from:'',to:'',note:''};
+ }
+}
+function workSparkline(points){
+ const usable=points.filter(point=>point.rate!=null);
+ if(usable.length<2)return '';
+ const W=300,H=44,max=Math.max(...usable.map(point=>point.rate),0.01),x=index=>(W*index/(usable.length-1)).toFixed(1),y=rate=>(H-3-(H-8)*rate/max).toFixed(1);
+ const line=usable.map((point,index)=>`${x(index)},${y(point.rate)}`).join(' '),last=usable[usable.length-1];
+ return `<svg class=workSuggestSpark viewBox="0 0 ${W} ${H+10}" role=img aria-label="Pushback rate by week"><polyline fill=none stroke="var(--warn)" stroke-width=2 stroke-linejoin=round points="${line}"/><circle cx="${x(usable.length-1)}" cy="${y(last.rate)}" r=3.5 fill="var(--warn)"/><text x=0 y="${H+9}" fill="var(--faint)" font-size=9>${esc(usable[0].label)}</text><text x="${W-2}" y="${H+9}" fill="var(--faint)" font-size=9 text-anchor=end>${esc(last.label)}</text></svg>`;
+}
+// Effort by model: one model at a time, because a level such as "high" means different things on different models.
+let workEffortModel=localStorage.getItem('tm_work_effort_model')||'',workEffortGridHtml='';
+const WORK_EFFORT_ROWS={routine:'Routine',everyday:'Everyday',complex:'Complex+'};
+function workEffortRate(rework){return rework?`${Math.round(rework.rate*100)}%`:'';}
+function workEffortVerdict(verdict){
+ const row=esc(WORK_EFFORT_ROWS[verdict.complexity]||verdict.complexity),evidence=`${workEffortRate({rate:verdict.lower_rate})} vs ${workEffortRate({rate:verdict.higher_rate})} pushback`;
+ const title=esc(`From ${verdict.lower_samples} and ${verdict.higher_samples} labeled follow-ups, 99% confidence`);
+ if(verdict.kind==='lower')return `<li data-kind=lower title="${title}"><b>${row}: ${esc(verdict.higher)} → ${esc(verdict.lower)} looks safe</b> · ${evidence} · saves ${money(verdict.saving)}</li>`;
+ return `<li data-kind=raise title="${title}"><b>${row}: raise ${esc(verdict.lower)} → ${esc(verdict.higher)}</b> · ${evidence}</li>`;
+}
+function renderWorkEffortModels(insights){
+ const data=insights?.effort_by_model||{},models=data.models||[],box=$('w-effort-models');
+ box.hidden=!insights||!models.length; // only models with labeled requests
+ if(!models.length)return;
+ // JSON rather than a NUL-joined key: the HTML parser rewrites NUL inside attributes.
+ const key=model=>JSON.stringify([model.model,model.runtime]);
+ const chosen=models.find(model=>key(model)===workEffortModel)||models[0];
+ $('w-effort-model').innerHTML=models.map(model=>`<option value="${esc(key(model))}"${model===chosen?' selected':''}>${esc(model.model)} · ${esc(model.runtime)}</option>`).join('');
+ const efforts=chosen.efforts||[],grid=$('w-effort-grid');
+ // One number per cell (pushback); cost per request sits once per effort column.
+ const columnCost=effort=>{let spend=0,requests=0;(chosen.rows||[]).forEach(row=>{const cell=(row.cells||[]).find(item=>item.effort===effort);if(cell&&cell.cost_per_request!=null){spend+=cell.spend;requests+=cell.requests;}});return requests?spend/requests:null;};
+ grid.style.gridTemplateColumns=`110px repeat(${efforts.length},minmax(72px,1fr))`;
+ const head=`<div role=row style="display:contents"><div class=workSizingHead role=columnheader></div>${efforts.map(effort=>{const cost=columnCost(effort);const tip=esc('No effort recorded: the app\'s default level');return `<div class="workSizingHead workEffortHead${effort==='default'?' fieldtip':''}" role=columnheader${effort==='default'?` tabindex=0 aria-description="${tip}" data-tip="${tip}"`:''}>${esc(effort)}${cost!=null?`<small>${money(cost)}/req</small>`:''}</div>`;}).join('')}</div>`;
+ const html=head+(chosen.rows||[]).map(row=>`<div role=row style="display:contents"><div class=workSizingRowHead role=rowheader>${esc(WORK_EFFORT_ROWS[row.complexity]||row.complexity)}</div>${(row.cells||[]).map(cell=>{
+  if(!cell.requests)return '<div class=workEffortCell data-empty role=cell aria-label="No requests">·</div>';
+  const cost=cell.cost_per_request!=null?`${money(cell.cost_per_request)}/request`:'cost unavailable';
+  const label=`${WORK_EFFORT_ROWS[row.complexity]||row.complexity} at ${cell.effort}: `;
+  if(!cell.rework||cell.rework.few_samples){const detail=`${label}too few labeled follow-ups (${cell.rework?.samples||0}) · ${f(cell.requests)} requests · ${cost}`;return `<div class=workEffortCell data-few role=cell tabindex=0 data-cell="${esc(row.complexity+':'+cell.effort)}" title="${esc(detail)}" aria-label="${esc(detail)}" data-detail="${esc(detail)}">·</div>`;}
+  const heat=Math.min(.32,cell.rework.rate*.8).toFixed(3);
+  const detail=`${label}${workEffortRate(cell.rework)} pushback · ${f(cell.rework.samples)} labeled follow-ups · ${f(cell.requests)} requests · ${cost}`;
+  return `<div class=workEffortCell role=cell tabindex=0 data-cell="${esc(row.complexity+':'+cell.effort)}" style="--heat:${heat}" title="${esc(detail)}" aria-label="${esc(detail)}" data-detail="${esc(detail)}">${workEffortRate(cell.rework)}</div>`;
+ }).join('')}</div>`).join('');
+ // The Work poll re-renders every few seconds: leave unchanged cells alone, and keep focus on the same cell when they do change.
+ if(html!==workEffortGridHtml){
+  const focused=grid.contains?.(document.activeElement)?document.activeElement.dataset.cell:'';
+  grid.innerHTML=workEffortGridHtml=html;
+  const again=focused&&[...grid.querySelectorAll('[data-cell]')].find(node=>node.dataset.cell===focused);
+  if(again){again.focus();$('w-effort-detail').textContent=again.dataset.detail;}
+  else $('w-effort-detail').textContent='';
+ }
+ const verdicts=chosen.verdicts||[];
+ $('w-effort-verdicts').innerHTML=verdicts.map(workEffortVerdict).join('');
+ $('w-effort-note').textContent=`Faint dots: too few follow-ups${data.unrecorded_spend>0?` · ${money(data.unrecorded_spend)} without a recorded effort left out`:''}`;
+}
+// A cell's evidence for keyboard, touch, and pointer alike: focusing, tapping, or hovering shows it under the table.
+['focusin','mouseover'].forEach(type=>$('w-effort-grid').addEventListener(type,event=>{
+ const cell=event.target.closest('[data-detail]');
+ if(cell)$('w-effort-detail').textContent=cell.dataset.detail;
+}));
+$('w-effort-model').addEventListener('change',event=>{
+ workEffortModel=event.target.value;localStorage.setItem('tm_work_effort_model',workEffortModel);
+ $('w-effort-detail').textContent='';
+ if(WORK?.insights)renderWorkEffortModels(WORK.insights);
+});
+function renderWorkSuggestCards(insights){
+ const rows=insights?.recommendations||[],box=$('w-suggest-cards');
+ const drill=item=>{const tip=workSuggestion(item);return tip.drill?` data-drill="${esc(JSON.stringify(tip.drill))}" data-drill-label="${esc(tip.title)}"`:'';};
+ // Models
+ const models=rows.filter(item=>WORK_MODEL_SUGGESTIONS.includes(item.kind)).sort((a,b)=>(b.saving||0)-(a.saving||0));
+ const best=models.find(item=>(item.saving||0)>0);
+ const modelRows=models.slice(0,3).map(item=>{const swap=workModelSwap(item);return `<button type=button class=workDrillBtn${drill(item)} title="${esc(swap.note)}"><span class=workSwap>${esc(swap.from)}<b>→</b>${esc(swap.to)}</span><span class=workSwapSave>${item.saving>0?workDollars(item.saving):'--'}</span></button>`;}).join('');
+ const modelCard=`<div class=workSuggestCard><div class=workSuggestEyebrow><i style="background:var(--good)"></i>Model suggestions</div>${models.length?`<div class=workSuggestHero>${best?`${workDollars(best.saving)}<small title="Savings can overlap">biggest saving</small>`:`${models.length}<small>model suggestion${models.length===1?'':'s'}</small>`}</div><div class=workSuggestRows>${modelRows}</div><div class=workSuggestFoot><span>${models.length>3?`+${models.length-3} more`:''}</span><button type=button data-open-sizing-tables>See all</button></div>`:'<div class=workSuggestEmpty>No model changes suggested for this period.</div>'}</div>`;
+ // Reasoning
+ // Several high levels can be flagged at once (for example xhigh and max): count them together.
+ const efforts=rows.filter(item=>item.kind==='effort_routine').sort((a,b)=>(b.spend||0)-(a.spend||0));
+ // The drill filter takes a comma-separated effort list; the card shows the levels joined with "or".
+ const effort=efforts.length?{...efforts[0],requests:efforts.reduce((sum,item)=>sum+(item.requests||0),0),spend:efforts.reduce((sum,item)=>sum+(item.spend||0),0),effort:efforts.map(item=>item.effort).join(','),label:efforts.map(item=>item.effort).join(' or ')}:null;
+ const cells=(insights?.right_sizing?.effort?.cells||[]).filter(cell=>cell.complexity==='routine'&&cell.spend>0).sort((a,b)=>b.spend-a.spend);
+ const routineSpend=cells.reduce((sum,cell)=>sum+cell.spend,0),shades=['var(--reason)','var(--w-routine-2)','var(--w-routine-3)','var(--w-routine-4)'];
+ const shown=cells.slice(0,3),rest=routineSpend-shown.reduce((sum,cell)=>sum+cell.spend,0);
+ const parts=[...shown.map(cell=>({label:cell.effort||'unknown',spend:cell.spend})),...(rest>0?[{label:'other',spend:rest}]:[])];
+ const bar=routineSpend?`<div class=workSuggestBar role=img aria-label="Routine spend by reasoning effort">${parts.map((part,index)=>`<span style="flex:${part.spend.toFixed(4)};background:${shades[index]}"></span>`).join('')}</div><div class=workSuggestLegend>${parts.map((part,index)=>`<span><i style="background:${shades[index]}"></i>${esc(part.label)}</span>`).join('')}</div>`:'';
+ const effortCard=`<div class=workSuggestCard><div class=workSuggestEyebrow><i style="background:var(--reason)"></i>Reasoning suggestions</div>${effort?`<div class=workSuggestHero>${(effort.requests||0).toLocaleString()}<small>routine request${effort.requests===1?'':'s'} ran at ${esc(effort.label)} effort</small></div>`:`<div class=workSuggestEmpty>No reasoning changes suggested for this period.</div>`}${bar}<div class=workSuggestFoot><span></span>${effort&&drill(effort)?`<button type=button${drill(effort)}>Open requests</button>`:''}</div></div>`;
+ // Pushback
+ const rework=insights?.rework||{},overall=rework.overall||{};
+ const weekly=(rework.weekly||[]).filter(point=>point.samples>=20).map(point=>({rate:point.rate,label:workMonthName(point.week,{year:false})}));
+ // Least and most need 50+ judged follow-ups each and a gap bigger than noise (two-proportion check, about 95%).
+ const ranked=(rework.models||[]).filter(model=>model.samples>=50&&model.rate!=null&&model.model&&model.model!=='unknown-model').sort((a,b)=>a.rate-b.rate);
+ const lo=ranked[0],hi=ranked[ranked.length-1],pooled=ranked.length>1?(lo.rate*lo.samples+hi.rate*hi.samples)/(lo.samples+hi.samples):0;
+ const distinct=ranked.length>1&&hi.rate-lo.rate>1.96*Math.sqrt(pooled*(1-pooled)*(1/lo.samples+1/hi.samples));
+ const chip=(label,model)=>model?`<div><span>${label}</span><b title="${esc(model.model)} · ${esc(model.runtime)}">${esc(model.model.replace(/^claude-/,''))} <s>${workPercent(model.rate)}</s></b></div>`:'';
+ const pushCard=`<div class=workSuggestCard><div class=workSuggestEyebrow><i style="background:var(--warn)"></i>Pushback</div>${overall.samples?`<div class=workSuggestHero>${workPercent(overall.rate)}<small>of ${overall.samples.toLocaleString()} follow-ups pushed back${overall.few_samples?' · few samples':''}</small></div>${workSparkline(weekly)}${distinct?`<div class=workSuggestChips>${chip('Least pushback',lo)}${chip('Most pushback',hi)}</div>`:''}<div class=workSuggestFoot><span></span><button type=button data-scroll-work=w-module-rework>Pushback over time</button></div>`:'<div class=workSuggestEmpty>No labeled follow-ups in this period yet.</div>'}</div>`;
+ box.innerHTML=modelCard+effortCard+pushCard;
+}
+function renderWorkOpportunities(insights){
+ const rows=insights?.recommendations||[],table=$('w-opportunities');
+ renderWorkSuggestCards(insights);
+ if(!rows.length){table.innerHTML='';return;}
+ table.innerHTML=`<thead><tr><th>Suggestion</th><th>Based on</th><th>Spend</th><th>Possible saving</th></tr></thead><tbody>${rows.map(item=>{
+  const tip=workSuggestion(item);
+  const label=tip.drill?`<button type=button class=workDrillBtn data-drill="${esc(JSON.stringify(tip.drill))}" data-drill-label="${esc(tip.title)}"><span class=workIssueKind aria-hidden=true>▲</span><span class=workSuggestion><b>${esc(tip.title)}</b><small>${esc(tip.detail)}</small></span></button>`:esc(tip.title);
+  return `<tr><td>${label}</td><td><span class=mono>${esc(workSuggestionBasis(item))}</span></td><td><span class=mono>${money(item.spend)}</span></td><td><span class=mono>${item.saving!=null&&item.saving>0?`<span style="color:var(--good)">${money(item.saving)}</span> est`:'<span class=workMuted>--</span>'}</span></td></tr>`;
+ }).join('')}</tbody>`;
+}
+function renderWorkFilters(insights){
+ const filters=insights?.filters||{};
+ $('w-runtime').innerHTML='<option value="">All apps</option>'+(filters.runtimes||[]).map(value=>`<option value="${esc(value)}"${value===workRuntime?' selected':''}>${esc(value)}</option>`).join('');
+ const projects=filters.projects||[];
+ if(workProject&&!projects.includes(workProject))projects.unshift(workProject);
+ $('w-project').innerHTML='<option value="">All projects</option>'+projects.map(value=>`<option value="${esc(value)}"${value===workProject?' selected':''}>${esc(deliveryProjectName(value))}</option>`).join('');
+}
+const WORK_OUTCOME_LABELS={accepted:'Accepted without pushback',recovered:'Recovered after pushback',ended_on_pushback:'Ended on pushback',unclear:'Unclear',single_shot:'Single request',pending:'Not labeled yet'};
+const WORK_OUTCOME_COLORS={accepted:'var(--w-accepted)',recovered:'var(--w-recovered)',ended_on_pushback:'var(--w-ended)',unclear:'var(--w-unclear)',single_shot:'var(--w-single)',pending:'var(--w-pending)'};
+function renderWorkFit(insights){
+ const fit=insights?.model_fit||{},models=fit.models||[],table=$('w-fit-table');
+ if(!models.length||!(fit.work_types||[]).length){table.innerHTML='<tbody><tr><td><div class=workEmpty>Waiting for labeled sessions.</div></td></tr></tbody>';return;}
+ const cell=(work,model)=>(fit.cells||[]).find(item=>item.work_type===work&&item.model===model.model&&item.runtime===model.runtime);
+ table.innerHTML=`<thead><tr><th>Work type</th>${models.map(model=>`<th class=num title="${esc(model.runtime)} · ${model.tasks} tasks">${esc(model.model)}<br><small class=workMuted>${esc(model.runtime)}</small></th>`).join('')}</tr></thead><tbody>${fit.work_types.map(work=>`<tr><td>${esc(WORK_TYPE_LABELS[work]||work)}</td>${models.map(model=>{const item=cell(work,model);if(!item||!item.tasks)return '<td class="num workMuted">--</td>';return `<td class="num mono workFitCell"><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify({work_type:work,model:model.model,model_runtime:model.runtime}))}" data-drill-label="${esc(`${WORK_TYPE_LABELS[work]||work} · ${model.model}`)}">${workRateText(item.rework)}${item.best?'<span class=workFitBest>Best</span>':''}<small>${item.tasks} · ${money(item.cost_per_task)}/task</small></button></td>`;}).join('')}</tr>`).join('')}</tbody>`;
+}
+$('view-work').addEventListener('click',event=>{
+ const tables=event.target.closest('[data-open-sizing-tables]');
+ if(tables){const details=$('w-sizing-tables');details.open=true;details.scrollIntoView({behavior:'smooth',block:'start'});return;}
+ const scroll=event.target.closest('[data-scroll-work]');
+ if(scroll){$(scroll.dataset.scrollWork)?.scrollIntoView({behavior:'smooth',block:'start'});return;}
+ const single=event.target.closest('[data-open-work-session]');
+ if(single){selectSession(single.dataset.openWorkSession,{returnScope:'all'});return;}
+ const target=event.target.closest('[data-drill]');if(!target)return;
+ let filters={};try{filters=JSON.parse(target.dataset.drill);}catch(error){return;}
+ openWorkSessions(filters,target.dataset.drillLabel);
+});
+let workResizeTimer=0;
+window.addEventListener('resize',()=>{clearTimeout(workResizeTimer);workResizeTimer=setTimeout(()=>{if(WORK&&$('view-work').classList.contains('on')){renderWorkRework(WORK.insights);renderWorkAgentTrend(WORK.insights);}},150);});
+function workHours(seconds){const minutes=Math.round((seconds||0)/60);return minutes>=90?`${(minutes/60).toFixed(minutes%60?1:0)} h`:`${minutes} min`;}
+const WORK_BANDS={night:['Night','midnight–6 am'],morning:['Morning','6 am–noon'],afternoon:['Afternoon','noon–6 pm'],evening:['Evening','6 pm–midnight']};
+const WORK_TAG_INFO={
+ marathon:['Marathon',t=>`More than ${workHours(t.marathon_s)} of active time`,'var(--w5)'],
+ big_spend:['Big spender',t=>`Top 10% by cost, over ${money(t.big_spend)}`,'var(--w2)'],
+ team:['Subagent team',t=>`${t.team_children} or more subagent runs`,'var(--w7)'],
+ overkill:['Overkill',()=>'Routine work on a premium model or high effort','var(--warn)'],
+ underpowered:['Underpowered',()=>'Complex work on a light model that got pushback','var(--warn)'],
+ rescued:['Rescued',()=>'Back on track after a pushback','var(--w-recovered)'],
+ stuck:['Ended on pushback',()=>'The last follow-up was a pushback','var(--bad)'],
+ one_shot:['One-shot',()=>'Done in a single request','var(--good)'],
+ long_thread:['Long thread',()=>'30 or more requests in one session','var(--w1)'],
+};
+function renderWorkTagCards(insights){
+ const tags=insights?.tags||{},items=tags.items||[],thresholds=tags.thresholds||{},host=$('w-tags');
+ const sessions=insights?.coverage?.sessions||0;
+ $('w-tags-note').textContent=items.length?`${sessions.toLocaleString()} sessions`:'';
+ host.innerHTML=items.length?items.map(item=>{
+  const [name,describe,tone]=WORK_TAG_INFO[item.tag]||[item.tag,()=>'','var(--w-unclear)'];
+  const stats=[money(item.spend),item.share!=null?`${workPercent(item.share)} of spend`:'',item.resolved_rate!=null&&item.judged_sessions>=5?`${workPercent(item.resolved_rate)} resolved`:''].filter(Boolean).join(' · ');
+  return `<button type=button class=workTagTile style="--tone:${tone}" data-drill="${esc(JSON.stringify({tag:item.tag}))}" data-drill-label="${esc(name)}"><span class=workTagName><i aria-hidden=true></i>${esc(name)}</span><strong class=num>${item.sessions.toLocaleString()}</strong><span class=workTagStats>${esc(stats)}</span><small>${esc(describe(thresholds))}</small></button>`;
+ }).join(''):'<div class=workEmpty>No sessions in this period yet.</div>';
+}
+function renderWorkRhythm(insights){
+ const rhythm=insights?.rhythm||{},cells=rhythm.cells||[],heat=$('w-heat'),bands=rhythm.bands||[];
+ const days=['Mon','Tue','Wed','Thu','Fri','Sat','Sun'],max=Math.max(1,...cells.map(cell=>cell.sessions));
+ const lookup=new Map(cells.map(cell=>[`${cell.weekday}:${cell.hour}`,cell]));
+ const busiest=cells.length?cells.reduce((a,b)=>b.sessions>a.sessions?b:a):null;
+ const hourText=hour=>new Date(2000,0,1,hour).toLocaleTimeString([],{hour:'numeric'});
+ $('w-rhythm-note').textContent=busiest?`${(rhythm.sessions||0).toLocaleString()} sessions · most start on ${days[busiest.weekday]} around ${new Date(2000,0,1,busiest.hour).toLocaleTimeString([],{hour:'numeric',minute:'2-digit'})}`:'';
+ heat.innerHTML=cells.length?days.map((day,weekday)=>`<span>${day}</span>${Array.from({length:24},(_,hour)=>{const cell=lookup.get(`${weekday}:${hour}`);return cell?`<i data-v style="--v:${(0.2+0.8*cell.sessions/max).toFixed(2)}" title="${esc(`${day} ${hourText(hour)} · ${cell.sessions} session${cell.sessions===1?'':'s'} · ${money(cell.spend)}`)}"></i>`:'<i></i>';}).join('')}`).join('')+`<span></span>${[0,6,12,18].map(hour=>`<span class=h>${esc(hourText(hour))}</span>`).join('')}`:'<div class=workEmpty style="grid-column:1/-1">No session start times in this period.</div>';
+ const total=bands.reduce((sum,band)=>sum+band.sessions,0),maxRate=Math.max(.05,...bands.map(band=>band.pushback?.rate||0));
+ $('w-bands').innerHTML=total?bands.filter(band=>band.sessions).map(band=>{const [name,range]=WORK_BANDS[band.band]||[band.band,''];const few=!band.pushback||band.pushback.few_samples;return `<div class=workBand data-few="${few}"><span>${esc(name)}<small>${esc(range)}</small></span><span class=workBarTrack><i style="width:${band.pushback?(100*band.pushback.rate/maxRate).toFixed(1):0}%"></i></span><b class=num>${band.pushback?workPercent(band.pushback.rate):'--'}</b><small>${band.sessions.toLocaleString()} session${band.sessions===1?'':'s'} · ${money(band.spend)}${few&&band.pushback?' · few follow-ups':''}</small></div>`;}).join(''):'';
+ const solid=bands.filter(band=>band.pushback&&!band.pushback.few_samples);
+ let note='';
+ if(solid.length>=2){
+  const high=solid.reduce((a,b)=>b.pushback.rate>a.pushback.rate?b:a),low=solid.reduce((a,b)=>b.pushback.rate<a.pushback.rate?b:a);
+  note=low.pushback.rate>0&&high.pushback.rate/low.pushback.rate>=1.3?`Pushback is ${(high.pushback.rate/low.pushback.rate).toFixed(1)}× higher in the ${WORK_BANDS[high.band][0].toLowerCase()} than in the ${WORK_BANDS[low.band][0].toLowerCase()}.`:'Pushback is about the same at every time of day.';
+ }else if(total)note='Needs at least 20 labeled follow-ups in two parts of the day to compare.';
+ $('w-band-note').textContent=note;
+}
+function renderWork(payload){
+ WORK=payload;renderWorkStatus(payload);
+ const insights=payload?.insights,areas=(payload?.settings?.areas||[]).map(area=>area.name);
+ renderWorkFilters(insights);renderWorkBreakdown(insights);renderWorkTagCards(insights);renderWorkRhythm(insights);
+ renderWorkRework(insights);renderWorkAgentTrend(insights);
+ renderWorkScorecard(insights);renderWorkEffortModels(insights);renderWorkFit(insights);renderWorkMix(insights);renderWorkOpportunities(insights);renderWorkSizing(insights);renderWorkEffort(insights);
+}
+async function loadWork(){
+ const request=++workRequest,query=new URLSearchParams({months:workMonths});
+ if(workRuntime)query.set('runtime',workRuntime);if(workProject)query.set('project',workProject);
+ try{
+  const response=await fetch(`/work?${query}`,{cache:'no-store'});
+  const payload=await response.json();if(request!==workRequest)return;
+  if(!response.ok||!payload.ok){
+   if(response.status===404&&(workProject||workRuntime)){workProject='';workRuntime='';loadWork();return;}
+   throw new Error(payload.error||'Work insights unavailable');
+  }
+  workLastLoadedAt=Date.now();renderWork(payload);
+ }catch(error){
+  if(request!==workRequest)return;
+  $('w-state').dataset.state='storage_error';$('w-state').textContent='Error';
+  $('w-status-title').textContent='Work insights are unavailable';$('w-status-detail').textContent='Token Meter will try again shortly.';
+ }
+}
+async function postWorkAction(path,payload){
+ const token=agentActionToken();
+ if(!token)throw new Error('Controls are not ready yet. Wait a moment and try again.');
+ const response=await fetch(path,{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify(payload)});
+ let result={};try{result=await response.json();}catch(error){}
+ if(!response.ok||!result.ok)throw new Error(result.error||'Token Meter could not save that change.');
+ return result;
+}
+$('w-rework-model').addEventListener('change',()=>{if(WORK)renderWorkRework(WORK.insights);});
+$('w-agent-model').addEventListener('change',()=>{if(WORK)renderWorkAgentTrend(WORK.insights);});
+$('w-months').addEventListener('change',event=>{workMonths=event.target.value;loadWork();});
+$('w-runtime').addEventListener('change',event=>{workRuntime=event.target.value;loadWork();});
+$('w-project').addEventListener('change',event=>{workProject=event.target.value;loadWork();});
+$('w-pause').addEventListener('change',async event=>{
+ const duration=event.target.value;if(!duration)return;
+ try{const result=await postWorkAction('/work-insights/pause',{duration});if(WORK){WORK.status=result.status;WORK.settings=result.work_insights;renderWorkStatus(WORK);}}
+ catch(error){$('w-status-detail').textContent=error.message;}
+ finally{event.target.value='';}
+});
+$('w-resume').addEventListener('click',async()=>{
+ try{const result=await postWorkAction('/work-insights/pause',{duration:'resume'});if(WORK){WORK.status=result.status;WORK.settings=result.work_insights;renderWorkStatus(WORK);}loadWork();}
+ catch(error){$('w-status-detail').textContent=error.message;}
+});
+$('w-open-settings').addEventListener('click',()=>setHashRoute('settings-work-insights'));
+$('w-turn-on').addEventListener('click',()=>setHashRoute('settings-work-insights'));
+$('w-setup-retry').addEventListener('click',async()=>{
+ try{const result=await postWorkAction('/work-insights/setup',{start:true});if(WORK){WORK.status=result.status;renderWorkStatus(WORK);}}
+ catch(error){$('w-status-detail').textContent=error.message;}
+});
+function renderWorkSettings(payload,{force=false}={}){
+ if(!payload)return;
+ applyWorkSupport(payload.settings?.supported);  // known here long before the first full state on a cold start
+ WORK_SETTINGS=payload;
+ const settings=payload.settings||{},status=payload.status||{};
+ const badge=status.reason==='delete_pending'?'Delete pending':({disabled:'Off',setup_needed:'Setup needed',running:'Running',idle:'Up to date',paused:'Paused',throttled:'Waiting',backoff:'Retrying',storage_error:'Error'}[settings.enabled?status.state:'disabled']||'On');
+ $('work-settings-badge').textContent=badge;
+ if(!force&&settingsInteractionActive()){updateWorkSaveState();return;}
+ $('work-enable-cta').hidden=Boolean(settings.enabled);
+ $('work-enabled').checked=Boolean(settings.enabled);$('work-battery').checked=settings.pause_on_battery!==false;$('work-live-notify').checked=settings.live_notifications!==false;$('work-live-notify').disabled=!settings.enabled;$('work-live-notify').closest('label').title=settings.enabled?'':'Turn on labeling to get live-suggestion notifications.';
+ $('work-model').value=settings.model||'';$('work-url').value=settings.ollama_url||'';
+ $('work-rate').value=String(settings.rate_per_minute||'auto');$('work-backfill').value=String(settings.backfill_days??90);
+ workAreasDraft=(settings.areas||[]).map(area=>({...area}));renderWorkAreas();
+}
+function workSettingsDraft(){
+ return {model:$('work-model').value.trim(),ollama_url:$('work-url').value.trim(),areas:(workAreasDraft||[]).map(area=>({name:area.name.split(/\s+/).join(' ').trim(),description:area.description.split(/\s+/).join(' ').trim()}))};
+}
+// Save covers the model, address, and areas; it is live only when one of them differs from what is saved.
+function workSettingsDirty(){
+ const saved=WORK_SETTINGS?.settings||{},draft=workSettingsDraft();
+ const savedAreas=(saved.areas||[]).map(area=>({name:area.name,description:area.description}));
+ return draft.model!==(saved.model||'')||draft.ollama_url!==(saved.ollama_url||'')||JSON.stringify(draft.areas)!==JSON.stringify(savedAreas);
+}
+const WORK_UNSAVED_NOTE=' Other changes are not saved yet.';
+function updateWorkSaveState(){
+ const dirty=Boolean(WORK_SETTINGS)&&workSettingsDirty(),line=$('work-settings-status');
+ $('work-save').disabled=!dirty;
+ if(dirty&&(line.textContent===''||line.textContent==='Saved'))line.textContent='Unsaved changes';
+ else if(!dirty&&(line.textContent==='Unsaved changes'||line.textContent.endsWith(WORK_UNSAVED_NOTE)))line.textContent='';
+}
+function renderWorkAreas(){
+ const limits=WORK_SETTINGS?.settings?.limits||{min_areas:2,max_areas:8,name:40,description:200},areas=workAreasDraft||[];
+ $('work-areas').innerHTML=areas.map((area,index)=>`<div class=workAreaRow><i class=workSwatch style="--swatch:${index<8?`var(--w${index+1})`:'var(--w-unclear)'}"></i><input data-area-index=${index} data-area-field=name value="${esc(area.name)}" maxlength=${limits.name} aria-label="Area ${index+1} name"><input data-area-index=${index} data-area-field=description value="${esc(area.description)}" maxlength=${limits.description} aria-label="Area ${index+1} description"><button class="tbtn clearFilters" type=button data-area-remove=${index} ${areas.length<=limits.min_areas?'disabled':''} aria-label="Remove area ${index+1}">Remove</button></div>`).join('');
+ $('work-areas-count').textContent=`${areas.length} of ${limits.max_areas} · changing areas relabels them in the background`;
+ $('work-area-add').disabled=areas.length>=limits.max_areas;
+ updateWorkSaveState();
+}
+async function loadWorkSettings(){
+ try{const response=await fetch('/work-insights/status',{cache:'no-store'});const payload=await response.json();if(payload.ok)renderWorkSettings(payload);}catch(error){}
+}
+async function saveWorkSettings(payload,message){
+ // A toggle saves at once; keep unsaved model, address, and area edits that it does not include.
+ const kept=!('model' in payload)&&workSettingsDirty()?{draft:workSettingsDraft(),areas:'areas' in payload||payload.reset_areas?null:workAreasDraft}:null;
+ $('work-settings-status').textContent='Saving…';
+ try{
+  const result=await postWorkAction('/settings/work-insights',payload);
+  renderWorkSettings({settings:result.work_insights,status:result.status},{force:true});
+  if(kept){$('work-model').value=kept.draft.model;$('work-url').value=kept.draft.ollama_url;if(kept.areas)workAreasDraft=kept.areas;renderWorkAreas();}
+  const unsaved=kept&&workSettingsDirty();
+  $('work-settings-status').textContent=unsaved?`${message||'Saved.'}${WORK_UNSAVED_NOTE}`:message||'Saved';
+  workLastLoadedAt=0;
+ }catch(error){$('work-settings-status').textContent=error.message;}
+}
+$('work-areas').addEventListener('input',event=>{const input=event.target.closest('[data-area-index]');if(!input||!workAreasDraft)return;workAreasDraft[Number(input.dataset.areaIndex)][input.dataset.areaField]=input.value;updateWorkSaveState();});
+['work-model','work-url'].forEach(id=>$(id).addEventListener('input',updateWorkSaveState));
+$('work-areas').addEventListener('click',event=>{const button=event.target.closest('[data-area-remove]');if(!button||!workAreasDraft)return;workAreasDraft.splice(Number(button.dataset.areaRemove),1);renderWorkAreas();});
+$('work-area-add').addEventListener('click',()=>{if(!workAreasDraft)return;workAreasDraft.push({name:'',description:''});renderWorkAreas();$('work-areas').querySelector('.workAreaRow:last-child input')?.focus();});
+$('work-enable-button').addEventListener('click',()=>{const box=$('work-enabled');box.checked=true;box.dispatchEvent(new Event('change'));$('work-enable-cta').hidden=true;box.focus();});
+$('work-enabled').addEventListener('change',event=>saveWorkSettings({enabled:event.target.checked},event.target.checked?'On. Labeling starts in the background.':'Off. Labeling stopped.'));
+$('work-battery').addEventListener('change',event=>saveWorkSettings({pause_on_battery:event.target.checked}));
+$('work-live-notify').addEventListener('change',event=>saveWorkSettings({live_notifications:event.target.checked}));
+$('work-rate').addEventListener('change',event=>saveWorkSettings({rate_per_minute:event.target.value==='auto'?'auto':Number(event.target.value)}));
+$('work-backfill').addEventListener('change',event=>saveWorkSettings({backfill_days:Number(event.target.value)}));
+$('work-save').addEventListener('click',()=>{if(workSettingsDirty())saveWorkSettings(workSettingsDraft());});
+$('work-areas-reset').addEventListener('click',()=>saveWorkSettings({reset_areas:true},'Default areas restored.'));
+$('work-pause').addEventListener('change',async event=>{
+ const duration=event.target.value;if(!duration)return;
+ try{const result=await postWorkAction('/work-insights/pause',{duration});renderWorkSettings({settings:result.work_insights,status:result.status},{force:true});$('work-settings-status').textContent=duration==='resume'?'Resumed.':'Paused.';}
+ catch(error){$('work-settings-status').textContent=error.message;}
+ finally{event.target.value='';}
+});
+$('work-clear').addEventListener('click',async()=>{
+ if(!window.confirm('Delete all work labels? They are rebuilt in the background if work insights stay on.'))return;
+ try{await postWorkAction('/work-insights/clear',{confirm:true});$('work-settings-status').textContent='Labels deleted.';workLastLoadedAt=0;loadWorkSettings();}
+ catch(error){$('work-settings-status').textContent=error.message;}
+});
+async function applyWorkSessionFilter(params){
+ const query=new URLSearchParams();
+ ['months','runtime','project','month','start_month','area','work_type','complexity','tier','effort','outcome','model','model_runtime','tag'].forEach(key=>{if(params.get(key))query.set(key,params.get(key));});
+ query.set('ids','1');
+ const label=params.get('label')||'Work',request=++workFilterRequest;
+ if(history.replaceState)history.replaceState(null,'','/#sessions-all');
+ setSessionScope('all');showTab('session');showCurrentPanel('sessions');
+ workSessionFilter={label,keys:new Set(),loading:true};
+ renderCurrentSessions();if(LATEST)renderAllSessions(LATEST.xsession);
+ try{
+  const response=await fetch(`/work/sessions?${query}`,{cache:'no-store'}),payload=await response.json();
+  if(request!==workFilterRequest)return;
+  if(!response.ok||!payload.ok)throw new Error(payload.error||'Work filter unavailable');
+  workSessionFilter={label,keys:new Set(payload.keys.map(String)),total:payload.total,truncated:payload.truncated};
+ }catch(error){if(request!==workFilterRequest)return;workSessionFilter={label:`${label} (unavailable)`,keys:new Set(),failed:true};}
+ if(LATEST)renderAllSessions(LATEST.xsession);
+}
+async function loadDelivery(){
+ const request=++deliveryRequest,query=new URLSearchParams({range:deliveryRange});if(deliveryProject)query.set('project',deliveryProject);
+ try{
+  const response=await fetch(`/git-delivery?${query}`,{cache:'no-store'});if(!response.ok)throw new Error('Git data unavailable');
+  const payload=await response.json();if(request!==deliveryRequest)return;
+  deliveryLastLoadedAt=Date.now();renderDelivery(payload);
+  clearTimeout(deliveryRetryTimer);
+  if(!payload?.coverage?.last_checked&&deliveryLoadRetries<8){deliveryLoadRetries++;deliveryRetryTimer=setTimeout(loadDelivery,1500);}else deliveryLoadRetries=0;
+ }catch(error){
+  if(request!==deliveryRequest)return;
+  const coverageBar=$('d-coverage-bar');coverageBar.style.setProperty('--delivery-coverage',0);coverageBar.classList.add('partial');coverageBar.removeAttribute('aria-valuenow');coverageBar.setAttribute('aria-valuetext','Spend coverage unavailable');
+  $('d-coverage-percent').textContent='--';$('d-coverage').classList.add('partial');$('d-coverage').textContent='Git evidence unavailable';
+  $('d-model-note').textContent='';$('d-model-table').querySelector('tbody').innerHTML='<tr><td colspan=5><div class="deliveryEmpty emptyState">Git evidence unavailable.</div></td></tr>';$('d-project-table').querySelector('tbody').innerHTML='<tr><td colspan=4><div class="deliveryEmpty emptyState">Git evidence unavailable.</div></td></tr>';
+  $('d-push-yield').textContent='--';$('d-push-yield-note').textContent='Waiting for output tokens.';$('d-rework').textContent='--';
+	  $('d-signals').innerHTML='<div class="deliverySignalEmpty emptyState">Git evidence unavailable.</div>';
+	  $('d-shape').innerHTML='<div class="deliveryShapeEmpty emptyState">Git evidence unavailable.</div>';
+	  $('d-evidence-spend').textContent='--';setDeliveryEvidenceRatio('Git evidence unavailable.','Git evidence unavailable. Ratios require overlapping spend and Git evidence.');$('d-evidence-freshness').textContent='Git scan unavailable.';
+	  ['comparable','spend','git','unavailable'].forEach(key=>{$(`d-evidence-count-${key}`).textContent='--';});
+	 }
+}
+$('d-coverage').addEventListener('click',()=>setDeliveryEvidencePanel($('d-evidence-panel').hidden));
+$('d-evidence-close').addEventListener('click',()=>setDeliveryEvidencePanel(false));
+document.querySelectorAll('[data-delivery-evidence-filter]').forEach(button=>button.addEventListener('click',()=>{setDeliveryEvidenceFilter(button.dataset.deliveryEvidenceFilter);setDeliveryEvidencePanel(false);}));
+$('d-evidence-filter').addEventListener('change',event=>setDeliveryEvidenceFilter(event.target.value,{scroll:false}));
+$('d-day-prev').addEventListener('click',()=>selectAdjacentDeliveryDay(-1));
+$('d-day-next').addEventListener('click',()=>selectAdjacentDeliveryDay(1));
+$('d-day-close').addEventListener('click',dismissGitChartInspector);
+$('d-chart-hits').addEventListener('pointerleave',event=>{if(event.pointerType!=='touch')hideDeliveryChartTip();});
+$('d-project').addEventListener('change',event=>{deliveryProject=event.target.value;deliverySelectedDay='';deliveryEvidenceFilter='all';localStorage.setItem('tm_delivery_project',deliveryProject);loadDelivery();});
+$('d-range').addEventListener('change',event=>{deliveryRange=DELIVERY_RANGES.includes(event.target.value)?event.target.value:'30';deliverySelectedDay='';localStorage.setItem('tm_delivery_range',deliveryRange);loadDelivery();});
+$('d-project-table').querySelector('thead').addEventListener('click',event=>{
+ const button=event.target.closest('[data-delivery-sort]');if(!button)return;
+ const key=button.dataset.deliverySort;deliverySort=deliverySort.key===key?{key,direction:deliverySort.direction==='asc'?'desc':'asc'}:{key,direction:key==='project'?'asc':'desc'};renderDeliveryTable(deliveryPayload?.project_rows||[]);
+});
+$('d-model-table').querySelector('thead').addEventListener('click',event=>{
+ const button=event.target.closest('[data-delivery-model-sort]');if(!button)return;
+ const key=button.dataset.deliveryModelSort;deliveryModelSort=deliveryModelSort.key===key?{key,direction:deliveryModelSort.direction==='asc'?'desc':'asc'}:{key,direction:key==='model'?'asc':'desc'};renderDeliveryModelTable(deliveryPayload?.model_rows||[],deliveryPayload?.model_coverage);
+});
+$('d-mobile-sort').addEventListener('change',event=>{
+ const [key,direction]=event.target.value.split(':');
+ if(!['project','covered_cost','changed_lines','spend_per_1k'].includes(key)||!['asc','desc'].includes(direction))return;
+ deliverySort={key,direction};renderDeliveryTable(deliveryPayload?.project_rows||[]);
+});
+$('delivery-clear').addEventListener('click',async()=>{
+ if(!window.confirm('Clear Token Meter Git evidence? This removes only Token Meter totals and starts a new baseline. Your repositories are not changed.'))return;
+ const status=$('delivery-clear-status'),token=agentActionToken();status.textContent='Clearing…';
+ try{
+  const response=await fetch('/git-delivery/clear',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({confirm:true})});
+  const payload=await response.json();if(!response.ok||!payload.ok)throw new Error('clear failed');
+  deliveryPayload=null;deliverySelectedDay='';deliveryLastLoadedAt=0;status.textContent='Git evidence cleared. New pushes start a fresh baseline.';loadDelivery();
+ }catch(error){status.textContent='Git evidence could not be cleared.';}
+});
+
diff --git a/dashboard/js/work-status.js b/dashboard/js/work-status.js
new file mode 100644
index 00000000..57f48fff
--- /dev/null
+++ b/dashboard/js/work-status.js
@@ -0,0 +1,374 @@
+function renderWorkTags(tags){
+ const host=$('preview-work-tags');
+ if(!tags||!(tags.area||tags.work_type)){host.hidden=true;host.innerHTML='';return;}
+ const tagChips=[];
+ if(tags.area&&tags.area!=='Pending')tagChips.push(`<span class=workTag title="${tags.area_guess?'Area: the local model\u2019s best guess with low confidence':'Area (local model estimate)'}">${esc(tags.area)}${tags.area_guess?' (likely)':''}</span>`);
+ if(tags.work_type)tagChips.push(`<span class=workTag title="Work type (local model estimate)">${esc(WORK_TYPE_LABELS[tags.work_type]||tags.work_type)}</span>`);
+ if(tags.complexity)tagChips.push(`<span class=workTag title="Complexity (local model estimate)">${esc(WORK_COMPLEXITY_LABELS[tags.complexity]||tags.complexity)}</span>`);
+ if(tags.labeled_turns)tagChips.push(`<span class="workTag${tags.corrections?' pushback':''}" title="Follow-up turns that pushed back on the previous work">${tags.corrections} pushback${tags.corrections===1?'':'s'} / ${tags.labeled_turns}</span>`);
+ host.innerHTML=tagChips.join('');host.hidden=!tagChips.length;
+}
+const WORK_TYPE_LABELS={feature:'Feature work',debug:'Bug fixing',refactor:'Refactoring',test:'Testing',review:'Code review',plan:'Planning & design',explore:'Questions & research',ops:'DevOps & setup',docs:'Docs & writing',other:'Non-software',unclear:'Unclear'};
+const WORK_COMPLEXITY_LABELS={routine:'Routine',everyday:'Everyday',complex:'Complex',high_impact:'High impact'};
+const WORK_TIER_LABELS={light:'Light models',standard:'Standard models',premium:'Premium models'};
+const WORK_UNLABELED_AREAS=['No request text','Outside history','Pending'],WORK_MUTED_AREAS=['Unclear',...WORK_UNLABELED_AREAS];
+const WORK_AREA_NAMES={Pending:'Not labeled yet','Outside history':'Outside labeling history'};
+const WORK_AREA_TIPS={Unclear:'The local model was not confident about the area.','No request text':'Token Meter has no typed request to label for these sessions: the app does not record one Token Meter can read, or the session never had one.','Outside history':'Older than the labeling history in Settings → Work insights. Raise it to label these.',Pending:'Waiting for the local model.'};
+const WORK_AREA_COLORS=['var(--w1)','var(--w2)','var(--w3)','var(--w4)','var(--w5)','var(--w6)','var(--w7)','var(--w8)'];
+function workAreaColor(area,areas){
+ if(area==='Unclear')return'var(--w-unclear)';
+ if(WORK_UNLABELED_AREAS.includes(area))return'var(--w-pending)';
+ const index=(areas||[]).indexOf(area);
+ return WORK_AREA_COLORS[index]||'var(--w-unclear)';
+}
+function workPercent(value){return value==null?'--':`${Math.round(value*100)}%`;}
+function workRateText(rework){
+ if(!rework)return'<span class=workMuted>--</span>';
+ const text=workPercent(rework.rate);
+ return rework.few_samples?`<span class=workMuted title="Fewer than 20 labeled turns">${text} · few</span>`:text;
+}
+function workMonthLabel(month,partial){return workMonthName(month,{year:true,partial});}
+function workClock(value){
+ if(!value||value==='indefinite')return'';
+ const when=new Date(Number(value)*1000),today=new Date().toDateString()===when.toDateString();
+ return when.toLocaleString([],today?{hour:'2-digit',minute:'2-digit'}:{weekday:'short',hour:'2-digit',minute:'2-digit'});
+}
+function workDuration(seconds){
+ if(!seconds)return'';
+ const minutes=Math.max(1,Math.round(seconds/60));
+ return minutes<90?`about ${minutes} min left`:`about ${Math.round(minutes/60)} h left`;
+}
+const WORK_SETUP_ACTIVE=['checking','installing_ollama','starting_ollama','downloading_model','importing'];
+let workSetupTimer=0;
+function workGigabytes(bytes){const value=Math.max(0,bytes||0);return value<1e9?`${Math.round(value/1e6)} MB`:`${(value/1e9).toFixed(1)} GB`;}
+const WORK_SETUP_STEP={checking:'ollama',installing_ollama:'ollama',starting_ollama:'ollama',downloading_model:'model',importing:'prepare'};
+const WORK_SETUP_DETAIL={size:'The connection dropped before the download finished. What arrived is kept, and the next try resumes from there.',hash:'The downloaded file didn’t match its checksum, so it was deleted and will be downloaded again.',archive:'Ollama’s download didn’t pass its safety check, so it was deleted.',signature:'Ollama’s download wasn’t signed by Ollama, so it was deleted.',http_status:'The download server turned the request away.',tls:'A secure connection couldn’t be made. A proxy, VPN, or network filter may be blocking it.',timeout:'The connection timed out.',connection:'The connection was lost or couldn’t be opened.',curl:'A second download method also failed.',disk:'The disk filled up during the download.',start_timeout:'Ollama took too long to start.',import_failed:'Adding the model to Ollama failed.'};
+// Download speed from successive status polls, smoothed so one slow poll doesn't swing the estimate.
+let workSetupRate={bytes:0,at:0,speed:0,state:''};
+function workSetupSpeed(setup){
+ const now=Date.now(),done=Number(setup.done_bytes||0),rate=workSetupRate;
+ if(rate.state!==setup.state||done<rate.bytes){workSetupRate={bytes:done,at:now,speed:0,state:setup.state};return 0;}
+ const seconds=(now-rate.at)/1000;
+ if(seconds>=2){const sample=(done-rate.bytes)/seconds;rate.speed=rate.speed?rate.speed*.6+sample*.4:sample;rate.bytes=done;rate.at=now;}
+ return rate.speed;
+}
+function workRate(bytesPerSecond){return bytesPerSecond>=1e6?`${(bytesPerSecond/1e6).toFixed(1)} MB/s`:`${Math.max(1,Math.round(bytesPerSecond/1e3))} KB/s`;}
+function workSetupCopy(setup){
+ if(!setup)return null;
+ const progress=setup.total_bytes?`${workGigabytes(setup.done_bytes)} of ${workGigabytes(setup.total_bytes)}`:'';
+ let pace='';
+ if(['installing_ollama','downloading_model'].includes(setup.state)&&setup.total_bytes){
+  const speed=workSetupSpeed(setup),left=Math.max(0,setup.total_bytes-setup.done_bytes);
+  if(speed>0)pace=` · ${workRate(speed)} · ${workDuration(left/speed)||'almost done'}`;
+  if(speed>0&&speed<1e6)pace+=' · slow connection: this can take a while, and you can leave this page';
+ }
+ const retry=setup.state==='failed'&&setup.retry_at?`Token Meter tries again on its own at ${workClock(setup.retry_at)}${setup.attempts>1?` (attempt ${setup.attempts+1})`:''}, or select Retry setup now.`:'';
+ const why=WORK_SETUP_DETAIL[setup.detail]||'';
+ return {
+  checking:['Setup','Checking Ollama','Looking for Ollama and the classifier model on this Mac.'],
+  installing_ollama:['Setup',`Downloading Ollama ${setup.ollama_version||''}`.trim(),`${progress}${pace} · a pinned, signed build that runs only on this Mac.`],
+  starting_ollama:['Setup','Starting Ollama','The first start can take a minute while macOS checks it. Ollama runs in the background on this Mac only.'],
+  downloading_model:['Setup','Downloading the labeling model',`${progress}${pace} · the download resumes if the connection drops.`],
+  importing:['Setup','Preparing the model','Adding it to Ollama. This can take a few minutes.'],
+  failed:['Setup',{network:'The download stopped',verify:'A download failed its check',disk_space:'Not enough disk space',memory:'Not enough memory on this Mac',ollama_start:'Ollama didn’t start',ollama_offline:'Ollama isn’t running',import:'Importing the model failed'}[setup.reason]||'Setup stopped',
+   [why,retry||({network:'Check the internet connection, then select Retry setup.',verify:'Select Retry setup to download it again.',disk_space:setup.needed_bytes?`Free up about ${workGigabytes(setup.needed_bytes)}, then select Retry setup.`:'Free up some disk space, then select Retry setup.',memory:'The labeling model needs a Mac with at least about 10 GB of memory, so nothing was downloaded.',ollama_start:'Select Retry setup to try again.',ollama_offline:'Start Ollama on this Mac (open the Ollama app or run ollama serve), then select Retry setup.',import:'Select Retry setup to try again.'}[setup.reason]||'Select Retry setup to try again.')].filter(Boolean).join(' ')],
+ }[setup.state]||null;
+}
+// Which step is done, current, or failed; a failure belongs to the step that was running.
+function renderWorkSetupSteps(setup,lastStep){
+ const list=$('w-setup-steps'),bar=$('w-setup-bar');
+ list.hidden=!setup;bar.hidden=!(setup&&setup.total_bytes&&['installing_ollama','downloading_model'].includes(setup.state));
+ if(!setup)return;
+ const order=['ollama','model','prepare','label'],current=setup.state==='failed'?(WORK_SETUP_STEP[setup.failed_during]||lastStep):WORK_SETUP_STEP[setup.state];
+ const at=Math.max(0,order.indexOf(current));
+ list.querySelectorAll('li').forEach((item,index)=>{item.dataset.state=index<at?'done':index===at?(setup.state==='failed'?'failed':'current'):'';});
+ if(!bar.hidden){const share=Math.min(100,Math.round(100*setup.done_bytes/setup.total_bytes));bar.querySelector('i').style.width=`${share}%`;bar.setAttribute('aria-valuenow',share);}
+}
+let workSetupLastStep='ollama';
+async function refreshWorkStatus(){
+ if(!WORK||!$('view-work').classList.contains('on'))return;
+ try{
+  const response=await fetch('/work-insights/status',{cache:'no-store'}),payload=await response.json();
+  if(!payload.ok)return;
+  WORK.status=payload.status;WORK.settings=payload.settings;renderWorkStatus(WORK);
+  if(payload.status?.setup?.state==='ready')loadWork();
+ }catch(error){}
+}
+// The charts read only labeled requests, so say so until labeling catches up.
+function workProgressNote(settings,status,coverage,hasInsights){
+ const labelable=Math.max(0,(coverage.sessions||0)-(coverage.no_text_sessions||0)-(coverage.outside_sessions||0));
+ const labeled=coverage.labeled_sessions||0;
+ if(!settings.enabled||!hasInsights||(labeled>=labelable&&!status.pending))return null;
+ // The status card above already counts what is left; this says what that means for the charts.
+ if(!labeled)return['Results appear as labeling finishes','No session in this period is labeled yet, so the charts below are empty for now. They fill in as requests are labeled.'];
+ if(labeled>=labelable)return['Results are updating','Every session in this period has labels. Some are being labeled again, so numbers below may shift a little as that finishes.'];
+ // One line: the status card above already gives the labeled share.
+ return['','Charts are partial until labeling finishes · unlabeled sessions show in gray.'];
+}
+function renderWorkStatus(payload){
+ const status=payload?.status||{},settings=payload?.settings||{},coverage=payload?.insights?.coverage||{};
+ const state=status.reason==='delete_pending'?'storage_error':settings.enabled?status.state||'idle':'disabled';
+ const labelable=Math.max(0,(coverage.sessions||0)-(coverage.no_text_sessions||0)-(coverage.outside_sessions||0));
+ const share=labelable?Math.floor(100*coverage.labeled_sessions/labelable):0;
+ // While requests are queued, show what is left; the session share alone reads as done during a relabel.
+ const progress=`${status.pending?`${status.pending.toLocaleString()} request${status.pending===1?'':'s'} left to label · charts update as they finish`:`Labeled ${share}% of labelable sessions in this period`}${status.eta_s&&state==='running'?` · ${workDuration(status.eta_s)}`:''}`;
+ const copy={
+  disabled:['Off','Work insights are off','Turn on local classification in Settings to label sessions.'],
+  setup_needed:['Setup',status.reason==='remote_model'?'Cloud model refused':'Classifier model not found',status.reason==='model_missing'?(status.model_change?'Work insights now use Google’s Gemma 4 E4B model (Apache-2.0): about a 5 GB download that needs about 11 GB free while it sets up and about 5.5 GB of memory while it labels. Select Retry setup to download it.':`Looking for “${settings.model||'token-meter-gemma'}”. Select Retry setup to install it.`):status.reason==='remote_model'?'That Ollama model runs on another host. Choose a local model in Settings.':'Start Ollama on this machine, then Token Meter retries automatically.'],
+  running:['Running','Labeling sessions',progress],
+  idle:['Ready',status.pending?'Waiting to label more requests':'Up to date',progress],
+  paused:['Paused','Paused',status.paused_until==='indefinite'?'Paused until you resume.':`Paused until ${workClock(status.paused_until)}.`],
+  throttled:['Waiting',{on_battery:'Waiting: on battery power',system_busy:'Waiting: this Mac is busy',model_slow:'Waiting: the model is responding slowly',low_memory:'Waiting: memory is low',not_enough_memory:'Waiting: not enough memory on this Mac'}[status.reason]||'Waiting',status.reason==='not_enough_memory'?'The labeling model needs about 6 GB of memory plus room for macOS and your apps, which this Mac doesn’t have. Work insights stay off the model so your Mac stays responsive.':status.reason==='low_memory'?`The model is unloaded so other apps keep their memory. ${progress} · checks again${status.retry_at?` at ${workClock(status.retry_at)}`:' shortly'}.`:`${progress} · checks again in a minute.`],
+  backoff:['Retrying',status.reason==='internal_error'?'Recovering from an internal error':status.reason==='timeout'?'Ollama is slow to answer':'Can’t reach Ollama',`${status.retry_at?`Retrying at ${workClock(status.retry_at)}.`:'Retrying shortly.'} Queued work is kept.${status.error_at?` (${status.error_at})`:''}`],
+  storage_error:['Error',status.reason==='delete_pending'?'Deleting labels didn’t finish':'Can’t save labels',status.reason==='delete_pending'?'Labeling is stopped until the delete succeeds. Token Meter retries every five minutes.':'Token Meter retries every five minutes.'],
+ }[state]||['Ready','Up to date',progress];
+ const setupRelevant=status.setup&&(WORK_SETUP_ACTIVE.includes(status.setup.state)||(status.setup.state==='failed'&&['setup_needed','backoff'].includes(status.state)));
+ const setup=settings.enabled&&setupRelevant?status.setup:null,setupCopy=workSetupCopy(setup);
+ const shown=setupCopy||copy;
+ const off=!settings.enabled;$('w-turn-on').hidden=!off;$('w-open-settings').hidden=off;
+ const pill=$('w-state');pill.dataset.state=setupCopy?(setup.state==='failed'?'setup_needed':'running'):state;pill.textContent=shown[0];
+ $('w-status-title').textContent=shown[1];$('w-status-detail').textContent=shown[2];
+ const note=workProgressNote(settings,status,coverage,Boolean(payload?.insights));
+ $('w-progress-note').hidden=!note;
+ if(note){$('w-progress-title').textContent=note[0];$('w-progress-title').hidden=!note[0];$('w-progress-detail').textContent=note[1];}
+ if(setup&&WORK_SETUP_STEP[setup.state])workSetupLastStep=WORK_SETUP_STEP[setup.state];
+ renderWorkSetupSteps(setupCopy?setup:null,workSetupLastStep);
+ const setupState=status.setup?.state;
+ const serviceNeedsSetup=['setup_needed','backoff'].includes(status.state);
+ $('w-setup-retry').hidden=!(settings.enabled&&status.setup&&!WORK_SETUP_ACTIVE.includes(setupState)&&(setupState==='failed'?serviceNeedsSetup:state==='setup_needed'));
+ clearTimeout(workSetupTimer);
+ if(setup&&(WORK_SETUP_ACTIVE.includes(setup.state)||setup.retry_at))workSetupTimer=setTimeout(refreshWorkStatus,setup.retry_at&&setup.state==='failed'?15000:4000);
+ $('w-pause-wrap').hidden=!settings.enabled||state==='paused';
+ $('w-resume').hidden=state!=='paused';
+}
+const WORK_OUTCOME_ORDER=['accepted','recovered','ended_on_pushback','unclear'],OUTCOMES_SHOWN=WORK_OUTCOME_ORDER;
+function workIsDay(key){return /^\d{4}-\d{2}-\d{2}$/.test(String(key||''));}
+function workMonthName(month,{year=false,partial=false}={}){
+ if(workIsDay(month)){
+  const day=new Date(`${month}T12:00:00`);if(Number.isNaN(day.getTime()))return month;
+  const text=day.toLocaleDateString([],year?{month:'short',day:'numeric',year:'numeric'}:{month:'short',day:'numeric'});
+  return partial?`${text} · so far`:text;
+ }
+ const date=new Date(`${month}-01T00:00:00`);
+ if(Number.isNaN(date.getTime()))return month;
+ const text=date.toLocaleDateString([],year?{month:'short',year:'numeric'}:{month:'short'});
+ return partial?`${text} · so far`:text;
+}
+let workBreakdownModel='',workBreakdownSort={key:'spend',direction:'desc'};
+const WORK_BREAKDOWN_COLUMNS=[
+ ['name','Kind of work','Select to sort by name.'],
+ ['spend','Spend','Each request\'s share of its session\'s cost.'],
+ ['requests','Requests','Messages you typed. Agent : human counts only those from apps that split model calls by request; hover a row for its counts.'],
+ ['resolved_rate','Task outcomes','Tasks with a labeled follow-up: accepted, recovered after pushback, ended on pushback, or unclear. Sorts by resolved share.'],
+ ['cost_per_resolved','Cost / resolved','Spend on resolved tasks per resolved task.'],
+ ['agent_per_human','Agent : human','Agent turns (model calls) per human turn (message you typed). Only apps that split model calls by request count.'],
+ ['pushback','Pushback','How often your next message pushed back. Faded below 20 labeled follow-ups.'],
+ ['best_model','Best model','Least pushback among models with 20+ labeled follow-ups and 3+ sessions for this kind of work. Sorts by its pushback.'],
+ ['worst_model','Worst model','Most pushback among the same rated models. Sorts by its pushback.'],
+];
+function workBreakdownName(row){return row.key?(WORK_TYPE_LABELS[row.key]||row.key):'Not labeled yet';}
+function workBreakdownValue(row,key){
+ if(key==='name')return workBreakdownName(row).toLowerCase();
+ if(key==='pushback')return row.pushback?row.pushback.rate:null;
+ if(key==='best_model'||key==='worst_model')return row[key]?row[key].rate:null;
+ return row[key]??null;
+}
+function sortWorkBreakdown(rows,sort=workBreakdownSort){
+ const sign=sort.direction==='asc'?1:-1;
+ return [...rows].sort((a,b)=>{const x=workBreakdownValue(a,sort.key),y=workBreakdownValue(b,sort.key);
+  if(x==null&&y==null)return b.spend-a.spend;if(x==null)return 1;if(y==null)return -1;
+  return (x<y?-1:x>y?1:0)*sign||b.spend-a.spend;});
+}
+function workCellBar(value,max){
+ if(value==null||!(max>0))return '';
+ return `<span class=workCellBar><i style="width:${Math.max(2,100*value/max).toFixed(1)}%"></i></span>`;
+}
+function renderWorkBreakdown(insights){
+ const breakdown=insights?.breakdown||{},models=breakdown.models||[],select=$('w-breakdown-model');
+ const keys=models.map(item=>`${item.model}␟${item.runtime}`);
+ if(workBreakdownModel&&!keys.includes(workBreakdownModel))workBreakdownModel='';
+ select.innerHTML='<option value="">All models</option>'+models.map((item,index)=>`<option value="${esc(keys[index])}">${esc(`${item.model} · ${item.runtime}`)}</option>`).join('');
+ select.value=workBreakdownModel;
+ const chosen=workBreakdownModel?models[keys.indexOf(workBreakdownModel)]:null;
+ const overall=chosen?chosen.overall:breakdown.overall,table=$('w-breakdown-table');
+ const columns=WORK_BREAKDOWN_COLUMNS.filter(([key])=>!chosen||(key!=='best_model'&&key!=='worst_model'));
+ if(chosen&&(workBreakdownSort.key==='best_model'||workBreakdownSort.key==='worst_model'))workBreakdownSort={key:'spend',direction:'desc'};
+ const calls=value=>value==null?'--':value.toLocaleString(undefined,{maximumFractionDigits:1});
+ const count=value=>(value||0).toLocaleString();
+ const ratio=row=>workAgentRatio(row.agent_per_human);
+ if(!overall||!overall.requests){$('w-breakdown-note').textContent='';$('w-breakdown-foot').textContent='';table.innerHTML='<tbody><tr><td><div class=workEmpty>No requests in this period.</div></td></tr></tbody>';return;}
+ $('w-breakdown-note').textContent=`${chosen?`${chosen.model} · `:''}${money(overall.spend)} over ${count(overall.requests)} request${overall.requests===1?'':'s'} · agent : human ${ratio(overall)} · ${workPercent(overall.resolved_rate)} of judged tasks resolved`;
+ const rows=sortWorkBreakdown(chosen?chosen.work_type:breakdown.work_type||[]);
+ const max=key=>Math.max(0,...rows.map(row=>workBreakdownValue(row,key)||0));
+ const maxSpend=max('spend'),maxRatio=max('agent_per_human');
+ const muted=row=>!row.key||row.key==='unclear';
+ const outcomeBar=row=>{const judged=WORK_OUTCOME_ORDER.reduce((sum,key)=>sum+((row.outcomes||{})[key]||0),0);
+  if(!judged)return `<span class=workMuted title="${esc(`${count(row.tasks)} task${row.tasks===1?'':'s'}, none with a labeled follow-up`)}">--</span>`;
+  const present=WORK_OUTCOME_ORDER.filter(key=>(row.outcomes||{})[key]);
+  return `<span class=workOutcomeBar role=img aria-label="${esc(present.map(key=>`${WORK_OUTCOME_LABELS[key]} ${row.outcomes[key]}`).join(', '))}" title="${esc(`${count(judged)} of ${count(row.tasks)} tasks judged`)}">${present.map(key=>`<i style="flex:${row.outcomes[key]} 0 0;--swatch:${WORK_OUTCOME_COLORS[key]}" title="${esc(`${WORK_OUTCOME_LABELS[key]} · ${row.outcomes[key]}`)}"></i>`).join('')}</span><small>${workPercent(row.resolved_rate)} resolved</small>`;};
+ const modelCell=(row,field)=>{const item=row[field];if(!item)return '<td><span class=workMuted title="Needs two models with enough labeled follow-ups">--</span></td>';
+  const drill={model:item.model,model_runtime:item.runtime};if(row.key)drill.work_type=row.key;
+  return `<td><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify(drill))}" data-drill-label="${esc(`${workBreakdownName(row)} · ${item.model}`)}" title="${esc(`${item.model} · ${item.runtime} · ${workPercent(item.rate)} pushback over ${count(item.samples)} labeled follow-ups`)}"><span class=workScoreName><b>${esc(item.model)}</b><small>${esc(item.runtime)} · ${workPercent(item.rate)}</small></span></button></td>`;};
+ const cells=(row,total)=>{
+  const name=workBreakdownName(row),drill=total||!row.key?null:{work_type:row.key,...(chosen?{model:chosen.model,model_runtime:chosen.runtime}:{})};
+  const label=total?'<strong>All work</strong>':drill?`<button type=button class=workDrillBtn data-drill="${esc(JSON.stringify(drill))}" data-drill-label="${esc(chosen?`${name} · ${chosen.model}`:name)}">${esc(name)}</button>`:esc(name);
+  return `<td>${label}</td>
+<td class=num><b>${money(row.spend)}</b>${total?'':`<small> ${workPercent(row.share)}</small>`}${total?'':workCellBar(row.spend,maxSpend)}</td>
+<td class=num title="${esc(`${count(row.sessions)} session${row.sessions===1?'':'s'}`)}">${count(row.requests)}${row.few_samples&&!total?'<small class=workCellNote>few</small>':''}</td>
+<td class=workOutcomeCell>${outcomeBar(row)}</td>
+<td class=num>${row.cost_per_resolved==null?'<span class=workMuted>--</span>':money(row.cost_per_resolved)}</td>
+<td class=num title="${esc(row.human_turns?`${count(row.agent_turns)} agent turns, ${count(row.human_turns)} human turns`:'Not recorded by these apps')}"><b>${ratio(row)}</b>${total?'':workCellBar(row.agent_per_human,maxRatio)}</td>
+<td class=num>${workRateText(row.pushback)}</td>${chosen?'':modelCell(row,'best_model')+modelCell(row,'worst_model')}`;};
+ const head=columns.map(([key,label,tip])=>{const active=workBreakdownSort.key===key;
+  return `<th${key==='name'?'':' class=num'} aria-sort="${active?(workBreakdownSort.direction==='asc'?'ascending':'descending'):'none'}"><button class=efficiencySort type=button data-work-sort=${key} title="${esc(tip)}">${esc(label)}<span class=efficiencySortMark aria-hidden=true>${active?(workBreakdownSort.direction==='asc'?'↑':'↓'):''}</span></button></th>`;}).join('');
+ table.innerHTML=`<thead><tr>${head}</tr></thead><tbody><tr class=workBreakdownTotal>${cells(overall,true)}</tr>${rows.map(row=>`<tr${muted(row)?' class=workMuted':''}>${cells(row,false)}</tr>`).join('')}</tbody>`;
+ const unanswered=overall.requests-overall.human_turns,unjudged=(overall.outcomes||{}).unjudged||0;
+ const excludedDetail=[unanswered>0?`${count(unanswered)} of ${count(overall.requests)} requests come from apps that don't split model calls by request, so Agent : human leaves them out.`:'',unjudged?`${count(unjudged)} of ${count(overall.tasks)} tasks had no labeled follow-up and aren't in Task outcomes.`:''].filter(Boolean).join(' ');
+ const excludedShort=[unanswered>0?`${count(unanswered)} ${unanswered===1?'request':'requests'}`:'',unjudged?`${count(unjudged)} ${unjudged===1?'task':'tasks'}`:''].filter(Boolean).join(', ');
+ $('w-breakdown-foot').innerHTML=excludedShort?`<span class=fieldtip tabindex=0 aria-description="${esc(excludedDetail)}" data-tip="${esc(excludedDetail)}">· ${esc(excludedShort)} excluded</span>`:'';
+}
+$('w-breakdown-model').addEventListener('change',event=>{workBreakdownModel=event.target.value;if(WORK)renderWorkBreakdown(WORK.insights);});
+$('w-breakdown-table').addEventListener('click',event=>{const button=event.target.closest('[data-work-sort]');if(!button)return;event.stopPropagation();const key=button.dataset.workSort;
+ workBreakdownSort=workBreakdownSort.key===key?{key,direction:workBreakdownSort.direction==='desc'?'asc':'desc'}:{key,direction:key==='name'||key==='best_model'?'asc':'desc'};if(WORK)renderWorkBreakdown(WORK.insights);});
+function drawWorkTrend(svg,points,{value,axis,tip,average,averageText,empty,floor,daily}){
+ // Drawn in pixels at the chart's own width, so labels stay at the 11px floor in a half-width card.
+ const W=Math.max(320,Math.round(svg.parentElement.clientWidth||560));
+ if(!points.length){svg.setAttribute('viewBox',`0 0 ${W} 120`);svg.innerHTML=`<text x=${W/2} y=60 text-anchor=middle class=workAxisText>${esc(empty)}</text>`;return;}
+ const H=260,left=40,right=12,top=16,bottom=28,max=Math.max(floor,...points.map(value))*1.15,fill=`${svg.id}-fill`;
+ svg.setAttribute('viewBox',`0 0 ${W} ${H}`);
+ const x=index=>points.length===1?(left+W-right)/2:left+(W-left-right)*index/(points.length-1),y=v=>top+(H-top-bottom)*(1-v/max);
+ const path=points.map((point,index)=>`${index?'L':'M'}${x(index).toFixed(1)},${y(value(point)).toFixed(1)}`).join('');
+ const area=points.length>1?`<path class=workArea style="fill:url(#${fill})" d="${path}L${x(points.length-1).toFixed(1)},${y(0).toFixed(1)}L${x(0).toFixed(1)},${y(0).toFixed(1)}Z"></path>`:'';
+ const grid=[0,max/2,max].map(v=>`<line class=workGridLine x1=${left} x2=${W-right} y1="${y(v).toFixed(1)}" y2="${y(v).toFixed(1)}"></line><text class=workAxisText x=${left-6} y="${(y(v)+3).toFixed(1)}" text-anchor=end>${esc(axis(v))}</text>`).join('');
+ const avg=average==null?'':`<line class=workTrendAvg x1=${left} x2=${W-right} y1="${y(average).toFixed(1)}" y2="${y(average).toFixed(1)}"></line><text class=workTrendAvgText x=${W-right} y="${(y(average)-5).toFixed(1)}" text-anchor=end>${esc(averageText)}</text>`;
+ const label=point=>daily?workMonthName(point.week,{year:false}):`Week of ${workMonthName(point.week,{year:false})}`;
+ const dots=points.map((point,index)=>`<circle class="workPoint${point.few_samples?' few':''}" cx="${x(index).toFixed(1)}" cy="${y(value(point)).toFixed(1)}" r=4><title>${esc(`${label(point)} · ${tip(point)}${point.few_samples?' (few samples)':''}`)}</title></circle>`).join('');
+ svg.innerHTML=`<defs><linearGradient id=${fill} x1=0 y1=0 x2=0 y2=1><stop offset=0 style="stop-color:var(--signal);stop-opacity:.28"/><stop offset=1 style="stop-color:var(--signal);stop-opacity:0"/></linearGradient></defs>${grid}${area}<path class=workLine d="${path}"></path>${dots}${avg}<text class=workAxisText x=${left} y=${H-6}>${esc(workMonthName(points[0].week,{year:false}))}</text><text class=workAxisText x=${W-right} y=${H-6} text-anchor=end>${esc(workMonthName(points[points.length-1].week,{year:false}))}</text>`;
+}
+function renderWorkRework(insights){
+ const rework=insights?.rework||{},select=$('w-rework-model'),series=rework.weekly_by_model||[];
+ const keys=series.map(item=>`${item.model}␟${item.runtime}`);
+ if(select.value&&!keys.includes(select.value))select.value='';
+ const current=select.value;
+ select.innerHTML='<option value="">All models</option>'+series.map((item,index)=>`<option value="${esc(keys[index])}">${esc(`${item.model} · ${item.runtime}`)}</option>`).join('');
+ select.value=current;
+ const chosen=current?series[keys.indexOf(current)]:null,weeks=(chosen?chosen.weeks:rework.weekly||[]).slice(rework.grain==='day'?-31:-26);
+ const samples=weeks.reduce((sum,week)=>sum+week.samples,0),hits=weeks.reduce((sum,week)=>sum+week.rate*week.samples,0),daily=rework.grain==='day';
+ const average=samples?hits/samples:0;
+ $('w-rework-note').textContent=weeks.length?`${workPercent(average)} of ${samples.toLocaleString()} follow-ups · ${daily?'daily':'weekly'}`:'Waiting for labeled follow-ups';
+ drawWorkTrend($('w-rework-trend'),weeks,{value:week=>week.rate,axis:v=>`${Math.round(v*100)}%`,tip:week=>`${workPercent(week.rate)} of ${week.samples} turns`,
+  average,averageText:`avg ${workPercent(average)}`,empty:'No labeled follow-ups in this period yet',floor:.1,daily});
+}
+function workAgentRatio(value){return value==null?'--':`${value.toLocaleString(undefined,{maximumFractionDigits:1})} : 1`;}
+function renderWorkAgentTrend(insights){
+ const models=insights?.breakdown?.models||[],select=$('w-agent-model'),keys=models.map(item=>`${item.model}␟${item.runtime}`);
+ if(select.value&&!keys.includes(select.value))select.value='';
+ const current=select.value;
+ select.innerHTML='<option value="">All models</option>'+models.map((item,index)=>`<option value="${esc(keys[index])}">${esc(`${item.model} · ${item.runtime}`)}</option>`).join('');
+ select.value=current;
+ const chosen=current?models[keys.indexOf(current)]:null;
+ const trend=(chosen?chosen.agent_trend:insights?.breakdown?.agent_trend)||{},daily=trend.grain==='day',points=(trend.points||[]).slice(daily?-31:-26);
+ const human=points.reduce((sum,point)=>sum+point.human_turns,0),agent=points.reduce((sum,point)=>sum+point.agent_turns,0),average=human?agent/human:null;
+ $('w-agent-note').textContent=points.length?`${workAgentRatio(average)} over ${human.toLocaleString()} human turns · ${daily?'daily':'weekly'}`:'Waiting for requests with model calls';
+ drawWorkTrend($('w-agent-trend'),points,{value:point=>point.agent_per_human,axis:v=>v.toLocaleString(undefined,{maximumFractionDigits:0}),
+  tip:point=>`${workAgentRatio(point.agent_per_human)} · ${point.agent_turns.toLocaleString()} agent / ${point.human_turns.toLocaleString()} human turns`,
+  average,averageText:`avg ${workAgentRatio(average)}`,empty:'No requests with model calls in this period yet',floor:1,daily});
+}
+function openWorkSessions(filters,label){
+ const query=new URLSearchParams({months:workMonths});
+ if(workRuntime)query.set('runtime',workRuntime);
+ const project=filters.project||workProject;if(project)query.set('project',project);
+ Object.entries(filters).forEach(([key,value])=>{if(key!=='project'&&value!=null&&value!=='')query.set(key,value);});
+ query.set('label',label||'Work');
+ location.hash=`sessions-all?work=1&${query}`;
+}
+function renderWorkSizing(insights){
+ const cells=insights?.right_sizing?.cells||[],grid=$('w-sizing');
+ if(!insights?.right_sizing?.tiers_known){grid.innerHTML='<div class=workEmpty style="grid-column:1/-1">Model price tiers are unavailable for these sessions.</div>';return;}
+ const tiers=['light','standard','premium'],groups=['routine','everyday','complex'];
+ const head=`<div role=row style="display:contents"><div class=workSizingHead role=columnheader></div>${tiers.map(tier=>`<div class=workSizingHead role=columnheader>${esc(WORK_TIER_LABELS[tier])}</div>`).join('')}</div>`;
+ grid.innerHTML=head+groups.map(group=>`<div role=row style="display:contents"><div class=workSizingRowHead role=rowheader>${group==='complex'?'Complex+':esc(WORK_COMPLEXITY_LABELS[group])}</div>${tiers.map(tier=>{
+  const cell=cells.find(item=>item.complexity===group&&item.tier===tier)||{requests:0,spend:0};
+  const flag=cell.flag==='possible_overspend'?'<span class=workFlag><span aria-hidden=true>▲</span>Possible overspend (estimate)</span>':cell.flag==='possible_false_economy'?'<span class=workFlag><span aria-hidden=true>▲</span>Possible false economy (estimate)</span>':'';
+  const body=`<strong class=mono>${cell.requests?money(cell.spend):'--'}</strong><span>${cell.requests} request${cell.requests===1?'':'s'}</span>${cell.rework?`<span>Rework ${workRateText(cell.rework)}</span>`:''}${flag}`;
+  return `<div class=workSizingCell role=cell data-flag="${esc(cell.flag||'')}">${cell.requests?`<button type=button class="workDrillBtn workSizingBtn" data-drill="${esc(JSON.stringify({complexity:group,tier}))}" data-drill-label="${esc(`${group==='complex'?'Complex+':WORK_COMPLEXITY_LABELS[group]} · ${WORK_TIER_LABELS[tier]}`)}">${body}</button>`:body}</div>`;
+ }).join('')}</div>`).join('');
+}
+function renderWorkEffort(insights){
+ const effort=insights?.right_sizing?.effort,table=$('w-effort-table');
+ if(!effort||!(effort.efforts||[]).length){table.innerHTML='<tbody><tr><td><div class=workEmpty>No reasoning-effort data for these sessions.</div></td></tr></tbody>';return;}
+ const groups=['routine','everyday','complex'],cell=(group,level)=>(effort.cells||[]).find(item=>item.complexity===group&&item.effort===level);
+ table.innerHTML=`<thead><tr><th>Complexity</th>${effort.efforts.map(level=>`<th class=num>${esc(level)}</th>`).join('')}</tr></thead><tbody>${groups.map(group=>`<tr><td>${group==='complex'?'Complex+':esc(WORK_COMPLEXITY_LABELS[group])}</td>${effort.efforts.map(level=>{const item=cell(group,level);if(!item||!item.requests)return '<td class="num workMuted">--</td>';return `<td class="num mono workFitCell"><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify({complexity:group,effort:level}))}" data-drill-label="${esc(`${group==='complex'?'Complex+':WORK_COMPLEXITY_LABELS[group]} · ${level} effort`)}">${money(item.spend)}${item.flag?'<span class=workFitBest style="color:var(--warn);border-color:rgb(var(--orange-rgb)/.5)">▲ Overthinking?</span>':''}<small>${item.requests} · rework ${item.rework?workRateText(item.rework):'--'}</small></button></td>`;}).join('')}</tr>`).join('')}</tbody>`;
+}
+const WORK_TIER_COLORS={light:'var(--w-tier-light)',standard:'var(--w-tier-standard)',premium:'var(--w-tier-premium)'};
+const WORK_EFFORT_BANDS=[{key:'default',label:'Default',levels:['default'],note:'not recorded'},{key:'normal',label:'Low–medium',levels:['low','medium']},{key:'high',label:'High',levels:['high']},{key:'extra',label:'Extra high+',levels:['xhigh','max','ultra']}];
+const WORK_EFFORT_BAND_COLORS={default:'var(--w-unclear)',normal:'var(--w-tier-light)',high:'var(--w-tier-standard)',extra:'var(--w-tier-premium)'};
+const WORK_EFFORT_COLORS={low:'var(--w-e1)',medium:'var(--w-e2)',high:'var(--w-e3)',xhigh:'var(--w-e4)',max:'var(--w-e5)',ultra:'var(--w-e6)'};
+const WORK_GROUP_LABELS={routine:'Routine',everyday:'Everyday',complex:'Complex+'};
+function workMeter(rate,max,{few=false,color=''}={}){
+ if(rate==null)return '<span class=workMuted>--</span>';
+ return `<span class=workMeter data-few="${few}"${few?' title="Fewer than 20 labeled turns"':''}><i><b style="width:${(100*Math.min(1,rate/Math.max(1e-9,max))).toFixed(1)}%${color?`;--meter:${color}`:''}"></b></i><em class=mono>${workPercent(rate)}</em></span>`;
+}
+let workScoreSort={key:'spend',direction:'desc'};
+const WORK_SCORE_COLUMNS=[['model','Model'],['tasks','Tasks'],['spend','Spend'],['pushback','Pushback'],['resolved_rate','Resolved'],['cost_per_resolved','Per resolved'],
+ ['kinds','Best / weakest at','Kinds of work where this model drew the least (best) or most (weakest) pushback among models with 20+ labeled follow-ups and 3+ sessions. Sorts by how many it is best at.']];
+function workScoreValue(row,key){
+ if(key==='model')return `${row.model} ${row.runtime}`.toLowerCase();
+ if(key==='pushback')return row.rework?row.rework.rate:null;
+ if(key==='kinds')return (row.best_at||[]).length*100-(row.worst_at||[]).length;
+ return row[key]??null;
+}
+function sortWorkScore(rows,sort=workScoreSort){
+ const sign=sort.direction==='asc'?1:-1;
+ return [...rows].sort((a,b)=>{const x=workScoreValue(a,sort.key),y=workScoreValue(b,sort.key);
+  if(x==null&&y==null)return b.spend-a.spend;if(x==null)return 1;if(y==null)return -1;
+  return (x<y?-1:x>y?1:0)*sign||b.spend-a.spend;});
+}
+function renderWorkScorecard(insights){
+ const rows=insights?.model_scorecard||[],table=$('w-scorecard');
+ if(!rows.length){table.innerHTML='<tbody><tr><td><div class=workEmpty>Waiting for sessions in this period.</div></td></tr></tbody>';return;}
+ // Colors follow spend rank, so a model keeps its color however the table is sorted.
+ const identities=rows.map(row=>`${row.model}::${row.runtime}`);
+ const maxPush=Math.max(.05,...rows.map(row=>row.rework?.rate||0)),ranked=rows.filter(row=>row.cost_per_resolved!=null&&row.judged_tasks>=5&&(row.judged_sessions??0)>=3);
+ const lowestCost=ranked.length>=2?Math.min(...ranked.map(row=>row.cost_per_resolved)):null;
+ const kindChips=(label,list,tone)=>list&&list.length?`<div class=workScoreKinds><small>${label}</small>${list.map(kind=>`<span class="chip${tone?` ${tone}`:''}">${esc(WORK_TYPE_LABELS[kind]||kind)}</span>`).join('')}</div>`:'';
+ const kinds=row=>kindChips('Best',row.best_at,'')+kindChips('Weakest',row.worst_at,'tone-warn')||'<span class=workMuted>--</span>';
+ const head=WORK_SCORE_COLUMNS.map(([key,label,tip])=>{const active=workScoreSort.key===key;
+  return `<th aria-sort="${active?(workScoreSort.direction==='asc'?'ascending':'descending'):'none'}"><button class=efficiencySort type=button data-work-score-sort=${key}${tip?` title="${esc(tip)}"`:''}>${esc(label)}<span class=efficiencySortMark aria-hidden=true>${active?(workScoreSort.direction==='asc'?'↑':'↓'):''}</span></button></th>`;}).join('');
+ table.innerHTML=`<thead><tr>${head}</tr></thead><tbody>${sortWorkScore(rows).map(row=>{
+  const few=!row.rework||row.rework.few_samples,best=lowestCost!=null&&ranked.includes(row)&&row.cost_per_resolved===lowestCost,thin=row.judged_tasks<5,identity=`${row.model}::${row.runtime}`;
+  return `<tr><td><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify({model:row.model,model_runtime:row.runtime}))}" data-drill-label="${esc(`${row.model} · ${row.runtime}`)}"><i class=workScoreDot style="--swatch:${modelColor(identity,identities)}"></i><span class=workScoreName><b>${esc(row.model)}</b><small>${esc(row.runtime)}${row.tier?` · ${esc(WORK_TIER_LABELS[row.tier]||row.tier)}`:''}</small></span></button></td><td><span class=mono>${row.tasks.toLocaleString()}</span></td><td><span class=mono>${money(row.spend)}</span></td><td><span>${row.rework?workMeter(row.rework.rate,maxPush,{few}):'<span class=workMuted>--</span>'}</span></td><td><span class=mono>${row.resolved_rate==null?'<span class=workMuted>--</span>':thin?`<span class=workMuted title="${esc(`${row.judged_tasks} judged task${row.judged_tasks===1?'':'s'}`)}">${workPercent(row.resolved_rate)} · few</span>`:workPercent(row.resolved_rate)}</span></td><td><span class=mono${best?' style="color:var(--good)"':''}>${row.cost_per_resolved==null?'<span class=workMuted>--</span>':money(row.cost_per_resolved)}${best?'<em class=workLowest>lowest</em>':''}</span></td><td>${kinds(row)}</td></tr>`;
+ }).join('')}</tbody>`;
+}
+$('w-scorecard').addEventListener('click',event=>{const button=event.target.closest('[data-work-score-sort]');if(!button)return;event.stopPropagation();const key=button.dataset.workScoreSort;
+ workScoreSort=workScoreSort.key===key?{key,direction:workScoreSort.direction==='desc'?'asc':'desc'}:{key,direction:key==='model'?'asc':'desc'};if(WORK)renderWorkScorecard(WORK.insights);});
+function workMixRows(groups,levels,cellFor,colorFor,labelFor,drillFor,flagged){
+ return groups.map(group=>{
+  const cells=levels.map(level=>({level,cell:cellFor(group,level)})).filter(item=>item.cell&&item.cell.spend>0);
+  const total=cells.reduce((sum,item)=>sum+item.cell.spend,0);
+  if(!total)return `<div class=workMixRow><span class=workMixLabel>${esc(WORK_GROUP_LABELS[group])}</span><div class=workStack></div><span class="workMixTotal workMuted">--</span></div>`;
+  return `<div class=workMixRow><span class=workMixLabel>${esc(WORK_GROUP_LABELS[group])}</span><div class=workStack>${cells.map(({level,cell})=>{const share=cell.spend/total;return `<button type=button style="flex:${share.toFixed(4)} 0 0;--seg:${colorFor(level)}" data-flag="${flagged(cell)}" data-drill="${esc(JSON.stringify(drillFor(group,level)))}" data-drill-label="${esc(`${WORK_GROUP_LABELS[group]} · ${labelFor(level)}`)}" title="${esc(`${WORK_GROUP_LABELS[group]} · ${labelFor(level)}: ${money(cell.spend)} · ${workPercent(share)} · ${cell.requests} request${cell.requests===1?'':'s'}${cell.rework?` · pushback ${workPercent(cell.rework.rate)}`:''}${flagged(cell)?` · ${workFlagReason(cell)}`:''}`)}" aria-label="${esc(`${WORK_GROUP_LABELS[group]}, ${labelFor(level)}, ${money(cell.spend)}, ${workPercent(share)} of spend`)}">${share>=.14?`<span>${workPercent(share)}</span>`:''}</button>`;}).join('')}</div><span class=workMixTotal>${money(total)}</span></div>`;
+ }).join('');
+}
+function renderWorkMix(insights){
+ const sizing=insights?.right_sizing||{},groups=['routine','everyday','complex'],tiers=['light','standard','premium'];
+ const tierHost=$('w-tier-mix'),effortHost=$('w-effort-mix');
+ if(!sizing.tiers_known){tierHost.innerHTML='<div class=workEmpty>Model price tiers are unavailable for these sessions.</div>';}
+ else{
+  const cell=(group,tier)=>(sizing.cells||[]).find(item=>item.complexity===group&&item.tier===tier);
+  tierHost.innerHTML=workMixRows(groups,tiers,cell,tier=>WORK_TIER_COLORS[tier],tier=>WORK_TIER_LABELS[tier],(group,tier)=>({complexity:group,tier}),item=>Boolean(item.flag))+`<div class=workMixLegend>${tiers.map(tier=>`<span><i style="--swatch:${WORK_TIER_COLORS[tier]}"></i>${esc(WORK_TIER_LABELS[tier])}</span>`).join('')}<span><i class=flag></i>Premium on routine · light on complex</span></div>`;
+ }
+ const effort=sizing.effort||{},levels=effort.efforts||[];
+ if(!levels.length){effortHost.innerHTML='<div class=workEmpty>No reasoning-effort data for these sessions.</div>';}
+ else{
+  // Effort levels are folded into readable groups (unrecorded ones into Default); the tables below keep every level.
+  const bands=WORK_EFFORT_BANDS.map(band=>({...band,levels:band.levels.filter(level=>levels.includes(level))})).filter(band=>band.levels.length);
+  const cell=(group,key)=>{
+   const band=bands.find(item=>item.key===key),members=(effort.cells||[]).filter(item=>item.complexity===group&&band.levels.includes(item.effort));
+   if(!members.length)return null;
+   const samples=members.reduce((sum,item)=>sum+(item.rework?.samples||0),0),hits=members.reduce((sum,item)=>sum+(item.rework?(item.rework.rate*item.rework.samples):0),0);
+   return {spend:members.reduce((sum,item)=>sum+item.spend,0),requests:members.reduce((sum,item)=>sum+item.requests,0),flag:members.some(item=>item.flag)?'possible_overthinking':'',rework:samples?{rate:hits/samples,samples}:null,levels:members.filter(item=>item.requests).map(item=>item.effort)};
+  };
+  effortHost.innerHTML=workMixRows(groups,bands.map(band=>band.key),cell,key=>WORK_EFFORT_BAND_COLORS[key],key=>bands.find(band=>band.key===key).label,(group,key)=>({complexity:group,effort:(cell(group,key)?.levels||[]).join(',')}),item=>Boolean(item.flag))+`<div class=workMixLegend>${bands.map(band=>`<span><i style="--swatch:${WORK_EFFORT_BAND_COLORS[band.key]}"></i>${esc(band.label)}<small>${esc(band.note||band.levels.join(', '))}</small></span>`).join('')}<span><i class="flag effort"></i>High effort on routine work</span></div>`;
+ }
+}
diff --git a/dashboard/markup/efficiency-work.html b/dashboard/markup/efficiency-work.html
new file mode 100644
index 00000000..a4f916dc
--- /dev/null
+++ b/dashboard/markup/efficiency-work.html
@@ -0,0 +1,109 @@
+	 <div class=view id=view-efficiency>
+	  <div class="spectrumPageHeadFrame hasPageActions">
+	   <div class="efficiencyHead spectrumPageHead" data-page-signal=efficiency>
+	    <div class=spectrumPageHeadCopy><h1>Efficiency</h1></div>
+	   </div>
+	   <div class=spectrumPageActions><div class=modelControls>
+	    <label class=filterControl><span>Project</span><select class=filterSelect id=e-project aria-label="Efficiency project filter"><option value="">All projects</option></select></label>
+	    <div class=filterControl><span>Models</span><details class=modelPicker id=e-model-picker><summary aria-label="Choose models for efficiency"><span id=e-model-summary>All models</span></summary><div class=modelPickerMenu id=e-model-options role=group aria-label="Models for efficiency"></div></details></div>
+	    <label class=filterControl><span>History</span><select class=filterSelect id=e-range aria-label="Efficiency history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
+	   </div></div>
+	  </div>
+	  <div class=efficiencyHero aria-label="Mechanical efficiency">
+	   <section class="card efficiencyHeadline"><div class=efficiencyEyebrow>Output / $</div><div class="efficiencyValueRow valueWithDelta"><div class="v mono" id=e-output-dollar>--</div><div class=trendDelta id=e-output-dollar-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-output-dollar-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily output per covered dollar"></svg><div class="efficiencyChartTip chartTip" id=e-output-dollar-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-output-dollar-status aria-live=polite></span></div><div class=efficiencyCoverage id=e-output-dollar-coverage>Waiting for covered cost and output.</div></section>
+	   <section class="card efficiencyHeadline reasoning"><div class=efficiencyEyebrow>Reasoning ratio</div><div class="efficiencyValueRow valueWithDelta"><div class="v mono" id=e-reasoning-ratio>--</div><div class=trendDelta id=e-reasoning-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-reasoning-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily reasoning ratio"></svg><div class="efficiencyChartTip chartTip" id=e-reasoning-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-reasoning-status aria-live=polite></span></div><div class=efficiencyCoverage id=e-reasoning-coverage>Reasoning coverage unavailable.</div></section>
+	  </div>
+	  <div class=efficiencySupport>
+	   <section class="card efficiencySupportItem"><div class=label>Context load</div><div class="efficiencySupportValueRow valueWithDelta"><div class="v mono" id=e-context-load>--</div><div class=trendDelta id=e-context-load-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-context-load-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily context load"></svg><div class="efficiencyChartTip chartTip" id=e-context-load-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-context-load-status aria-live=polite></span></div><div class=subline id=e-context-load-note>input tokens per output token</div></section>
+	   <section class="card efficiencySupportItem"><div class=label>Cache hit ratio</div><div class="efficiencySupportValueRow valueWithDelta"><div class="v mono" id=e-cache-hit>--</div><div class=trendDelta id=e-cache-hit-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-cache-hit-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily cache hit ratio"></svg><div class="efficiencyChartTip chartTip" id=e-cache-hit-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-cache-hit-status aria-live=polite></span></div><div class=subline id=e-cache-hit-note>cache-read share of input</div></section>
+	  </div>
+	  <section class=goalsSection id=efficiency-goals aria-labelledby=goals-heading>
+	   <div id=goals-overview>
+	   <div class=goalsHead><h2 id=goals-heading tabindex=-1>Efficiency goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=efficiency-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div>
+	   </div>
+	   <div class=goalDetailView id=goal-detail aria-live=polite hidden></div>
+	  </section>
+	  <section class="card efficiencyModelCard">
+	   <div class=efficiencyModelHead><h2 class=fieldtip tabindex=0 aria-description="Statistics only · Compare similar work · no quality judgment." data-tip="Statistics only · Compare similar work · no quality judgment.">By model</h2><div class=efficiencyModelMeta id=e-model-meta></div></div>
+	   <div class=efficiencyTableWrap><table class=tbl id=e-model-table><thead><tr><th aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=model>Model<span class=efficiencySortMark aria-hidden=true></span></button></th><th>App</th><th>Reasoning effort</th><th class=num aria-sort=descending><button class=efficiencySort type=button data-efficiency-sort=cost>Spend<span class=efficiencySortMark aria-hidden=true>↓</span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=output_per_dollar>Output / $<span class=efficiencySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=reasoning_ratio>Reasoning<span class=efficiencySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=context_load>Context load<span class=efficiencySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=cache_hit_ratio>Cache hit<span class=efficiencySortMark aria-hidden=true></span></button></th></tr></thead><tbody></tbody></table></div>
+		  </section>
+	 </div>
+	 <div class=view id=view-work>
+	  <div class="spectrumPageHeadFrame hasPageActions">
+	   <div class="efficiencyHead spectrumPageHead" data-page-signal=work>
+	    <div class=spectrumPageHeadCopy><h1>Work</h1><p class=spectrumPageSubtitle>What the spend went into.</p></div>
+	   </div>
+	   <div class=spectrumPageActions><div class=modelControls>
+	    <label class=filterControl><span>Project</span><select class=filterSelect id=w-project aria-label="Work project filter"><option value="">All projects</option></select></label>
+	    <label class=filterControl><span>App</span><select class=filterSelect id=w-runtime aria-label="Work app filter"><option value="">All apps</option></select></label>
+	    <label class=filterControl><span>History</span><select class=filterSelect id=w-months aria-label="Work history range"><option value=1d>1 day</option><option value=7d>1 week</option><option value=30d>1 month</option><option value=month>Month</option><option value=3>3 months</option><option value=6 selected>6 months</option><option value=12>12 months</option><option value=0>All history</option></select></label>
+	   </div></div>
+	  </div>
+	  <section class="card workStatus" id=w-status aria-live=polite>
+	   <div class=workStatusMain><span class=workStatusPill id=w-state data-state=disabled>Off</span><div class=workStatusText><strong id=w-status-title>Work insights are off</strong><span id=w-status-detail>Turn on local classification in Settings to label sessions.</span><ol class=workSetupSteps id=w-setup-steps hidden aria-label="Setup steps"><li data-step=ollama>Ollama</li><li data-step=model>Download the model</li><li data-step=prepare>Prepare</li><li data-step=label>Label</li></ol><div class=workSetupBar id=w-setup-bar hidden role=progressbar aria-label="Setup progress" aria-valuemin=0 aria-valuemax=100><i></i></div></div></div>
+	   <div class=workStatusActions>
+	    <label class=workPause hidden id=w-pause-wrap><span class=workSrOnly>Pause work insights</span><select class=filterSelect id=w-pause aria-label="Pause work insights"><option value="">Pause…</option><option value=1h>Pause for 1 hour</option><option value=tomorrow>Pause until tomorrow</option><option value=indefinite>Pause until resumed</option></select></label>
+	    <button class=tbtn id=w-resume type=button hidden>Resume</button>
+    <button class=tbtn id=w-setup-retry type=button hidden>Retry setup</button>
+	    <button class="tbtn go" id=w-turn-on type=button hidden>Turn on Work insights</button>
+    <button class=tbtn id=w-open-settings type=button>Settings</button>
+	   </div>
+	  </section>
+  <section class="card emptyState workProgressNote" id=w-progress-note hidden><strong id=w-progress-title></strong><p id=w-progress-detail></p></section>
+  <section class="card workSizing" id=w-module-sizing>
+   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Spend by request complexity, split by model tier and reasoning effort. Savings are estimates." data-tip="Spend by request complexity, split by model tier and reasoning effort. Savings are estimates.">Right-sizing</h2><div class=subline>Savings · est.</div></div></div>
+   <div class=workSuggestCards id=w-suggest-cards></div>
+   <div class=workEffortModels id=w-effort-models aria-labelledby=w-effort-models-title>
+    <div class=workSubhead><h3 id=w-effort-models-title>Pushback by reasoning effort</h3><label class=filterControl><span>Model</span><select class=filterSelect id=w-effort-model aria-label="Model for pushback by reasoning effort"></select></label></div>
+    <div class=workEffortGrid id=w-effort-grid role=table aria-label="Pushback by complexity and reasoning effort"></div>
+    <p class=workEffortDetail id=w-effort-detail aria-hidden=true></p>
+    <ul class=workEffortVerdicts id=w-effort-verdicts></ul>
+    <p class=workEffortNote id=w-effort-note></p>
+   </div>
+   <details class=workTableToggle id=w-sizing-tables><summary>View as tables</summary>
+    <div class=workTableWrap><table class=workIssues id=w-opportunities></table></div>
+    <div class="workSplit workMixSplit">
+     <div><div class=workSubhead><h3>Model tier</h3><span>share of spend</span></div><div class=workMix id=w-tier-mix></div></div>
+     <div><div class=workSubhead><h3>Reasoning effort</h3><span>share of spend</span></div><div class=workMix id=w-effort-mix></div></div>
+    </div>
+    <div class=workSizingGrid id=w-sizing role=table aria-label="Right-sizing grid"></div>
+    <div class=workTableWrap><table class=tbl id=w-effort-table></table></div>
+   </details>
+  </section>
+	  <section class=goalsSection id=work-goals aria-labelledby=work-goals-heading><div class=goalsHead><h2 id=work-goals-heading tabindex=-1>Work goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=work-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div></section>
+	  <section class="card workBreakdown" id=w-module-breakdown>
+	   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="One row per kind of work. Spend is each request's share of its session's cost. Task outcomes count tasks with a labeled follow-up: accepted, recovered after pushback, ended on pushback, or unclear. Agent : human is model calls (agent turns) per message you typed (human turn). Pushback is how often your next message pushed back. Best and worst model have the least and most pushback among models with 20 or more labeled follow-ups and 3 sessions. Labels are local-model estimates. Select a heading to sort, a row to open its sessions." data-tip="One row per kind of work. Spend is each request's share of its session's cost. Task outcomes count tasks with a labeled follow-up: accepted, recovered after pushback, ended on pushback, or unclear. Agent : human is model calls (agent turns) per message you typed (human turn). Pushback is how often your next message pushed back. Best and worst model have the least and most pushback among models with 20 or more labeled follow-ups and 3 sessions. Labels are local-model estimates. Select a heading to sort, a row to open its sessions.">Work breakdown</h2><div class=subline id=w-breakdown-note></div></div>
+	    <label class=filterControl><span>Model</span><select class=filterSelect id=w-breakdown-model aria-label="Work breakdown model"><option value="">All models</option></select></label></div>
+	   <div class=workTableWrap><table class="tbl workBreakdownTable" id=w-breakdown-table></table></div>
+	   <div class=workFootnote id=w-breakdown-foot></div>
+	  </section>
+	  <section class="card workRhythm" id=w-module-rhythm>
+	   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="When sessions started in this period, in this Mac's local time, and how often follow-ups pushed back at each time of day." data-tip="When sessions started in this period, in this Mac's local time, and how often follow-ups pushed back at each time of day.">When you work</h2><div class=subline id=w-rhythm-note></div></div></div>
+	   <div class=workSplit>
+	    <div><div class=workSubhead><h3>Session starts</h3><span>local time</span></div><div class=workHeat id=w-heat role=img aria-label="Session starts by weekday and hour"></div></div>
+	    <div><div class=workSubhead><h3>Pushback by time of day</h3><span>share of follow-ups</span></div><div class=workBandList id=w-bands></div><div class=workFootnote id=w-band-note></div></div>
+	   </div>
+	  </section>
+	  <div class=workTrendPair>
+	  <section class="card workRework" id=w-module-rework>
+	    <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Share of labeled follow-up turns where you pushed back on the previous work, per week (per day for short ranges). Hollow points have fewer than 20 labeled turns." data-tip="Share of labeled follow-up turns where you pushed back on the previous work, per week (per day for short ranges). Hollow points have fewer than 20 labeled turns.">Pushback over time</h2><div class=subline id=w-rework-note></div></div>
+	     <label class=filterControl><span>Model</span><select class=filterSelect id=w-rework-model aria-label="Pushback trend model"><option value="">All models</option></select></label></div>
+	    <div class=workTrendWrap><svg class=workTrend id=w-rework-trend viewBox="0 0 560 330" role=img aria-label="Pushback rate over time"></svg></div>
+	  </section>
+	   <section class="card workRework" id=w-module-agent-trend>
+	    <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Agent turns (model calls) per human turn (message you typed), per week (per day for short ranges). Only apps that split model calls by request count. Hollow points have fewer than 20 human turns. Not a score." data-tip="Agent turns (model calls) per human turn (message you typed), per week (per day for short ranges). Only apps that split model calls by request count. Hollow points have fewer than 20 human turns. Not a score.">Agent : human over time</h2><div class=subline id=w-agent-note></div></div>
+	     <label class=filterControl><span>Model</span><select class=filterSelect id=w-agent-model aria-label="Agent : human trend model"><option value="">All models</option></select></label></div>
+	    <div class=workTrendWrap><svg class=workTrend id=w-agent-trend viewBox="0 0 560 260" role=img aria-label="Agent turns per human turn over time"></svg></div>
+	   </section>
+	  </div>
+	  <section class="card workFit" id=w-module-fit>
+   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Faded pushback meters have fewer than 20 labeled follow-up turns." data-tip="Faded pushback meters have fewer than 20 labeled follow-up turns.">Model choices</h2><div class=subline>Top models by spend</div></div></div>
+   <div class=workTableWrap><table class=workScore id=w-scorecard></table></div>
+   <details class=workTableToggle><summary>By kind of work</summary><div class=workTableWrap><table class=tbl id=w-fit-table></table></div></details>
+  </section>
+	  <section class="card workTagsCard" id=w-module-tags>
+	   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Tags are worked out from each session's cost, active time, subagents, labels, and how it ended. A session can have several. Select a tag to open its sessions." data-tip="Tags are worked out from each session's cost, active time, subagents, labels, and how it ended. A session can have several. Select a tag to open its sessions.">Session tags</h2><div class=subline id=w-tags-note></div></div></div>
+	   <div class=workTagGrid id=w-tags></div>
+	  </section>
+  <div class=efficiencyEvidence><span class=fieldtip tabindex=0 aria-description="Sessions started in this period. Session text goes only to Ollama on this machine; Token Meter stores only labels and counts. Select any bar or row to open its sessions." data-tip="Sessions started in this period. Session text goes only to Ollama on this machine; Token Meter stores only labels and counts. Select any bar or row to open its sessions.">Labels are local estimates · text goes only to local Ollama</span></div>
+	 </div>
diff --git a/dashboard/markup/git-learn-tools.html b/dashboard/markup/git-learn-tools.html
new file mode 100644
index 00000000..9cfe195f
--- /dev/null
+++ b/dashboard/markup/git-learn-tools.html
@@ -0,0 +1,108 @@
+	 <div class=view id=view-git>
+	  <div class="spectrumPageHeadFrame hasPageActions">
+	   <div class="efficiencyHead spectrumPageHead" data-page-signal=git>
+	    <div class=spectrumPageHeadCopy><h1>Git</h1><p class=spectrumPageSubtitle>Pushed code &times; covered spend &middot; <span class=fieldtip id=d-caveat tabindex=0 aria-description="Local Git only: hashed keys and line counts, never filenames or messages. Spend is estimated. Few lines make ratios noisy. Not a quality score." data-tip="Local Git only: hashed keys and line counts, never filenames or messages. Spend is estimated. Few lines make ratios noisy. Not a quality score.">local Git only</span></p></div>
+	   </div>
+	   <div class=spectrumPageActions><div class="modelControls deliveryControls">
+	    <label class=filterControl><span>Project</span><select class=filterSelect id=d-project aria-label="Git project filter"><option value="">All projects</option></select></label>
+	    <label class=filterControl><span>History</span><select class=filterSelect id=d-range aria-label="Git history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option></select></label>
+	   </div></div>
+	  </div>
+	  <section class="card deliveryOverview" aria-label="Git overview">
+	   <div class=deliveryOverviewHead>
+	    <div><div class=deliveryEyebrow><span id=d-period-label>7 days</span></div><h2 id=d-comparison>No comparable prior period</h2></div>
+	    <button class="deliveryCoverageState partial" id=d-coverage type=button aria-live=polite aria-expanded=false aria-controls=d-evidence-panel>Scanning local Git</button>
+	   </div>
+	   <div class=deliveryMetricGrid>
+	    <div class=deliveryMetric><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Text lines added plus deleted in successful pushes. Binary files excluded." data-tip="Text lines added plus deleted in successful pushes. Binary files excluded.">Pushed lines</div><div class=valueWithDelta><div class=deliveryMetricValue id=d-code-pushed>--</div><div class=trendDelta id=d-code-pushed-change data-direction="" hidden><strong>No comparable prior period</strong><span></span></div></div><div class=deliveryMetricMeta><b id=d-added>--</b> added <span aria-hidden=true>&middot;</span> <b id=d-deleted>--</b> deleted</div></div>
+	    <div class=deliveryMetric><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Covered spend per 1,000 pushed lines, same projects and period." data-tip="Covered spend per 1,000 pushed lines, same projects and period.">Spend / 1K</div><div class=valueWithDelta><div class=deliveryMetricValue id=d-spend-lines>--</div><div class=trendDelta id=d-spend-lines-change data-direction="" hidden><strong>No comparable prior period</strong><span></span></div></div><div class=deliveryMetricMeta id=d-spend-note>Waiting for coverage.</div></div>
+	    <div class=deliveryMetric><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Pushed lines per 1K covered output tokens, same projects and period. Output includes reasoning where reported." data-tip="Pushed lines per 1K covered output tokens, same projects and period. Output includes reasoning where reported.">Push yield</div><div class=valueWithDelta><div class=deliveryMetricValue id=d-push-yield>--</div><div class=trendDelta id=d-push-yield-change data-direction="" hidden><strong>No comparable prior period</strong><span></span></div></div><div class=deliveryMetricMeta id=d-push-yield-note>Waiting for output tokens.</div></div>
+    <div class="deliveryMetric deliveryCoverageMetric"><div class=deliveryMetricTop><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Share of spend from projects with both cost and Git evidence." data-tip="Share of spend from projects with both cost and Git evidence.">Spend coverage</div><strong id=d-coverage-percent>--</strong></div><div class=deliveryCoverageBar id=d-coverage-bar role=progressbar aria-label="Share of selected-period spend with comparable Git evidence" aria-valuemin=0 aria-valuemax=100 aria-valuetext="Spend coverage unavailable"><i aria-hidden=true></i></div></div>
+	   </div>
+	   <div class=deliveryEvidenceStrip aria-label="Git evidence details">
+	    <div class=deliveryEvidenceItem><span>Push days</span><strong id=d-active-days>--</strong></div>
+	    <div class=deliveryEvidenceItem><span class="fieldtip" tabindex=0 aria-description="Your non-merge commits in successful pushes." data-tip="Your non-merge commits in successful pushes.">Commits</span><strong id=d-commits>--</strong></div>
+	    <div class=deliveryEvidenceItem><span>Repositories</span><strong id=d-repo-evidence>--</strong></div>
+	    <div class=deliveryEvidenceItem><span>Comparable</span><strong id=d-comparable-evidence>--</strong></div>
+	    <div class=deliveryEvidenceItem><span class="fieldtip" tabindex=0 aria-description="Deleted share of pushed lines. Deletions are normal editing, not defects." data-tip="Deleted share of pushed lines. Deletions are normal editing, not defects.">Deleted share</span><strong id=d-rework>--</strong></div>
+	   </div>
+	  </section>
+	  <section class="card deliveryEvidencePanel" id=d-evidence-panel hidden aria-labelledby=d-evidence-title>
+   <div class=deliveryEvidenceHead><div><h2 class=fieldtip id=d-evidence-title tabindex=0 aria-description="Period-specific spend and Git coverage; unavailable is not zero." data-tip="Period-specific spend and Git coverage; unavailable is not zero.">Evidence coverage</h2></div><button class=deliveryEvidenceClose id=d-evidence-close type=button aria-label="Close evidence coverage">&times;</button></div>
+   <div class=deliveryEvidenceSummary><strong id=d-evidence-spend>--</strong><span>of spend has Git evidence</span></div>
+	   <div class=deliveryEvidenceChoices>
+	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=comparable><span>Comparable</span><strong id=d-evidence-count-comparable>--</strong></button>
+	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=spend_only><span>Spend only</span><strong id=d-evidence-count-spend>--</strong></button>
+	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=git_only><span>Git only</span><strong id=d-evidence-count-git>--</strong></button>
+	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=unavailable><span>No period evidence</span><strong id=d-evidence-count-unavailable>--</strong></button>
+	   </div>
+	   <div class=deliveryEvidenceMeta><span class="fieldtip" id=d-evidence-ratio tabindex=0 aria-description="Ratios require overlapping spend and Git evidence." data-tip="Ratios require overlapping spend and Git evidence.">Waiting for overlap</span><span id=d-evidence-freshness>Git scan pending.</span></div>
+	  </section>
+	  <section class=goalsSection id=git-goals aria-labelledby=git-goals-heading><div class=goalsHead><h2 id=git-goals-heading tabindex=-1>Delivery goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=git-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div></section>
+	  <section class="card deliveryVisual">
+	   <div class=deliveryVisualHead><div><h2 class=fieldtip tabindex=0 aria-description="Added + deleted text lines per day. Select a day for spend." data-tip="Added + deleted text lines per day. Select a day for spend.">Code pushed by day</h2></div><div class=deliveryLegend aria-label="Git chart legend"><span><i></i>Added</span><span><i class=deleted></i>Deleted</span></div></div>
+	   <div class=deliveryMobileScrollHint aria-hidden=true>Swipe or scroll to explore &rarr;</div>
+	   <div class=deliveryChartViewport><div class=deliveryChartWrap id=d-chart-wrap><svg class=deliveryChart id=d-daily-chart viewBox="0 0 1040 310" preserveAspectRatio=none role=img aria-label="Daily pushed text lines"></svg><div class=deliveryHitGrid id=d-chart-hits aria-label="Daily Git values"></div><div class="deliveryChartTip chartTip" id=d-chart-tip role=tooltip hidden></div></div></div>
+	   <div class=deliveryDayInspector id=d-day-inspector hidden aria-live=polite><div class=deliveryDayIdentity><span>Selected day</span><strong id=d-day-title>--</strong><small id=d-day-note></small></div><div class=deliveryDayMetrics id=d-day-metrics></div><div class=deliveryDayActions><button id=d-day-prev type=button>&larr; Previous</button><button id=d-day-next type=button>Next &rarr;</button><button class=deliveryDayClose id=d-day-close type=button aria-label="Close selected day">&times;</button></div></div>
+	  </section>
+	  <section class=deliveryInsightSection aria-labelledby=d-insight-title>
+	   <div class=deliveryInsightHead><div><h2 class=fieldtip id=d-insight-title tabindex=0 aria-description="Conversion, typical days, and outliers. Statistics only · no quality judgment." data-tip="Conversion, typical days, and outliers. Statistics only · no quality judgment.">Delivery economics</h2></div></div>
+	   <div class=deliveryInsightGrid>
+    <section class="card deliverySignalCard"><div class=deliveryInsightCardHead><div><h3 class=fieldtip tabindex=0 aria-description="Ranked local Git and covered-spend observations." data-tip="Ranked local Git and covered-spend observations.">Signals</h3></div></div><div class=deliverySignalList id=d-signals aria-live=polite><div class="deliverySignalEmpty emptyState">Reading local Git evidence&hellip;</div></div></section>
+    <section class="card deliveryShapeCard"><div class=deliveryInsightCardHead><div><h3 class=fieldtip tabindex=0 aria-description="Median, range, and high day · ratios require 50+ pushed lines." data-tip="Median, range, and high day · ratios require 50+ pushed lines.">Daily shape</h3></div></div><div class=deliveryShape id=d-shape><div class="deliveryShapeEmpty emptyState">Reading daily distributions&hellip;</div></div></section>
+	   </div>
+	  </section>
+	  <section class="card deliveryModels" aria-labelledby=d-model-title>
+	   <div class=deliveryProjectHead><h2 class=fieldtip id=d-model-title tabindex=0 aria-description="Estimate. Each project&rsquo;s pushed lines are split by each model&rsquo;s share of its covered spend." data-tip="Estimate. Each project&rsquo;s pushed lines are split by each model&rsquo;s share of its covered spend.">Code by model</h2><div class=deliveryModelNote id=d-model-note></div></div>
+	   <div class=deliveryTableWrap><table class=tbl id=d-model-table><thead><tr><th aria-sort=none><button class=deliverySort type=button data-delivery-model-sort=model>Model<span class=deliverySortMark aria-hidden=true></span></button></th><th>App</th><th>Effort</th><th class=num aria-sort=descending><button class="deliverySort fieldtip" type=button data-delivery-model-sort=covered_cost data-tip="Covered spend: estimated spend from sessions with cost evidence in these projects." aria-description="Covered spend: estimated spend from sessions with cost evidence in these projects.">Spend<span class=deliverySortMark aria-hidden=true>&darr;</span></button></th><th class=num aria-sort=none><button class=deliverySort type=button data-delivery-model-sort=attributed_lines>Est. lines<span class=deliverySortMark aria-hidden=true></span></button></th></tr></thead><tbody></tbody></table></div>
+		  </section>
+	  <section class="card deliveryProjects">
+	   <div class=deliveryProjectHead><h2>Projects</h2><div class=deliveryProjectControls><label class=deliveryEvidenceFilter><span>Evidence</span><select class=filterSelect id=d-evidence-filter aria-label="Filter Git projects by evidence"><option value=all>All projects</option><option value=comparable>Comparable</option><option value=spend_only>Spend only</option><option value=git_only>Git only</option><option value=unavailable>No period evidence</option></select></label><label class=deliveryMobileSort><span>Sort</span><select class=filterSelect id=d-mobile-sort aria-label="Sort Git projects"><option value=covered_cost:desc>Spend high–low</option><option value=covered_cost:asc>Spend low–high</option><option value=changed_lines:desc>Lines high–low</option><option value=changed_lines:asc>Lines low–high</option><option value=spend_per_1k:asc>Spend / 1K low–high</option><option value=spend_per_1k:desc>Spend / 1K high–low</option><option value=project:asc>Project A–Z</option><option value=project:desc>Project Z–A</option></select></label></div></div>
+	   <div class=deliveryTableWrap><table class=tbl id=d-project-table><thead><tr><th aria-sort=none><button class=deliverySort type=button data-delivery-sort=project>Project<span class=deliverySortMark aria-hidden=true></span></button></th><th class=num aria-sort=descending><button class="deliverySort fieldtip" type=button data-delivery-sort=covered_cost data-tip="Covered spend: estimated spend from sessions with cost evidence in these projects." aria-description="Covered spend: estimated spend from sessions with cost evidence in these projects.">Spend<span class=deliverySortMark aria-hidden=true>&darr;</span></button></th><th class=num aria-sort=none><button class=deliverySort type=button data-delivery-sort=changed_lines>Pushed lines<span class=deliverySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=deliverySort type=button data-delivery-sort=spend_per_1k>Spend / 1K<span class=deliverySortMark aria-hidden=true></span></button></th></tr></thead><tbody></tbody></table></div>
+		  </section>
+	 </div>
+
+	 <div class=view id=view-learn>
+  <div class="spectrumPageHeadFrame hasPageActions"><div class="learnHead spectrumPageHead" data-page-signal=learn><div class=spectrumPageHeadCopy><h1>Learn</h1><p class=spectrumPageSubtitle>Spend tokens like money. Measure what you get back.</p></div></div><div class=spectrumPageActions><button class=tbtn id=learn-play type=button>Play as full screen</button></div></div>
+  <div class="deck deckInline" id=learn-deck data-deck-host=learn></div>
+	 </div>
+
+	 <div class=view id=view-capabilities>
+  <div class=spectrumPageHeadFrame>
+   <header class="capPageHead spectrumPageHead" data-page-signal=capabilities>
+    <div class=spectrumPageHeadCopy><h1>Tools</h1><p class=spectrumPageSubtitle>Tools, MCP servers, and skills.</p></div>
+   </header>
+  </div>
+  <section class="card capStats" aria-label="Capability overview">
+   <button class=capStat type=button data-cap-jump=tool aria-label="Show Tools in the capability inventory"><span class=capStatLabel>Tools</span><strong id=c-stat-tools>&mdash;</strong><span class=capStatDetail id=c-stat-tools-detail>Waiting for evidence</span></button>
+   <button class=capStat type=button data-cap-jump=mcp aria-label="Show MCP servers in the capability inventory"><span class=capStatLabel>MCP servers</span><strong id=c-stat-mcps>&mdash;</strong><span class=capStatDetail id=c-stat-mcps-detail>Waiting for evidence</span></button>
+   <button class=capStat type=button data-cap-jump=skill aria-label="Show Skills in the capability inventory"><span class=capStatLabel>Skills</span><strong id=c-stat-skills>&mdash;</strong><span class=capStatDetail id=c-stat-skills-detail>Waiting for evidence</span></button>
+  </section>
+  <section class="card capReviewQueue" id=c-review-queue aria-labelledby=c-review-title>
+   <div class=capQueueHead>
+    <div><h2 id=c-review-title>Checking review candidates</h2><div class=capQueueDetail id=c-review-detail></div></div>
+    <span class=capQueueCount id=c-review-count>Waiting for evidence</span>
+   </div>
+   <div class=capReviewList id=c-review-list aria-live=polite><div class=capQueueLoading>Reading local capability evidence&hellip;</div></div>
+   <div class=capSelectionBar id=c-selection-bar hidden><span id=c-selection-count>0 selected</span><button class=tbtn id=c-clear-selection type=button>Clear selection</button><button class="tbtn danger" id=c-disable-selected type=button disabled>Disable selected&hellip;</button></div>
+  </section>
+  <section class="card capInventory" id=c-inventory aria-labelledby=c-inventory-title>
+   <div class=capInventoryHead><span class=capInventorySummary><h2 id=c-inventory-title tabindex=-1>All capabilities</h2></span><span class=capInventoryCount id=c-inventory-count>Waiting for inventory</span></div>
+   <div class=capInventoryBody>
+    <section class=capCatalog aria-label="Prompt-load evidence">
+     <div class=capCatalogHead><span><b class=fieldtip tabindex=0 title="Useful eager: schema loaded up front and called. Unused eager: schema loaded up front but not called. Deferred: schema kept out of the initial prompt. Default and read-only entries remain included as evidence." data-tip="Useful eager: schema loaded up front and called. Unused eager: schema loaded up front but not called. Deferred: schema kept out of the initial prompt. Default and read-only entries remain included as evidence.">Prompt-load evidence</b><small>Tool definitions in the initial prompt</small></span><span class=subline id=c-def-note>Waiting for evidence</span></div>
+     <div class=capCatalogBody><div class=defBar id=c-def-chart></div><div class=legend id=c-def-legend></div></div>
+    </section>
+    <div class=capFilters>
+     <label class=capFilterControl><span>Search</span><input class=searchbox id=c-search type=search aria-label="Search installed capabilities" placeholder="Name, source, or runtime"></label>
+     <div class=capFilterControl><span>Type</span><div class="seg sortseg" id=c-type-filter role=group aria-label="Capability type"><button type=button data-ctype=all>All</button><button type=button data-ctype=tool>Tools</button><button type=button data-ctype=mcp>MCPs</button><button type=button data-ctype=skill>Skills</button></div></div>
+     <div class=capFilterControl><span>State</span><div class="seg sortseg" id=c-state-filter role=group aria-label="Evidence and configuration"><button type=button data-cstate=all>All</button><button type=button data-cstate=enabled>Configured on</button><button type=button data-cstate=observed>Observed</button><button type=button data-cstate=unused>No use observed</button></div></div>
+     <label class=capFilterControl><span>Runtime</span><select id=c-runtime-filter aria-label="Capability runtime"><option value=all>All runtimes</option></select></label>
+    </div>
+    <label class=capMobileSort><span>Sort by</span><select id=c-mobile-sort><option value=name:asc>Name A–Z</option><option value=name:desc>Name Z–A</option><option value=use:desc>Most observed</option><option value=use:asc>Least observed</option><option value=last:desc>Recently observed</option><option value=last:asc>Oldest observed</option><option value=runtime:asc>Runtime A–Z</option><option value=state:asc>Configuration A–Z</option><option value=control:asc>Control A–Z</option></select></label>
+    <div class=capFilterStatus><div><span class=hint id=c-filter-count>Loading inventory&hellip;</span><div class=activeFilters id=c-active-filters hidden aria-live=polite></div></div><button class="tbtn clearFilters" id=c-clear-filters type=button hidden>Clear filters</button></div>
+    <div class=capTableWrap><table class=tbl id=c-table><thead><tr><th class=sortable data-csort=name tabindex=0 aria-sort=none>Capability</th><th class=sortable data-csort=type tabindex=0 aria-sort=none>Type</th><th class=sortable data-csort=runtime tabindex=0 aria-sort=none>Runtime / source</th><th class=sortable data-csort=state tabindex=0 aria-sort=none>Configuration</th><th class=sortable data-csort=use tabindex=0 aria-sort=none>Evidence</th><th class=sortable data-csort=last tabindex=0 aria-sort=none>Last observed</th><th class=sortable data-csort=control tabindex=0 aria-sort=none>Control</th></tr></thead><tbody><tr><td colspan=7 class=capEmpty>Loading local capability inventory&hellip;</td></tr></tbody></table></div>
+   </div>
+  </section>
+	 </div>
+
diff --git a/dashboard/markup/settings.html b/dashboard/markup/settings.html
new file mode 100644
index 00000000..8977c221
--- /dev/null
+++ b/dashboard/markup/settings.html
@@ -0,0 +1,169 @@
+	 <div class=view id=view-settings>
+  <div class=spectrumPageHeadFrame><div class="learnHead settingsPageHead spectrumPageHead" data-page-signal=settings><div class=spectrumPageHeadCopy><h1>Settings</h1><p class=spectrumPageSubtitle>Connections, pricing, and updates.</p></div></div></div>
+  <div class=settingsPageLayout>
+   <nav class="card settingsMap" aria-label="Settings sections">
+    <button type=button data-settings-target=appearance-settings><b>Appearance</b></button>
+    <button type=button data-settings-target=agent-access><b>Agent connection</b></button>
+    <button type=button data-settings-target=model-pricing-settings><b>Model pricing</b></button>
+    <button type=button data-settings-target=work-insights-settings><b>Work insights</b></button>
+    <button type=button data-settings-target=delivery-settings><b>Git evidence history</b></button>
+    <button type=button data-settings-target=update-settings><b>Software updates</b></button>
+   </nav>
+   <div class=settingsPageContent>
+   <section class="card pad appearanceSettings" id=appearance-settings>
+    <div class=learnSectionHead><div><h2 class=fieldtip id=appearance-title tabindex=0 aria-description="Provider and status colors stay the same in every theme." data-tip="Provider and status colors stay the same in every theme.">Appearance</h2><div class=subline>Theme for this browser · <kbd>&#8984;K</kbd> → Theme</div></div><span class="agentAccessBadge chip" id=theme-current-badge>Classic</span></div>
+    <div class=themePicker id=theme-picker role=group aria-labelledby=appearance-title></div>
+   </section>
+   <section class="card pad agentAccess" id=agent-access>
+    <div class=agentAccessHead><div><h2 class=fieldtip tabindex=0 aria-description="Give Codex and Claude read-only, on-demand access to numeric Token Meter evidence, and optionally install Token Meter skills that use it. Connections stay local and read-only." data-tip="Give Codex and Claude read-only, on-demand access to numeric Token Meter evidence, and optionally install Token Meter skills that use it. Connections stay local and read-only.">Agent connection</h2></div><a class=tbtn id=agent-skills-learn href="https://github.com/splunk/token-meter/blob/main/agent-skills/README.md" target=_blank rel="noopener noreferrer" aria-label="Learn more about Token Meter skills (opens GitHub in a new tab)">Learn more about skills</a></div>
+    <div class=agentClients id=agent-clients><div class=agentClient><div><div class=agentClientName>Loading connection status</div><div class=agentClientState>Checking local Codex and Claude Code configuration.</div></div></div></div>
+   </section>
+   <section class="card pad settingsLexicon settingsPricing" id=model-pricing-settings>
+    <div class=settingsLexiconHead><div><div class=label>Cost estimates</div><h2 class=fieldtip tabindex=0 aria-description="Edit prices in USD per 1 million tokens. By default, a change starts now and older sessions retain their earlier prices." data-tip="Edit prices in USD per 1 million tokens. By default, a change starts now and older sessions retain their earlier prices.">Model pricing</h2></div><span class="agentAccessBadge chip" id=model-pricing-badge>Loading prices</span></div>
+    <div class=modelPricingProvenance>Built-in rates reviewed <time id=model-pricing-reviewed>—</time><span aria-hidden=true>·</span><span id=model-pricing-sources>Loading sources</span></div>
+    <fieldset class=modelPriceScope id=model-price-scope><legend>Apply to selected models</legend><div class=modelPriceScopeOptions><label><input id=model-price-scope-from-now name=model-price-scope type=radio value=from_now checked><span>From now</span></label><label><input id=model-price-scope-from-date name=model-price-scope type=radio value=from_date><span>From date</span></label><label><input id=model-price-scope-all-history name=model-price-scope type=radio value=all_history><span>All history</span></label></div><label class=modelPriceEffective><span>Effective from</span><input id=model-price-effective-from type=datetime-local disabled aria-label="Model price effective date and time"></label><span id=model-price-selection-count>No models selected</span><span id=model-price-scope-note></span></fieldset>
+    <div class=modelPriceTabs id=model-price-tabs role=tablist aria-label="Model pricing provider"></div>
+    <div class=modelPriceTableWrap id=model-price-table-wrap><table class="tbl modelPriceTable"><thead><tr><th>Select</th><th>Provider</th><th>Model id</th><th class=num>Input</th><th class=num>Output</th><th class=num>Cache write</th><th class=num>Cached input</th></tr></thead><tbody id=model-pricing-rows><tr><td colspan=7 class=modelPricingEmpty>Waiting for dashboard data.</td></tr></tbody></table></div>
+    <form class=modelPriceAdd id=model-price-add-form>
+     <label><span>Provider</span><select id=model-price-provider><option value=claude>Claude</option><option value=codex>Codex / OpenAI</option><option value=cursor>Cursor</option><option value=opencode>OpenCode</option><option value=google>Google Gemini</option></select></label>
+     <label><span>New model id</span><input id=model-price-model autocomplete=off spellcheck=false required maxlength=160 placeholder="model-name-version"></label>
+     <label><span>Input</span><input id=model-price-input type=number min=0 max=1000000 step=any required placeholder=0></label>
+     <label><span>Output</span><input id=model-price-output type=number min=0 max=1000000 step=any required placeholder=0></label>
+     <label><span>Cache write</span><input id=model-price-cache-write type=number min=0 max=1000000 step=any required value=0></label>
+     <label><span>Cached input</span><input id=model-price-cache-read type=number min=0 max=1000000 step=any required value=0></label>
+     <button class=tbtn id=model-price-add type=submit>Add model</button>
+    </form>
+    <div class=modelPricingFooter><span class=settingsStatus id=model-pricing-status role=status aria-live=polite></span><button class=tbtn id=model-price-save-changes type=button disabled>Save models</button></div>
+   </section>
+   <section class="card pad workSettings" id=work-insights-settings hidden>
+    <div class=softwareUpdateHead><div><h2 class=fieldtip tabindex=0 aria-description="A local model labels each session's area, work type, complexity, and pushback so the Work page can show what spend went into. A local model reads the prompts you typed, the last few lines of the assistant reply before each one (to spot pushback), the names of files you uploaded, and the names of the files the agent changed for each request, and it counts the kinds of commands the agent ran. It never reads file contents or tool output. Text goes only to the Ollama address below on this machine, cloud models are refused, and Token Meter stores labels and counts, never text, file names, or commands." data-tip="A local model labels each session's area, work type, complexity, and pushback so the Work page can show what spend went into. A local model reads the prompts you typed, the last few lines of the assistant reply before each one (to spot pushback), the names of files you uploaded, and the names of the files the agent changed for each request, and it counts the kinds of commands the agent ran. It never reads file contents or tool output. Text goes only to the Ollama address below on this machine, cloud models are refused, and Token Meter stores labels and counts, never text, file names, or commands.">Work insights</h2><div class=subline>Reads your prompts and file names with a local Ollama model; stores only labels and counts.</div></div><span class=agentAccessBadge id=work-settings-badge>Off</span></div>
+    <div class=workEnableCta id=work-enable-cta hidden><button class="tbtn go" id=work-enable-button type=button>Turn on Work insights</button><small>Sets up Ollama and Google’s Gemma model in the background. Nothing leaves this Mac.</small></div>
+    <div class=softwareUpdateToggles>
+     <label class=softwareUpdateToggle><input id=work-enabled type=checkbox><span><b>Label sessions with a local model</b></span></label>
+     <label class=softwareUpdateToggle><input id=work-battery type=checkbox checked><span><b>Pause while on battery</b><small>Resumes automatically on power.</small></span></label>
+     <label class=softwareUpdateToggle><input id=work-live-notify type=checkbox checked><span><b>Notify me about live suggestions</b><small>Menu bar notification, one per suggestion per running session.</small></span></label>
+    </div>
+    <div class=workSettingsGrid>
+     <label class=settingsField><span>Model</span><input id=work-model spellcheck=false autocomplete=off maxlength=100></label>
+     <label class=settingsField><span>Ollama URL</span><input id=work-url spellcheck=false autocomplete=off maxlength=120></label>
+     <label class=settingsField><span class=fieldtip tabindex=0 aria-description="Automatic: up to 60 a minute while the CPU is mostly idle and this Mac is plugged in, 5 a minute otherwise." data-tip="Automatic: up to 60 a minute while the CPU is mostly idle and this Mac is plugged in, 5 a minute otherwise.">Pace</span><select class=filterSelect id=work-rate aria-description="Automatic: up to 60 a minute while the CPU is mostly idle and this Mac is plugged in, 5 a minute otherwise."><option value=auto>Automatic (default)</option><option value=5>5 labels / min</option><option value=10>10 labels / min</option><option value=20>20 labels / min</option><option value=40>40 labels / min</option><option value=60>60 labels / min</option></select></label>
+     <label class=settingsField><span>History to label</span><select class=filterSelect id=work-backfill><option value=30>Last 30 days</option><option value=90>Last 90 days</option><option value=365>Last 365 days</option><option value=0>All history</option></select></label>
+    </div>
+    <div class="workSetupHint fieldtip" tabindex=0 aria-description="Turning this on sets everything up in the background: Token Meter installs a pinned Ollama if this Mac doesn’t have one, downloads Google’s Gemma 4 E4B model (about 5 GB, Apache-2.0), adds it to Ollama, and deletes the download. It needs about 11 GB free while it sets up and about 5 GB after, and uses about 5.5 GB of memory while it labels." data-tip="Turning this on sets everything up in the background: Token Meter installs a pinned Ollama if this Mac doesn’t have one, downloads Google’s Gemma 4 E4B model (about 5 GB, Apache-2.0), adds it to Ollama, and deletes the download. It needs about 11 GB free while it sets up and about 5 GB after, and uses about 5.5 GB of memory while it labels.">Needs ~11 GB free to set up, ~5 GB after, ~5.5 GB RAM while labeling.</div>
+    <div class=workAreasHead><h3>Areas</h3><span class=subline id=work-areas-count></span></div>
+    <div class=workAreas id=work-areas></div>
+    <div class=workSettingsActions><div class=workActionGroup><button class=tbtn id=work-area-add type=button>Add area</button><button class="tbtn clearFilters" id=work-areas-reset type=button>Restore default areas</button></div><span class=settingsStatus id=work-settings-status aria-live=polite></span><button class=tbtn id=work-save type=button disabled>Save changes</button></div>
+    <div class="workActionGroup workSettingsManage"><label class=workPause><span class=workSrOnly>Pause work insights</span><select class=filterSelect id=work-pause aria-label="Pause work insights"><option value="">Pause…</option><option value=1h>Pause for 1 hour</option><option value=tomorrow>Pause until tomorrow</option><option value=indefinite>Pause until resumed</option><option value=resume>Resume</option></select></label><button class="tbtn clearFilters" id=work-clear type=button>Delete all labels</button></div>
+   </section>
+   <section class="card pad" id=delivery-settings>
+    <div class=learnSectionHead><div><h2 class=fieldtip tabindex=0 aria-description="Reads local pushes every five minutes. Clear starts a new baseline; older reflogs stay excluded. Token Meter stores these totals locally." data-tip="Reads local pushes every five minutes. Clear starts a new baseline; older reflogs stay excluded. Token Meter stores these totals locally.">Git evidence history</h2><div class=subline>Scans local pushes every 5 min.</div></div><button class="tbtn clearFilters" id=delivery-clear type=button>Clear Git evidence</button></div>
+    <div class="settingsStatus deliveryClearStatus" id=delivery-clear-status></div>
+   </section>
+   <section class="card pad" id=menubar-settings>
+    <div class=learnSectionHead><div><h2 class=fieldtip tabindex=0 aria-description="Shows the prompt-cache timer next to the cost in the menu bar title. Session cards and the menu bar popover always show it. The menu bar app reads this setting." data-tip="Shows the prompt-cache timer next to the cost in the menu bar title. Session cards and the menu bar popover always show it. The menu bar app reads this setting.">Menu bar</h2><div class=subline>Cache timer in the menu bar title.</div></div><div class=seg id=menubar-cache-timer role=group aria-label="Cache timer in menu bar"><button type=button data-cache-timer=always aria-pressed=true>Always</button><button type=button data-cache-timer=final2 aria-pressed=false>Last 2 min</button><button type=button data-cache-timer=off aria-pressed=false>Off</button></div></div>
+    <div class=settingsStatus id=menubar-settings-status aria-live=polite></div>
+   </section>
+   <section class="card pad softwareUpdates" id=update-settings>
+    <div class=softwareUpdateHead><div><h2 class=fieldtip tabindex=0 aria-description="Checks fetch revision metadata only. Safe updates from the tracked main branch can install automatically without opening the dashboard. Enabled by default: Token Meter checks once at startup, then every 10 minutes while it is running, and installs safe updates automatically." data-tip="Checks fetch revision metadata only. Safe updates from the tracked main branch can install automatically without opening the dashboard. Enabled by default: Token Meter checks once at startup, then every 10 minutes while it is running, and installs safe updates automatically.">Software updates</h2></div><span class="agentAccessBadge chip" id=update-settings-badge>Waiting</span></div>
+    <div class=softwareUpdateToggles>
+     <label class=softwareUpdateToggle><input id=update-enabled type=checkbox checked><span><b>Check for updates every 10 minutes</b><small>Off also disables auto-install.</small></span></label>
+     <label class=softwareUpdateToggle><input id=update-auto-install type=checkbox checked><span><b>Automatically install available updates</b><small>Checks continue when off.</small></span></label>
+    </div>
+    <div class=softwareUpdateActions><button class=tbtn id=update-check type=button>Check now</button><span class=settingsStatus id=update-settings-status>Waiting for the first update check.</span><span class=softwareUpdateMeta id=update-settings-meta></span></div>
+   </section>
+   </div>
+  </div>
+	 </div>
+</div>
+<button class="deckPrimary tourReturn" id=tour-return type=button hidden><span class=tourReturnArrow aria-hidden=true>←</span><span id=tour-return-label>Back to the tour</span></button>
+<dialog class=welcome id=welcome-dialog aria-modal=true aria-labelledby=welcome-label aria-describedby=welcome-deck-status>
+ <header class=welcomeTop><div class=welcomeBrand><b id=welcome-label>Welcome to Token Meter</b></div><div class=welcomeTopActions><button class=welcomeSkip id=welcome-skip type=button>Skip tour</button><button class=welcomeClose id=welcome-close type=button aria-label="Close welcome" title="Close (Esc)"><span aria-hidden=true>&#10005;</span></button></div></header>
+ <div class=deck id=welcome-deck data-deck-host=welcome></div>
+</dialog>
+<dialog class=commandPalette id=command-palette aria-labelledby=command-title>
+ <div class=commandShell>
+  <div class=commandSearch><svg viewBox="0 0 24 24" fill=none stroke-width=2 stroke-linecap=round aria-hidden=true><circle cx=11 cy=11 r=7></circle><path d="m20 20-4-4"></path></svg><input id=command-search type=search role=combobox aria-label="Search commands" aria-autocomplete=list aria-expanded=true aria-controls=command-list placeholder="Search views and actions" autocomplete=off spellcheck=false><kbd>ESC</kbd></div>
+  <div class=commandList id=command-list role=listbox aria-label="Available commands"></div>
+  <div class=commandFooter><span id=command-title><kbd>&#8984;K</kbd> opens this anywhere</span><span><kbd>&uarr;</kbd><kbd>&darr;</kbd> move <kbd>&crarr;</kbd> open</span></div>
+ </div>
+</dialog>
+<dialog class="mcpDialog goalsDialog" id=goals-dialog aria-labelledby=goals-form-heading>
+	   <form class=goalsForm id=goals-form novalidate>
+	    <h3 id=goals-form-heading tabindex=-1>New goal</h3>
+	    <div class=goalsFormBody>
+	    <div class=goalsFields>
+	    <div class="goalsStep goalsWide"><span id=goals-metric-label>Metric</span><div class=goalsOptions id=goals-metric-options role=group aria-labelledby=goals-metric-label></div><select id=goals-metric hidden></select></div>
+	    <label class=goalsStep id=goals-app-field>App<select class=filterSelect id=goals-app></select></label>
+	    <label class=goalsStep id=goals-work-field hidden>Kind of work<select class=filterSelect id=goals-work-type></select></label>
+	    <div class=goalsStep id=goals-models-field><span>Models</span><details class=modelPicker id=goals-model-picker><summary aria-label="Choose models for this goal"><span id=goals-model-summary>All models</span></summary><div class=modelPickerMenu id=goals-model-menu><label class=goalsModelSearch id=goals-model-search-field hidden><input id=goals-model-search type=search maxlength=120 autocomplete=off placeholder="Find a model" aria-label="Find a model"><small class=goalsHelp id=goals-model-note></small></label><div id=goals-model-options role=group aria-label="Models for this goal"></div></div></details></div>
+	    <label class=goalsStep for=goals-period>Period<select class=filterSelect id=goals-period><option value=today>Today</option><option value=week>This week</option><option value=month>This month</option><option value=next7>Next 7 days</option><option value=next30>Next 30 days</option><option value=next90>Next 90 days</option><option value=custom>Custom dates</option></select></label>
+	    <div class="goalsStep goalsDates goalsWide" id=goals-dates hidden><label>Start<input id=goals-start type=date></label><label>End<input id=goals-end type=date></label></div>
+	    <fieldset class="goalsStep goalsWide"><legend>Target</legend><div class=goalsOptions id=goals-options role=group aria-label="Target"></div>
+	     <div class=goalsCustom id=goals-custom hidden><select class=filterSelect id=goals-comparison aria-label="Direction"><option value="">Direction</option><option value=at_most>At most</option><option value=at_least>At least</option><option value=between hidden>Between</option></select><input id=goals-target type=number min=0 step=any aria-label="Target value"><input id=goals-target-high type=number min=0 step=any aria-label="Upper target value" hidden></div><p class=goalsHelp id=goals-target-note hidden></p></fieldset>
+	    <label class="goalsStep goalsSpan2">Name<input id=goals-title maxlength=100></label>
+	    <label class=goalsRepeat id=goals-repeat-field><input type=checkbox id=goals-repeat> Repeat <span id=goals-repeat-unit>monthly</span></label>
+	    </div>
+	    <aside class=goalPreview id=goals-preview aria-live=polite aria-label="Goal preview"></aside>
+	    </div>
+	    <div class=goalsFormActions><div class=goalsFormError id=goals-form-error role=alert hidden></div><button class=tbtn type=button id=goals-cancel>Cancel</button><button class=tbtn type=submit id=goals-save>Save goal</button></div>
+	   </form>
+</dialog>
+<dialog class=mcpDialog id=cap-dialog aria-labelledby=cap-dialog-title aria-describedby=cap-dialog-sub>
+ <div class=inner>
+  <h3 id=cap-dialog-title>Change skill pack?</h3>
+  <div class=subline id=cap-dialog-sub></div>
+  <div class=evidence id=cap-dialog-evidence></div>
+  <div class=label>Exact control</div>
+  <code id=cap-dialog-control></code>
+  <div class=subline id=cap-dialog-setting></div>
+  <div class=actions><button class=tbtn id=cap-cancel>Cancel</button><button class=tbtn id=cap-confirm>Confirm</button></div>
+ </div>
+</dialog>
+<dialog class=mcpDialog id=bulk-dialog aria-labelledby=bulk-dialog-title aria-describedby=bulk-dialog-sub>
+ <div class=inner>
+  <h3 id=bulk-dialog-title>Disable selected skill packs?</h3>
+  <div class=subline id=bulk-dialog-sub></div>
+  <div class=evidence id=bulk-dialog-evidence></div>
+  <div class=label>Exact controls</div>
+  <code class=bulkControls id=bulk-dialog-controls></code>
+  <div class=subline>Only selected current review candidates are accepted. MCP servers, built-ins, standalone skills, used groups, and runtime-managed packs are excluded. Successful changes require restarting the IDE or agent.</div>
+  <div class=actions><button class=tbtn id=bulk-cancel>Cancel</button><button class="tbtn danger" id=bulk-confirm>Disable selected</button></div>
+ </div>
+</dialog>
+<dialog class=mcpDialog id=agent-dialog>
+ <div class=inner>
+  <h3 id=agent-dialog-title>Connect agent?</h3>
+  <div class=subline id=agent-dialog-sub></div>
+  <div class=evidence id=agent-dialog-evidence></div>
+  <div class=label id=agent-dialog-command-label>Exact local command</div>
+  <code class=agentCommand id=agent-dialog-command></code>
+  <div class=subline id=agent-dialog-note>Only Token Meter&rsquo;s exact <code>tokenmeter</code> entry is managed. Start a new agent session after the change.</div>
+  <div class=actions><button class=tbtn id=agent-cancel>Cancel</button><button class=tbtn id=agent-confirm>Confirm</button></div>
+ </div>
+</dialog>
+<dialog class=mcpDialog id=session-delete-dialog>
+ <div class=inner>
+  <h3>Delete session?</h3>
+  <div class=subline id=session-delete-sub></div>
+  <div class=evidence id=session-delete-evidence></div>
+  <div class=label>Session</div>
+  <code id=session-delete-id></code>
+  <div class=subline id=session-delete-note></div>
+  <div class=actions><button class=tbtn id=session-delete-cancel>Cancel</button><button class="tbtn danger" id=session-delete-confirm>Move to Trash</button></div>
+ </div>
+</dialog>
+<dialog class=mcpDialog id=session-model-identity-dialog aria-labelledby=session-model-identity-title aria-describedby=session-model-identity-note>
+ <div class=inner>
+  <h3 id=session-model-identity-title>Assign model to this session</h3>
+  <div class=subline id=session-model-identity-sub></div>
+  <div class=evidence id=session-model-identity-evidence></div>
+  <label class=settingsField><span id=session-model-identity-model-label>Codex / OpenAI model ID</span><input id=session-model-identity-model autocomplete=off spellcheck=false maxlength=160 placeholder="gpt-model-version" list=session-model-identity-candidates></label>
+  <datalist id=session-model-identity-candidates></datalist>
+  <div class=subline id=session-model-identity-note>This affects only this saved session. It does not change model prices; configure a model rate separately in Settings → Model pricing.</div>
+  <div class=actions><button class="tbtn danger" id=session-model-identity-remove type=button hidden>Clear assignment</button><button class=tbtn id=session-model-identity-cancel type=button>Cancel</button><button class=tbtn id=session-model-identity-save type=button>Save model</button></div>
+ </div>
+</dialog>
+<button class=updateNotice id=update-notice type=button hidden>New update available</button>
+<div class=toastbox id=toastbox></div>
+
+<script>
diff --git a/dashboard/markup/shell.html b/dashboard/markup/shell.html
new file mode 100644
index 00000000..e79d65ff
--- /dev/null
+++ b/dashboard/markup/shell.html
@@ -0,0 +1,369 @@
+</style></head><body class=spectrumApp>
+<!--
+THESIS: Sessions are live instruments, not a generic grid of dark cards.
+OWN-WORLD: Token Meter ink, cyan and sky light, restrained violet and orange accents, Tektur display type, and layered operational gradients.
+STORY: Find the active run, read cost, context, and speed, then open one task and follow its evidence without losing orientation.
+FIRST VIEWPORT: A layered spectrum header leads into a two-column instrument grid; detail replaces the generic title with the task and pairs its main chart with a luminous cost-and-context gauge.
+FORM: Spectrum Instrument Field — user-pinned Neo-Mirai, 1 of 1 grounded forms; concept-roll seed a5c0fdde; returned to Token Meter's original palette.
+FINISH: unreviewed and undocumented is unfinished; this build ends with the finish review, the verdict, and specs/DESIGN.md
+-->
+<div class=wrap>
+ <div class=top aria-label="Token Meter navigation">
+  <div class=brand><div class=logo role=img aria-label="Splunk by Cisco"><img src="/assets/brand/logo-splunk-by-cisco-rgb-w.png" alt=""></div><span class=brandCopy><span class=brandName>Token Meter</span></span></div>
+	  <nav class=tabs aria-label="Primary navigation">
+	   <div class=navPrimary>
+	   <button class="tab on" id=tab-session data-label=Sessions aria-label=Sessions title=Sessions><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h16M4 12h16M4 17h16"/><path d="M7 5v4M14 10v4M18 15v4"/></svg><span class=tabLabel>Sessions</span></button>
+	   <button class=tab id=tab-daily data-label=Spend aria-label=Spend title=Spend><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="4" y="5" width="16" height="15" rx="2"/><path d="M8 3v4M16 3v4M4 9h16M8 13h3M8 17h7"/></svg><span class=tabLabel>Spend</span></button>
+	   <button class=tab id=tab-models data-label=Models aria-label=Models title=Models><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 18l5-5 4 2 7-8"/><path d="M16 7h4v4M4 20h16"/></svg><span class=tabLabel>Models</span></button>
+	   <button class=tab id=tab-subagents data-label=Subagents aria-label=Subagents title=Subagents><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><circle cx="12" cy="7" r="3"/><circle cx="6" cy="17" r="2"/><circle cx="18" cy="17" r="2"/><path d="M12 10v3M6 15v-2h12v2"/></svg><span class=tabLabel>Subagents</span></button>
+	   <button class=tab id=tab-efficiency data-label=Efficiency aria-label=Efficiency title=Efficiency><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M5 19V9M12 19V5M19 19v-7"/><path d="M3 19h18"/></svg><span class=tabLabel>Efficiency</span></button>
+	   <button class=tab id=tab-work data-label=Work aria-label=Work title=Work hidden><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="3" y="7" width="18" height="13" rx="2"/><path d="M9 7V5a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2M3 13h18"/></svg><span class=tabLabel>Work</span></button>
+	   <button class=tab id=tab-git data-label=Git aria-label=Git title=Git><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 16l5-5 4 3 7-8"/><path d="M15 6h5v5M4 20h16"/></svg><span class=tabLabel>Git</span></button>
+	   <a class=tab id=tab-performance href=/performance data-label=Performance aria-label=Performance title=Performance><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="5" y="4" width="14" height="16" rx="2"/><path d="M8 15v-3M12 15V9M16 15v-5M8 18h8"/></svg><span class=tabLabel>Performance</span></a>
+	   </div>
+	   <div class=navSecondary>
+	   <button class=tab id=tab-read data-label=Read aria-label="Read about Enterprise Tokenomics" title="Read about Enterprise Tokenomics · Opens a Splunk search in a new tab"><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M14 3h7v7M10 14 21 3M21 14v5a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5"/></svg><span class=tabLabel>Read</span></button>
+	   <button class=tab id=tab-learn data-label=Learn aria-label=Learn title=Learn><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 5.5A3.5 3.5 0 0 1 7.5 2H11v17H7.5A3.5 3.5 0 0 0 4 22zM20 5.5A3.5 3.5 0 0 0 16.5 2H13v17h3.5A3.5 3.5 0 0 1 20 22z"/></svg><span class=tabLabel>Learn</span></button>
+	   <button class=tab id=tab-capabilities data-label=Tools aria-label=Tools title=Tools><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M14 6a4 4 0 0 0-5 5L4 16l4 4 5-5a4 4 0 0 0 5-5l-3 3-3-3z"/></svg><span class=tabLabel>Tools</span></button>
+	   <button class=tab id=tab-settings data-label=Settings aria-label=Settings title=Settings><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h10M18 7h2M4 17h3M11 17h9M14 4v6M7 14v6"/></svg><span class=tabLabel>Settings</span></button>
+	   </div>
+	  </nav>
+  <div class=spacer></div>
+ </div>
+
+ <div id=session-depot hidden>
+  <div class=sessionhead>
+   <span class=badge id=s-provider>source</span>
+   <span class=repo id=s-repo>--</span>
+   <span class="sessid mono" id=s-id></span>
+   <span class=pill id=s-pricing></span>
+   <span class=spacer></span>
+  </div>
+  <div class=sessionStart id=session-start hidden><span>Started with</span><strong id=session-start-text></strong></div>
+
+  <div class="session-panel on" id=panel-summary>
+  <div class=agentDiscovery id=agent-discovery hidden>
+   <div class=agentDiscoveryMain><div class=agentDiscoveryTitle>Ask about this run from Codex or Claude</div><div class=agentDiscoveryText>Get a read-only verdict on cost, context, tool output, and whether to continue&mdash;without sharing prompts or tool content.</div></div>
+   <button class=tbtn id=agent-discovery-open type=button>Connect agent</button>
+   <button class=agentDiscoveryClose id=agent-discovery-close type=button aria-label="Dismiss agent access suggestion">&times;</button>
+  </div>
+  <div class=hero>
+   <div class="card costcard" tabindex=0>
+    <div>
+     <div class="label fieldtip" tabindex=0 title="Estimated cost for the selected local log/thread using the configured model rates. Executions are the individual model turns inside it." data-tip="Estimated cost for the selected local log/thread using the configured model rates. Executions are the individual model turns inside it.">Session cost</div>
+     <div class="meter mono" id=cost>$0.00</div>
+     <div class=subline id=sub></div>
+    </div>
+    <div class=costtip id=cost-tip></div>
+    <div class=costmeta>
+     <div><div class="label fieldtip" tabindex=0 title="Local timestamp for the first observed event in this log/thread." data-tip="Local timestamp for the first observed event in this log/thread.">Started</div><div class="v mono" id=cost-start>--</div><div class=sm>local time</div></div>
+     <div><div class="label fieldtip" tabindex=0 id=cost-end-label title="Local timestamp for the newest observed event in this log/thread." data-tip="Local timestamp for the newest observed event in this log/thread.">Last activity</div><div class="v mono" id=cost-end>--</div><div class=sm>local time</div></div>
+    </div>
+    <div class=frozen id=frozen>pinned log - frozen view</div>
+   </div>
+   <div class=statgrid>
+    <div class=stat><div class="label fieldtip" tabindex=0 title="Total model input tokens, including uncached input, cache reads, and cache writes." data-tip="Total model input tokens, including uncached input, cache reads, and cache writes.">Input</div><div class="v mono" id=input-tok>0</div><div class=sm id=input-toksm></div></div>
+	    <div class=stat><div class="label fieldtip" tabindex=0 title="Includes trace-reported reasoning and thinking output. Excludes input, cache, and external tool-result tokens. Completed speed is weighted across every attributable completed sample; active speed uses completed checkpoints." data-tip="Includes trace-reported reasoning and thinking output. Excludes input, cache, and external tool-result tokens. Completed speed is weighted across every attributable completed sample; active speed uses completed checkpoints.">Output</div><div class=outputPair><div class="v mono" id=output-tok>0</div><div class=outputRate><strong class=mono id=output-tps>--</strong><span>tok/s</span></div></div><div class=sm id=output-toksm></div></div>
+    <div class=stat><div class="label fieldtip" tabindex=0 title="Cumulative wall-clock time from a user prompt until the completed response. Reasoning and tool use count because you are still waiting; gaps between prompts do not." data-tip="Cumulative wall-clock time from a user prompt until the completed response. Reasoning and tool use count because you are still waiting; gaps between prompts do not.">Wait time</div><div class="v mono" id=ov-duration>--</div><div class=sm id=ov-idle></div></div>
+    <div class=stat><div class="label fieldtip" tabindex=0 title="Latest execution input/context tokens, shown against the model window when known." data-tip="Latest execution input/context tokens, shown against the model window when known.">Context in use</div><div class="v mono" id=ov-context>0</div><div class=sm id=ov-contextsm></div></div>
+   </div>
+  </div>
+
+  <div id=session-efficiency-home>
+   <section class="card sessionEfficiency" id=session-efficiency aria-labelledby=session-efficiency-title>
+    <div class=sessionEfficiencyIntro><div class=label id=session-efficiency-title>Efficiency</div><div class=sm>This run</div></div>
+    <div class="sessionEfficiencyMetric metric"><div class=label>Output / $</div><strong class=mono id=session-output-dollar>--</strong><span id=session-output-dollar-note>unavailable</span></div>
+    <div class="sessionEfficiencyMetric metric"><div class=label>Reasoning ratio</div><strong class=mono id=session-reasoning-ratio>--</strong><span id=session-reasoning-ratio-note>unavailable</span></div>
+   </section>
+  </div>
+
+  <div id=session-budget-home>
+  <div class="card sessionBudget" id=session-budget-control>
+   <div class=sessionBudgetHead>
+    <div><div class="label fieldtip" tabindex=0 title="Saved cost cap for this session. Token Meter alerts when the live session crosses it." data-tip="Saved cost cap for this session. Token Meter alerts when the live session crosses it.">Session budget</div></div>
+    <label class=sessionBudgetExact><span>Cap $</span><input id=budget type=number min=0.5 step=0.5 value=10 aria-label="Exact session budget in USD"></label>
+   </div>
+   <div class=sessionBudgetTrack>
+    <span class=mono id=budget-slider-min>$0.50</span>
+    <input id=budget-slider type=range min=0.5 max=100 step=0.5 value=10 aria-label="Session budget slider">
+    <span class=mono id=budget-slider-max>$100.00</span>
+   </div>
+   <div class=sessionBudgetMeta><span id=session-budget-spend>Session spend $0.00</span><span id=session-budget-status role=status aria-live=polite></span></div>
+  </div>
+  </div>
+
+  <details class=usageDetails id=usage-details>
+  <summary><span>Usage details</span></summary>
+  <div class=usageDetailsBody>
+  <div id=session-token-split-home>
+  <div class="card pad usageSplit" id=session-token-split-module>
+   <div class=splithead><div class="label fieldtip" tabindex=0 title="Semantic split of where the current log's tokens went." data-tip="Semantic split of where the current log's tokens went.">Where tokens go</div><span class=hint id=semhint></span></div>
+   <div class=bar id=sembar></div>
+   <div class=legend>
+    <span class=fieldtip tabindex=0 title="Tokens associated with model reasoning or thinking output." data-tip="Tokens associated with model reasoning or thinking output."><i class=dot style=background:var(--reason)></i>reasoning</span>
+    <span class=fieldtip tabindex=0 title="Regular assistant output tokens." data-tip="Regular assistant output tokens."><i class=dot style=background:var(--output)></i>output</span>
+    <span class=fieldtip tabindex=0 title="Approximate tokens returned by tool results." data-tip="Approximate tokens returned by tool results."><i class=dot style=background:var(--retrieval)></i>retrieval</span>
+    <span class=fieldtip tabindex=0 title="Tokens and cost attributed to subagent or coordination executions." data-tip="Tokens and cost attributed to subagent or coordination executions."><i class=dot style=background:var(--coord)></i>coordination</span>
+   </div>
+  </div>
+  </div>
+  <div class="statgrid usageDetailGrid">
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Output tokens attributed to reasoning or thinking events when the provider reports them." data-tip="Output tokens attributed to reasoning or thinking events when the provider reports them.">Thinking</div><div class="v mono" id=think-tok>0</div><div class=sm id=think-toksm></div></div>
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Approximate tokens returned from tool results, based on captured output size." data-tip="Approximate tokens returned from tool results, based on captured output size.">Tool results</div><div class="v mono" id=toolcall-tok>0</div><div class=sm id=toolcall-toksm></div></div>
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Estimated spend per active execution minute. Idle gaps are excluded and overlapping execution windows are counted once." data-tip="Estimated spend per active execution minute. Idle gaps are excluded and overlapping execution windows are counted once.">Burn / min</div><div class="v mono" id=burn>$0</div><div class=sm id=burnsm>active execution time</div></div>
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Estimated average cost per completed task or turn completion." data-tip="Estimated average cost per completed task or turn completion.">Cost / task</div><div class="v mono" id=cpt>$0</div><div class=sm id=cptsm></div></div>
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Share of input tokens that were cached or cache-related instead of uncached input." data-tip="Share of input tokens that were cached or cache-related instead of uncached input.">Cache rate</div><div class="v mono" id=cache-hit>0%</div><div class=sm id=cache-hitsm></div></div>
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Total input tokens served from or written to the provider prompt cache." data-tip="Total input tokens served from or written to the provider prompt cache.">Cache tokens</div><div class="v mono" id=cache-tok>0</div><div class=sm id=cache-toksm></div></div>
+   <div class=stat><div class="label fieldtip" tabindex=0 title="Estimated savings from cache reads versus charging those tokens at the normal input rate." data-tip="Estimated savings from cache reads versus charging those tokens at the normal input rate.">Cache saved</div><div class="v mono" id=cache-saved>$0</div><div class=sm id=cache-savedsm></div></div>
+  </div>
+
+  <div class=section-h><h2><span class=fieldtip tabindex=0 title="High-level metrics for the current log/thread. Executions are individual model turns." data-tip="High-level metrics for the current log/thread. Executions are individual model turns.">Execution Overview</span></h2><span class=hint id=exec-hint></span></div>
+  <div class=overview>
+   <div class="card ov"><div class="label fieldtip" id=ov-loaded-label tabindex=0 title="Runtime-advertised catalog entries when available; otherwise observed tool types. Catalog entries may be default/read-only and are not an optimization denominator." data-tip="Runtime-advertised catalog entries when available; otherwise observed tool types. Catalog entries may be default/read-only and are not an optimization denominator.">Catalog advertised</div><div class="v mono" id=ov-loaded>0</div><div class=sm id=ov-loadedsm></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Number of priced model executions observed in this log/thread." data-tip="Number of priced model executions observed in this log/thread.">Executions</div><div class="v mono" id=ov-exec>0</div><div class=sm id=ov-model></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Estimated log/thread cost divided by execution count." data-tip="Estimated log/thread cost divided by execution count.">Avg cost</div><div class="v mono" id=ov-avg>$0</div><div class=sm></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Total tool calls observed in this log/thread." data-tip="Total tool calls observed in this log/thread.">Tool calls</div><div class="v mono" id=ov-tools>0</div><div class=sm id=ov-tooltok></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Highest observed input/context token count in this log/thread." data-tip="Highest observed input/context token count in this log/thread.">Context peak</div><div class="v mono" id=ov-peak>0</div><div class=sm></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Most expensive single execution in this log/thread." data-tip="Most expensive single execution in this log/thread.">Priciest</div><div class="v mono" id=ov-big>$0</div><div class=sm id=ov-bigsm></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded." data-tip="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded.">Skills used</div><div class="v mono" id=ov-skills>--</div><div class=sm id=ov-skillssm></div></div>
+   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded." data-tip="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded.">MCP servers used</div><div class="v mono" id=ov-mcp>--</div><div class=sm id=ov-mcpsm></div></div>
+  </div>
+  <div class="capHero currentCapHero" aria-label="Session tool activity and removable capability optimization">
+   <div class="card pad"><div class="label fieldtip" tabindex=0 title="Unique tool identities observed in this selected log. Default tools and result-only instrumentation are included here as activity, not as removal candidates." data-tip="Unique tool identities observed in this selected log. Default tools and result-only instrumentation are included here as activity, not as removal candidates.">Tool activity</div><div class="meter mono" id=ov-activity-tools>0</div><div class=subline id=ov-activity-note></div></div>
+   <div class="card pad"><div class="label fieldtip" tabindex=0 title="Enabled user-installed skill packs this runtime can disable. Any skill activation marks its whole pack used. Default tools and MCP servers are read-only evidence." data-tip="Enabled user-installed skill packs this runtime can disable. Any skill activation marks its whole pack used. Default tools and MCP servers are read-only evidence.">Optional capability use</div><div class="meter mono" id=ov-optional-use>0/0</div><div class=capStatBar id=ov-optional-bar role=progressbar aria-label="Optional capability use in this session" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0><i></i></div><div class=subline id=ov-optional-note></div></div>
+   <div class="card pad"><div class="label fieldtip" tabindex=0 title="Enabled user-installed skill packs with no observed activation in this session. MCP servers and read-only capabilities are excluded." data-tip="Enabled user-installed skill packs with no observed activation in this session. MCP servers and read-only capabilities are excluded.">Unused skill packs</div><div class="meter mono" id=ov-unused-packs>0</div><div class=subline id=ov-unused-packs-note></div></div>
+  </div>
+
+  <div id=session-chart-home>
+  <section class=sessionChartModule id=session-chart-module>
+  <div class=section-h><h2>Execution Profile</h2><span class=hint id=exec-profile-hint>per execution or request</span></div>
+  <div class="card pad">
+   <div class=chartbar>
+    <div class=label>Chart</div>
+    <div class=seg id=chart-mode>
+     <button class=fieldtip data-chart=tokens title="Show input, cached input, and output tokens for each execution." data-tip="Show input, cached input, and output tokens for each execution.">Tokens</button>
+     <button class=fieldtip data-chart=cost title="Show estimated USD cost for each execution." data-tip="Show estimated USD cost for each execution.">Cost</button>
+     <button class=fieldtip data-chart=context title="Show input/context pressure as a share of the model context window." data-tip="Show input/context pressure as a share of the model context window.">Context</button>
+     <button class=fieldtip data-chart=tools title="Show the number of tool calls observed in each execution." data-tip="Show the number of tool calls observed in each execution.">Tools</button>
+     <button class=fieldtip data-chart=steps title="Show how many executions happened after each captured user message." data-tip="Show how many executions happened after each captured user message.">Steps</button>
+     <button class=fieldtip data-chart=wait title="Show prompt-to-completed-response wall-clock wait for each user request." data-tip="Show prompt-to-completed-response wall-clock wait for each user request.">Wait</button>
+    </div>
+    <div class=seg id=scale>
+     <button class=fieldtip data-scale=linear title="Use a normal proportional token scale." data-tip="Use a normal proportional token scale.">Linear</button>
+     <button class=fieldtip data-scale=cumulative title="Show running estimated cost or token totals through each execution." data-tip="Show running estimated cost or token totals through each execution.">Cumulative</button>
+    </div>
+   </div>
+   <div class=chartwrap>
+    <svg class=chart id=iochart viewBox="0 0 1040 244" preserveAspectRatio=none></svg>
+    <div class="charttip chartTip" id=chart-tip></div>
+   </div>
+   <div class=legend id=chart-legend></div>
+  </div>
+  </section>
+  </div>
+  </div>
+  </details>
+  </div>
+
+	  <div class=foot>Local-only</div>
+ </div>
+
+ <div class="view on" id=view-session>
+  <div class=sessionBackRow id=session-back-row data-current-detail><button class="tbtn sessionBack" id=session-back type=button aria-label="Back to Current sessions"><span aria-hidden=true>←</span><span id=session-back-label>Current sessions</span></button></div>
+  <div class=banner id=banner data-current-detail>
+   <span class=msg id=banner-msg></span>
+   <span class=budgetadd id=budget-add-row>
+    <label>Add $<input id=budget-add type=number min=0.5 step=0.5 value=5></label>
+    <button class=tbtn id=budget-add-btn type=button>Add budget</button>
+   </span>
+  </div>
+  <div class="banner monthlyBudgetBanner" id=current-budget-warning role=status aria-live=polite data-current-detail>
+   <span class=msg id=current-budget-warning-msg></span>
+   <button class=tbtn id=current-budget-settings type=button>Open monthly budget</button>
+  </div>
+  <div class="spectrumPageHeadFrame hasPageActions" data-session-flow=unavailable>
+   <div class="previewHead spectrumPageHead sessionFlowHead" id=session-flow-head data-page-signal=sessions data-session-flow=unavailable>
+    <div class="previewHeadCopy spectrumPageHeadCopy">
+     <h1 id=session-page-title>Sessions</h1>
+     <p class=spectrumPageSubtitle id=current-description>Last 30 minutes</p>
+    </div>
+   </div>
+   <div class=spectrumPageActions><div class=sessionFlowStatus role=status aria-live=polite><i aria-hidden=true></i><span id=session-flow-label>Waiting for evidence</span></div></div>
+  </div>
+
+  <div class="tabs sessionScopeTabs" id=session-scope-tabs role=tablist aria-label="Sessions view">
+   <button class=tab id=session-scope-current type=button role=tab aria-selected=true aria-controls=current-sessions-overview data-session-scope=current><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h16M4 12h16M4 17h16"/><path d="M7 5v4M14 10v4M18 15v4"/></svg><span class=tabLabel>Current sessions</span></button>
+   <button class=tab id=session-scope-all type=button role=tab aria-selected=false aria-controls=all-session-history data-session-scope=all><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="4" y="4" width="16" height="16" rx="2"/><path d="M8 8h8M8 12h8M8 16h5"/></svg><span class=tabLabel>All sessions</span></button>
+   <button class=tab id=session-scope-compare type=button role=tab aria-selected=false aria-controls=session-compare data-session-scope=compare><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="3" y="5" width="7" height="14" rx="1.5"/><rect x="14" y="5" width="7" height="14" rx="1.5"/><path d="M6.5 9v6M17.5 12v3"/></svg><span class=tabLabel>Compare</span><span class=compareTabCount id=compare-tab-count hidden></span></button>
+   <button class=tab id=session-scope-subagents type=button role=tab aria-selected=false aria-controls=subagent-explorer data-session-scope=subagents><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M12 4v5M5 12h14M5 12v6M12 12v6M19 12v6"/><circle cx="12" cy="3" r="1"/><circle cx="5" cy="19" r="1"/><circle cx="12" cy="19" r="1"/><circle cx="19" cy="19" r="1"/></svg><span class=tabLabel>Subagents</span></button>
+  </div>
+
+  <div class=previewSurface id=preview-surface-sessions>
+   <section class=currentDaySummary aria-label="Today's usage summary">
+    <div class=currentDayReadouts>
+     <div class=currentDayMetric><span class=currentDayMetricLabel>Spend today</span><strong class="currentDayMetricValue mono" id=current-day-spend>--</strong><small class=currentDayMetricNote id=current-day-spend-note></small></div>
+     <div class=currentDayMetric><span class=currentDayMetricLabel>Sessions today</span><strong class="currentDayMetricValue mono" id=current-day-sessions>--</strong><small class=currentDayMetricNote id=current-day-sessions-note></small></div>
+     <div class=currentDayMetric><span class=currentDayMetricLabel>Vs yesterday</span><strong class="currentDayMetricValue mono" id=current-day-vs-yesterday>--</strong><small class=currentDayMetricNote id=current-day-vs-yesterday-note></small></div>
+    </div>
+    <div class=currentDayActions><button class="tbtn currentDayMonth" id=current-month-spend type=button>View month spend</button><a class="tbtn currentDayLearn" href="https://www.splunk.com/en_us/products/tokenomics.html" target=_blank rel="noopener noreferrer" aria-label="Get Enterprise Tokenomics from Splunk (opens in a new tab)">Get Enterprise Tokenomics<svg class=currentDayLearnIcon viewBox="0 0 16 16" aria-hidden=true><path d="M8.5 3.5h4v4M12.5 3.5l-6 6"/><path d="M10.5 8.5v4h-7v-7h4"/></svg></a></div>
+   </section>
+   <section id=current-sessions-overview role=tabpanel aria-labelledby=session-scope-current>
+    <div class=currentSessionsHead>
+     <div class=currentSessionFilterGroups>
+      <div class=currentSessionFilterGroup id=current-session-runtime-filter-group hidden><span class=currentSessionFilterLabel>App</span><div class="seg currentSessionRuntimeFilters" id=current-session-runtime-filters role=group aria-label="Filter current sessions by runtime"></div></div>
+      <div class=currentSessionFilterGroup id=current-session-activity-filter-group hidden><span class=currentSessionFilterLabel>Status</span><div class="seg currentSessionActivityFilters" id=current-session-activity-filters role=group aria-label="Filter current sessions by activity"><button type=button data-current-activity-filter=all aria-pressed=true>All</button><button type=button data-current-activity-filter=working aria-pressed=false>Working</button><button type=button data-current-activity-filter=recent aria-pressed=false>Recent</button></div></div>
+     </div>
+     <span class=currentSessionsCount id=current-session-count-label>Waiting</span>
+    </div>
+    <div class=currentSessionGrid id=current-session-grid aria-label="Recent sessions. Drag cards or use Option and arrow keys to reorder."></div>
+    <div class=currentSessionOrderStatus id=current-session-order-status role=status aria-live=polite></div>
+   </section>
+   <section id=all-session-history role=tabpanel aria-labelledby=session-scope-all hidden>
+    <div class=allSessionsHead>
+     <h2 class=workSrOnly>All sessions</h2>
+     <span class=allSessionsHint id=g-hint>Recent activity</span>
+    </div>
+    <div class="globalControls logsToolbar">
+     <label class="filterControl logSearchControl"><span>Search</span><input class=searchbox id=g-search type=search placeholder="Title, project, or model"></label>
+     <label class=filterControl><span>App</span><select class=filterSelect id=g-app aria-label="App filter"><option value="">All apps</option></select></label>
+     <label class=filterControl><span>Projects</span><select class=filterSelect id=g-project aria-label="Projects filter"><option value="">All projects</option></select></label>
+     <label class=filterControl><span>Time range</span><select class=filterSelect id=g-time aria-label="Time range filter"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7d>7 days</option><option value=30d selected>30 days</option><option value=90d>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
+     <div class=logsToolbarRow>
+     <div class="filterControl filterSort filterChildren"><span>Subagent runs</span><div class="seg sortseg" id=g-children aria-label="Subagent run visibility">
+      <button type=button aria-pressed=true data-gchildren=hide class=on title="Hide subagent runs as rows. Their spend is still counted in totals and shown under each parent session.">Under parent</button>
+      <button type=button aria-pressed=false data-gchildren=show title="Also list subagent runs as their own rows.">As rows</button>
+     </div></div>
+     <div class=filterClear><button class="tbtn clearFilters" id=g-clear type=button title="Clear search, app, project, and time filters.">Clear filters</button></div>
+     <div class="filterControl filterSort"><span>Sort</span><div class="seg sortseg" id=g-sort>
+      <button data-gsort=recent title="Newest activity first.">Recent</button>
+      <button data-gsort=cost title="Highest cost first.">Cost</button>
+      <button data-gsort=tokens title="Most tokens first.">Tokens</button>
+      <button data-gsort=executions title="Most executions first.">Execs</button>
+      <button data-gsort=wait title="Most cumulative prompt-to-response wait first.">Wait</button>
+     </div></div>
+     </div>
+    </div>
+    <div class=logsToolbarStatus><div class=activeFilters id=g-active-filters hidden aria-live=polite></div><div class="globalMeta filterCount" id=g-count></div></div>
+    <div class=logsSummary id=logs-summary>
+     <div class=logKpis>
+      <div class="logStat metric"><div class=label>Filtered cost</div><div class="v mono" id=lf-cost>$0</div><div class=subline id=lf-cost-note></div></div>
+      <div class="logStat metric"><div class="label fieldtip" tabindex=0 aria-description="Fresh and cached input in the filtered sessions." data-tip="Fresh and cached input in the filtered sessions.">Input tokens</div><div class="v mono" id=lf-input>0</div></div>
+      <div class="logStat metric"><div class="label fieldtip" tabindex=0 aria-description="Trace-reported or clearly labeled locally estimated output in the filtered sessions." data-tip="Trace-reported or clearly labeled locally estimated output in the filtered sessions.">Output tokens</div><div class="v mono" id=lf-output>0</div></div>
+      <div class="logStat metric"><div class=label>Executions</div><div class="v mono" id=lf-executions>0</div><div class=subline id=lf-executions-note></div></div>
+      <div class="logStat metric waitStat"><div class="label fieldtip" tabindex=0 title="Cumulative prompt-to-completed-response wall-clock time in the filtered sessions." data-tip="Cumulative prompt-to-completed-response wall-clock time in the filtered sessions.">Wait time</div><div class="v mono" id=lf-wait>--</div><div class=subline id=lf-wait-note></div></div>
+     </div>
+     <details class=historyModels id=history-models>
+      <summary><span>By model</span><span class=logModelCount id=lf-model-count></span></summary>
+      <div class=logModelList id=lf-models></div>
+     </details>
+    </div>
+    <div class=slist id=slist></div>
+    <div class=compareTray id=compare-tray role=region aria-label="Sessions selected for comparison" hidden></div>
+   </section>
+   <section id=session-compare role=tabpanel aria-labelledby=session-scope-compare hidden>
+    <div class=allSessionsHead>
+     <div><h2>Compare sessions</h2><p>Up to four sessions side by side.</p></div>
+     <div class=compareHeadActions><button class=tbtn id=compare-pick type=button>Add from All sessions</button><button class="tbtn compareClear" id=compare-clear type=button>Clear</button></div>
+    </div>
+    <div id=compare-body aria-live=polite></div>
+   </section>
+   <section id=subagent-explorer role=tabpanel aria-labelledby=session-scope-subagents hidden>
+    <div class="card subagentCommand">
+     <div class=subagentViewTabs id=subagent-view-tabs role=tablist aria-label="Subagent workspace view">
+      <button id=subagent-tab-roles type=button role=tab data-subagent-view=roles aria-selected=true aria-controls=subagent-results-panel><span>Roles</span><small id=subagent-view-roles-count>--</small></button>
+      <button id=subagent-tab-sessions type=button role=tab data-subagent-view=sessions aria-selected=false aria-controls=subagent-results-panel><span>Sessions</span><small id=subagent-view-sessions-count>--</small></button>
+      <button id=subagent-tab-issues type=button role=tab data-subagent-view=issues aria-selected=false aria-controls=subagent-results-panel><span>Issues</span><small id=subagent-view-issues-count>--</small></button>
+     </div>
+     <div class=subagentFilterPrimary>
+      <label class="filterControl logSearchControl"><span>Search</span><input class=searchbox id=subagent-filter-search type=search placeholder="Role, nickname, model, or project"></label>
+      <label class=filterControl><span>App</span><select class=filterSelect id=subagent-filter-app><option value="">All apps</option></select></label>
+      <label class=filterControl><span>Project</span><select class=filterSelect id=subagent-filter-project><option value="">All projects</option></select></label>
+      <label class=filterControl><span>Time range</span><select class=filterSelect id=subagent-filter-time><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7d>7 days</option><option value=30d selected>30 days</option><option value=90d>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
+      <button class=subagentFilterMore id=subagent-filter-more type=button aria-expanded=false aria-controls=subagent-filter-advanced>More filters <span id=subagent-filter-more-count></span></button>
+     </div>
+     <div class=subagentFilterAdvanced id=subagent-filter-advanced hidden>
+      <label class=filterControl><span>Model</span><select class=filterSelect id=subagent-filter-model><option value="">All models</option></select></label>
+      <label class=filterControl><span>Status</span><select class=filterSelect id=subagent-filter-status><option value=all>All statuses</option><option value=working>Working</option><option value=incomplete>Incomplete</option><option value=complete>Complete</option><option value=waiting>Waiting</option><option value=recent>Recent</option><option value=unknown>Unknown</option></select></label>
+      <label class=filterControl><span>Signal</span><select class=filterSelect id=subagent-filter-signal><option value=all>All signals</option><option value=attention>Any cost/retry signal</option><option value=peer_cost_outlier>Peer cost outlier</option><option value=active_cost_concentration>Active cost concentration</option><option value=retry_pressure>Retry pressure</option></select></label>
+      <label class=filterControl><span>Sort</span><select class=filterSelect id=subagent-filter-sort><option value=recent>Recent</option><option value=cost>Cost</option><option value=tokens>Tokens</option><option value=work>Work time</option><option value=name>Agent name</option></select></label>
+     </div>
+     <div class=subagentFilterFooter id=subagent-filter-footer hidden>
+      <div class=subagentActiveFilters id=subagent-active-filters aria-live=polite></div>
+      <button class="tbtn clearFilters" id=subagent-filter-clear type=button>Clear all</button>
+     </div>
+    </div>
+    <div class=subagentCompactSummary id=subagent-compact-summary aria-live=polite></div>
+    <div class=subagentInventoryWarning id=subagent-inventory-warning hidden></div>
+    <div class=subagentCoverageNote id=subagent-coverage-note hidden></div>
+    <section class="card subagentModelDistribution" id=subagent-model-distribution aria-label="Model distribution of matching child runs" hidden></section>
+    <div class=subagentWorkspace id=subagent-workspace>
+     <section class="card subagentResultsCard" id=subagent-results-panel role=tabpanel aria-labelledby=subagent-tab-roles tabindex=0>
+      <div class=subagentResultsHead><div><h3 id=subagent-results-title>Role comparison</h3><p id=subagent-results-description>Provider-reported roles compared across the current filters.</p></div><span id=subagent-results-count></span></div>
+      <div class=subagentResults id=subagent-results></div>
+     </section>
+     <aside class="card subagentInspector" id=subagent-inspector aria-label="Agent inspector"></aside>
+    </div>
+   </section>
+  </div>
+
+  <div class=previewRunMeta data-current-detail>
+   <span class="badge app" id=preview-provider>source</span>
+   <span class=repo id=preview-project>--</span>
+   <span class=pill id=preview-model>--</span>
+   <span class=workTags id=preview-work-tags hidden></span>
+   <button class=sessionModelAssign id=session-model-identity-action type=button hidden>Add model</button>
+   <span class=spacer></span>
+   <a class="tbtn sessionDesktopLink" id=session-desktop-link hidden aria-label="Open this session in the Codex desktop app">Open in Codex</a>
+   <button class=sessionDelete id=session-delete type=button hidden>Delete session</button>
+  </div>
+  <section class="card previewStartStrip" data-current-detail>
+   <div class=previewStartLabel>Started with</div>
+   <div class=previewStartText id=preview-start>No user message captured.</div>
+  </section>
+  <div class="previewSurface on" id=preview-surface-run>
+  <div class=previewRunGrid>
+   <div class=previewChartColumn>
+    <div class=previewChartSlot id=preview-run-chart-slot></div>
+    <div class=previewTokenSlot id=preview-token-split-slot></div>
+   </div>
+   <aside class=previewDecision>
+    <div class=section-h><h2>Session cost</h2><span class=hint>estimate</span></div>
+    <section class="card previewStatus" id=preview-status-card>
+     <div class=previewStatusTop><span class=previewState id=preview-state>Live</span><span class="previewIdle mono" id=preview-idle>--</span></div>
+     <div class="previewCost mono" id=preview-cost>$0.00</div>
+     <div class=previewCostNote id=preview-cost-note>Waiting for live cost evidence.</div>
+     <div class=previewRunEfficiencySlot id=preview-run-efficiency-slot></div>
+     <div class=previewPressure>
+      <div class=previewPressureHead><span>Context pressure</span><b class=mono id=preview-context-pct>--</b></div>
+      <div class=previewPressureBar role=progressbar aria-label="Session context pressure" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0 id=preview-context-bar><i></i></div>
+     </div>
+     <div class=previewTimes>
+      <div><span>Started</span><b class=mono id=preview-started-at>--</b></div>
+      <div><span id=preview-last-label>Last activity</span><b class=mono id=preview-last-at>--</b></div>
+     </div>
+    </section>
+    <div class=previewRunBudgetSlot id=preview-run-budget-slot></div>
+   </aside>
+  </div>
+  <div class=previewKpis aria-label="Live run metrics">
+   <div class="card previewKpi metric previewSpeed"><div class="label fieldtip" tabindex=0 aria-description="Output tokens per second from timing evidence." data-tip="Output tokens per second from timing evidence.">Output speed</div><div class="v mono" id=preview-speed>--</div><div class=sm id=preview-speed-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Wall-clock time from each prompt to its completed response." data-tip="Wall-clock time from each prompt to its completed response.">Wait time</div><div class="v mono" id=preview-wait>--</div><div class=sm id=preview-wait-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Input/context tokens in the latest execution." data-tip="Input/context tokens in the latest execution.">Context in use</div><div class="v mono" id=preview-context>--</div><div class=sm id=preview-context-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Model turns in this session." data-tip="Model turns in this session.">Executions</div><div class="v mono" id=preview-executions>0</div><div class=sm id=preview-executions-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Tool calls observed in this session." data-tip="Tool calls observed in this session.">Tool calls</div><div class="v mono" id=preview-tools>0</div><div class=sm id=preview-tools-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated tokens of text returned by tools." data-tip="Estimated tokens of text returned by tools.">Tool-result tokens</div><div class="v mono" id=preview-tool-results>--</div><div class=sm id=preview-tool-results-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Share of input served from the prompt cache." data-tip="Share of input served from the prompt cache.">Cache rate</div><div class="v mono" id=preview-cache-rate>--</div><div class=sm id=preview-cache-rate-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated spend avoided by cache reads." data-tip="Estimated spend avoided by cache reads.">Cache saved</div><div class="v mono" id=preview-cache-saved>--</div><div class=sm id=preview-cache-saved-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated spend per minute while the run is active." data-tip="Estimated spend per minute while the run is active.">Burn / minute</div><div class="v mono" id=preview-burn>--</div><div class=sm id=preview-burn-note></div></div>
+   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated cost per accepted task." data-tip="Estimated cost per accepted task.">Cost / task</div><div class="v mono" id=preview-cost-task>--</div><div class=sm id=preview-cost-task-note></div></div>
+  </div>
+  <section class="card agentActivity" id=agent-activity aria-labelledby=agent-activity-title hidden>
+   <div class=agentActivityHead><div><h2 id=agent-activity-title>Agent activity</h2><p id=agent-activity-context></p></div><div class=agentCoverage id=agent-activity-coverage></div></div>
+   <div class=agentActivityMetrics id=agent-activity-metrics></div>
+   <div class=agentActivityTree id=agent-activity-tree role=tree aria-label="Agent activity hierarchy"></div>
+   <div class=agentAttentionDetail id=agent-attention-detail aria-live=polite></div>
+  </section>
+  <div class=foot>Local-only</div>
+  </div>
+ </div>
+
diff --git a/dashboard/markup/spend.html b/dashboard/markup/spend.html
new file mode 100644
index 00000000..cf6c3b41
--- /dev/null
+++ b/dashboard/markup/spend.html
@@ -0,0 +1,144 @@
+	 <div class=view id=view-daily>
+	  <div class="spectrumPageHeadFrame hasPageActions">
+	   <div class="dailyHead spectrumPageHead" data-page-signal=spend>
+	    <div class=spectrumPageHeadCopy><h1>Spend</h1></div>
+	   </div>
+	   <div class=spectrumPageActions><div class=spendRangeControls>
+	    <label class=filterControl><span>History</span><select class=filterSelect id=s-range aria-label="Spend history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option><option value=custom>Custom</option></select></label>
+	    <div class=spendCustom id=s-custom hidden><label><span>From</span><input id=s-from type=date></label><label><span>To</span><input id=s-to type=date></label><span id=s-range-error role=status aria-live=polite></span></div>
+	   </div></div>
+	  </div>
+	  <section class=spendBudgetSection id=spend-budgets aria-label="Monthly budget">
+	  <div class=budgetDashboard>
+	   <section class="card budgetLead">
+	    <div class=budgetLeadTop>
+	     <div class=budgetLeadTitle><h2 class=fieldtip tabindex=0 aria-description="Set a budget for each runtime; Token Meter adds them for the current calendar month. Partial coverage is shown as at least spend." data-tip="Set a budget for each runtime; Token Meter adds them for the current calendar month. Partial coverage is shown as at least spend.">Monthly budget</h2><span class=budgetMonth id=budget-month>This month</span><span class=budgetMeta id=budget-spend-note></span></div>
+	     <div class=budgetLeadHeadActions><span class="agentAccessBadge chip" id=budget-state>Not configured</span><button class=tbtn id=budget-plan-jump type=button aria-expanded=false aria-controls=budget-config>Set budgets</button></div>
+	    </div>
+    <div class=discountCue id=discount-cue role=status hidden></div>
+	    <div class=budgetLeadBody>
+	     <div class=budgetSpend>
+	      <div class=budgetFigure>
+	       <span class="label fieldtip" tabindex=0 title="Observed or locally estimated cost in the current local calendar month." data-tip="Observed or locally estimated cost in the current local calendar month.">Spent this month</span>
+	       <div class=budgetFigureLine><span class=budgetQualifier id=budget-spend-qualifier hidden>At least</span><span class="budgetSpendValue mono" id=budget-spend>$0</span><span class=budgetOf><span class=fieldtip tabindex=0 title="The sum of the registered runtime budgets." data-tip="The sum of the registered runtime budgets.">of</span> <b class=mono id=budget-total>Not set</b></span><span class=budgetTotalNote id=budget-total-note></span></div>
+	      </div>
+	      <div class=budgetProgress id=budget-progress role=progressbar aria-label="Monthly budget used" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0><i></i><span class=budgetProgressMarkers id=budget-progress-markers aria-hidden=true></span></div>
+	      <div class=budgetMeterFoot><span id=budget-current-note>Waiting for spend data.</span><span class=budgetCoverage id=budget-coverage></span></div>
+	     </div>
+	     <dl class=budgetStats>
+	      <div><dt class=fieldtip tabindex=0 title="Budget minus observed spend. Partial coverage means this is not a guaranteed safe remainder." data-tip="Budget minus observed spend. Partial coverage means this is not a guaranteed safe remainder.">Remaining</dt><dd class=mono id=budget-remaining>--</dd><dd class=budgetStatNote id=budget-remaining-note></dd></div>
+	      <div><dt class=fieldtip tabindex=0 title="Straight-line projection based on elapsed calendar days, shown after at least three active spend days." data-tip="Straight-line projection based on elapsed calendar days, shown after at least three active spend days.">Projected month</dt><dd class=mono id=budget-projected>--</dd><dd class=budgetStatNote id=budget-projected-note></dd></div>
+	     </dl>
+	    </div>
+	   </section>
+	  </div>
+	  <div class=spendBudgetEditor>
+	    <section class="card pad budgetRuntimeCard budgetConfig" id=budget-config hidden>
+		     <form class="budgetForm budgetInlineForm" id=budget-form>
+		      <div class=budgetConfigHead>
+		       <div><h2 class=fieldtip tabindex=0 aria-description="Runtime budgets are added to calculate the monthly total." data-tip="Runtime budgets are added to calculate the monthly total.">Set budgets</h2><div class=subline id=budget-allocation-note></div></div>
+		       <div class=budgetAlertInline role=group aria-label="Monthly budget alerts">
+		        <span class=budgetAlertTitle>Alerts at</span>
+		        <div class=budgetThresholds aria-label="Alert thresholds">
+		         <label><input id=budget-input-threshold-early data-budget-threshold type=number min=1 max=100 step=1 value=80 required aria-label="Early alert threshold"><span aria-hidden=true>%</span></label>
+		         <label><input id=budget-input-threshold-mid data-budget-threshold type=number min=1 max=100 step=1 value=90 required aria-label="Mid alert threshold"><span aria-hidden=true>%</span></label>
+		         <label><input id=budget-input-threshold-full data-budget-threshold type=number min=1 max=100 step=1 value=100 required aria-label="Final alert threshold"><span aria-hidden=true>%</span></label>
+		        </div>
+		        <label class=budgetNotifySwitch title="Toggle monthly budget alerts"><input id=budget-input-notifications type=checkbox checked aria-label="Enable monthly budget alerts"><span class=sw aria-hidden=true></span></label>
+		       </div>
+		      </div>
+		      <fieldset class=budgetFormGroup>
+		       <legend>Session defaults</legend>
+		       <div class=budgetSessionDefault>
+		        <label><span>Default session budget (USD)</span><input id=budget-input-session-default type=number min=0.5 max=100000000 step=0.5 value=10 required></label>
+		       </div>
+		      </fieldset>
+	      <fieldset class="budgetFormGroup budgetRuntimeFields">
+	       <legend>Runtime budgets · current spend</legend>
+	       <div class=budgetRuntimeList id=budget-runtimes>
+	        <div class=budgetRuntimeHead aria-hidden=true><span>Runtime</span><span>Spent this month</span><span>Budget (USD)</span></div>
+	        <div class=budgetRuntime id=budget-runtime-claude data-runtime-id=claude>
+	         <span class=budgetRuntimeName>Claude</span>
+	         <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-claude>$0.00</b><small id=budget-runtime-share-claude>0% of spend</small></span>
+	         <span class=budgetRuntimeTrack id=budget-runtime-track-claude><i></i></span>
+	         <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-claude aria-label="Claude budget" type=number min=0 max=100000000 step=any value=0></label>
+	        </div>
+	        <div class=budgetRuntime id=budget-runtime-codex data-runtime-id=codex>
+	         <span class=budgetRuntimeName>Codex</span>
+	         <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-codex>$0.00</b><small id=budget-runtime-share-codex>0% of spend</small></span>
+	         <span class=budgetRuntimeTrack id=budget-runtime-track-codex><i></i></span>
+	         <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-codex aria-label="Codex budget" type=number min=0 max=100000000 step=any value=0></label>
+	        </div>
+	        <div class=budgetRuntime id=budget-runtime-cursor data-runtime-id=cursor>
+	         <span class=budgetRuntimeName>Cursor</span>
+	         <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-cursor>$0.00</b><small id=budget-runtime-share-cursor>0% of spend</small></span>
+	         <span class=budgetRuntimeTrack id=budget-runtime-track-cursor><i></i></span>
+           <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-cursor aria-label="Cursor budget" type=number min=0 max=100000000 step=any value=0></label>
+	       </div>
+	       <div class=budgetRuntime id=budget-runtime-opencode data-runtime-id=opencode>
+	        <span class=budgetRuntimeName>OpenCode</span>
+	        <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-opencode>$0.00</b><small id=budget-runtime-share-opencode>0% of spend</small></span>
+	        <span class=budgetRuntimeTrack id=budget-runtime-track-opencode><i></i></span>
+	        <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-opencode aria-label="OpenCode budget" type=number min=0 max=100000000 step=any value=0></label>
+	       </div>
+	       </div>
+	      </fieldset>
+	      <div class=budgetActions><button class=tbtn id=budget-save type=submit>Save budgets</button><span class=settingsStatus id=budget-settings-status></span></div>
+	     </form>
+	    </section>
+    <section class="card pad budgetRuntimeCard discountCard settingsPricing" id=spend-discounts hidden aria-labelledby=discount-title>
+     <div class=budgetConfigHead><div><h2 id=discount-title class=fieldtip tabindex=0 aria-description="Spend and budgets use public list prices. Add the rate you actually pay and every cost is recalculated. Spend, budgets, and goals use your discount. Amounts a provider already billed are never discounted. Saved on this computer; updates and reinstalls keep your discounts." data-tip="Spend and budgets use public list prices. Add the rate you actually pay and every cost is recalculated. Spend, budgets, and goals use your discount. Amounts a provider already billed are never discounted. Saved on this computer; updates and reinstalls keep your discounts.">Discounts</h2></div><span class="agentAccessBadge chip" id=discount-badge>List prices</span></div>
+     <div class=modelPriceTabs id=discount-tabs role=tablist aria-label="Discounts by provider"></div>
+     <div class=modelPriceTableWrap><table class="tbl modelPriceTable"><thead><tr><th>Models from</th><th>Billed by</th><th class=num>Discount</th><th>From</th><th>Until</th><th>Note</th><th>Set by</th></tr></thead><tbody id=discount-rows></tbody></table></div>
+     <div class="modelPriceAdd discountAdd" id=discount-form role=group aria-label="Add a discount">
+      <label><span>Models from</span><select id=d-list><option value=anthropic>Anthropic</option><option value=openai>OpenAI</option><option value=cursor>Cursor</option><option value=kiro>Kiro</option><option value=opencode>OpenCode</option></select></label>
+      <label><span>Billed by</span><select id=d-channel><option value=direct>The provider</option><option value=bedrock>AWS Bedrock</option><option value=vertex>Google Vertex</option><option value=azure>Microsoft Azure</option><option value=any>Anyone</option></select></label>
+      <label><span>Discount %</span><input id=d-pct type=number min=0.01 max=99.99 step=0.01 placeholder=30></label>
+      <label><span>From <i class=hint>blank = all past usage</i></span><input id=d-start type=date></label>
+      <label><span>Until <i class=hint>blank = no end</i></span><input id=d-end type=date></label>
+      <label><span>Note</span><input id=d-note maxlength=60 placeholder="e.g. Company agreement"></label>
+      <button class=tbtn type=button id=d-add>Add discount</button>
+     </div>
+     <div class=modelPricingFooter><span class=settingsStatus id=discount-status></span><span class="settingsStatus warn" id=discount-invalid hidden></span></div>
+     <details class=discountMore>
+      <summary>How Claude apps are billed</summary>
+      <p>Claude Code and Claude Desktop don't record who bills them. Token Meter detects it; change it here if detection is wrong.</p>
+      <div class=discountApps>
+       <label><span>Claude Code</span><select id=d-claude-code data-runtime-channel=claude_code aria-label="Claude Code billed by"><option value=auto selected>Detect automatically</option><option value=direct>Anthropic</option><option value=bedrock>AWS Bedrock</option><option value=vertex>Google Vertex</option></select></label>
+       <label><span>Claude Desktop</span><select id=d-claude-desktop data-runtime-channel=claude_desktop aria-label="Claude Desktop billed by"><option value=auto selected>Detect automatically</option><option value=direct>Anthropic</option><option value=bedrock>AWS Bedrock</option><option value=vertex>Google Vertex</option></select></label>
+      </div>
+     </details>
+     <details class=discountMore>
+      <summary>Let other tools set discounts</summary>
+      <p>A tool on this computer, such as your company's contract or billing sync, can read and change discounts through Token Meter's local API at <code>/api/v1/cost-discounts</code>, using the token in <code>~/.token-meter/api-token</code>. Its changes appear in the table with the tool's name.</p>
+      <button class=tbtn type=button id=discount-rotate>Issue a new token</button>
+     </details>
+    </section>
+	  </div>
+   </section>
+	  <div class=spendKpis>
+	   <div class="card spendKpi metric"><div class=label>Selected-period spend</div><div class="v mono" id=s-total>--</div><div class=subline id=s-total-note></div></div>
+	   <div class="card spendKpi metric"><div class=label>Daily average</div><div class="v mono" id=s-average>--</div><div class=subline id=s-average-note></div></div>
+	   <div class="card spendKpi metric"><div class=label>Top platform</div><div class="v mono" id=s-top-runtime>--</div><div class=subline id=s-top-runtime-note></div></div>
+	   <div class="card spendKpi metric"><div class=label>Highest day</div><div class="v mono" id=s-highest-day>--</div><div class=subline id=s-highest-day-note></div></div>
+	  </div>
+	  <section class=goalsSection id=spend-goals aria-labelledby=spend-goals-heading><div class=goalsHead><h2 id=spend-goals-heading tabindex=-1>Spend goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=spend-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div></section>
+	  <section class="card spendChartCard">
+	   <div class=spendChartHead><div><h2>Spend trend</h2><p id=s-chart-note>Line = average</p></div><div class=spendChartControls><div class=seg id=s-granularity role=group aria-label="Group spend by"><button type=button class=on aria-pressed=true data-spend-granularity=day>Day</button><button type=button aria-pressed=false data-spend-granularity=week>Week</button><button type=button aria-pressed=false data-spend-granularity=month>Month</button></div><div class=spendLegend id=s-legend></div></div></div>
+	   <div class=spendChart id=s-chart aria-label="Spend trend"><div class="spendYAxis mono" id=s-y-axis aria-hidden=true></div><div class=spendPlot><div class=spendGrid aria-hidden=true></div><div class=spendChartInner id=s-chart-inner></div><div class=spendAverageLine id=s-average-line hidden aria-hidden=true><span class=mono></span></div></div></div>
+	   <div class="spendChartTip chartTip" id=s-chart-tip tabindex=0 hidden aria-live=polite></div>
+	  </section>
+	  <div class=spendEvidenceGrid>
+	   <section class="card spendLogsCard"><div class=spendPanelHead><div><h2>Highest-cost logs</h2><span id=s-log-day></span></div><span id=s-log-count></span></div><div class=spendLogs id=s-logs></div></section>
+	   <section class="card spendPlatformCard"><h2>Platform split</h2><div class=spendPlatformBody id=s-platforms></div></section>
+	  </div>
+	  <section class=spendInsightSection aria-labelledby=s-insight-title>
+	   <div class=spendInsightHead><div><h2 id=s-insight-title>Session economics</h2><p>Concentration, typical sessions, and outliers.</p></div><div class=spendInsightRange id=s-insights-range></div></div>
+	   <div class=spendInsightGrid>
+	    <section class="card spendConcentrationCard"><div class=spendInsightCardHead><div><h3>Spend concentration</h3><p>Top 10% of cost-covered sessions.</p></div></div><div class=spendConcentrationValue id=s-concentration>--</div><div class=spendConcentrationNote id=s-concentration-note>Loading range evidence…</div><div class=spendConcentrationBar id=s-concentration-bar role=progressbar aria-label="Share of spend from the top ten percent of sessions" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0><i></i></div><div class=spendConcentrationLegend><span>Top decile</span><span>Remaining sessions</span></div><div class=spendImpactList id=s-concentration-sessions></div></section>
+	    <section class="card spendShapeCard"><div class=spendInsightCardHead><div><h3 class=fieldtip tabindex=0 aria-description="Period cost · other measures are full-session totals." data-tip="Period cost · other measures are full-session totals.">Session shape</h3></div></div><div class=spendShape id=s-shape><div class="spendShapeEmpty emptyState">Loading session distributions…</div></div></section>
+	   </div>
+	   <section class="card spendScatterCard" id=s-scatter><div class=spendInsightCardHead><div><h3>Cost and input by active time</h3></div><div class=spendScatterControls><span class=spendScatterCoverage id=s-scatter-coverage></span><div class=seg id=s-scatter-metric aria-label="Outlier map metric"><button data-scatter-metric=cost>Spend</button><button data-scatter-metric=input>Processed input</button></div></div></div><div class=spendScatterWrap><svg class=spendScatterSvg id=s-scatter-svg viewBox="0 0 1040 340" preserveAspectRatio=none role=img aria-label="Session spend by active time"></svg><div class="spendScatterTip chartTip" id=s-scatter-tip hidden></div></div><div class=spendScatterLegend><span><i></i>Session</span><span><i class=spendScatterTopDot></i>Top-decile spend</span><span id=s-scatter-missing hidden>Requires active-time and selected-metric evidence.</span></div></section>
+	  </section>
+	 </div>
+
diff --git a/dashboard/markup/subagents-models.html b/dashboard/markup/subagents-models.html
new file mode 100644
index 00000000..97932e84
--- /dev/null
+++ b/dashboard/markup/subagents-models.html
@@ -0,0 +1,52 @@
+	 <div class=view id=view-subagents>
+	  <div class="spectrumPageHeadFrame hasPageActions">
+	   <div class="spectrumPageHead subagentPageHead" data-page-signal=subagents>
+	    <div class=spectrumPageHeadCopy><h1>Subagents</h1><p class=spectrumPageSubtitle>Track the cost of your custom agents.</p></div>
+	   </div>
+	   <div class=spectrumPageActions><span class=subagentExplorerMeta id=subagent-explorer-meta hidden></span></div>
+	  </div>
+	  <div id=subagent-page-home></div>
+	 </div>
+
+	 <div class=view id=view-models>
+	  <div class="spectrumPageHeadFrame hasPageActions">
+	   <div class="modelHead spectrumPageHead" data-page-signal=models>
+	    <div class=spectrumPageHeadCopy><h1>Models</h1></div>
+	   </div>
+	   <div class=spectrumPageActions><div class=modelControls>
+	    <label class=filterControl><span>Project</span><select class=filterSelect id=m-project aria-label="Model performance project filter"><option value="">All projects</option></select></label>
+	    <div class=filterControl><span>Models</span><details class=modelPicker id=m-model-picker><summary aria-label="Choose models to compare"><span id=m-model-summary>All models</span></summary><div class=modelPickerMenu id=m-model-options role=group aria-label="Models to compare"></div></details></div>
+	    <label class=filterControl><span>History</span><select class=filterSelect id=m-range aria-label="Models history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
+	   </div></div>
+	  </div>
+	  <div class=modelScopeStatus id=m-project-status aria-live=polite></div>
+	  <section class="card modelSpend" id=m-spend aria-labelledby=m-spend-title>
+   <div class=modelSpendHead><h2 id=m-spend-title>Where your spend goes</h2><span class=modelSpendTotal id=m-spend-total>--</span></div>
+   <div class=modelSpendBar id=m-spend-bar role=group aria-label="Estimated spend share by model"></div>
+   <div class=modelSpendLegend id=m-spend-legend></div>
+   <p class=modelSpendNote id=m-spend-note></p>
+  </section>
+  <div class="card modelTrendCard modelMixCard">
+   <div class=modelTrendHead><div><h2>Model mix over time</h2><p id=m-mix-note></p></div><div class=modelTrendControls><div class=seg id=m-mix-metric><button data-model-mix=cost>Cost</button><button data-model-mix=output>Output</button><button data-model-mix=executions>Executions</button></div></div></div>
+   <div class=modelChartWrap><svg class=modelChart id=m-mix viewBox="0 0 1040 250" preserveAspectRatio="none" role=img aria-label="Daily model mix"></svg><div class="modelChartTip chartTip" id=m-mix-tip tabindex=0 aria-label="Model mix for hovered day"></div></div>
+  </div>
+  <div class="card modelTrendCard modelSpeedCard" id=m-speedchart>
+   <div class=modelTrendHead><div><h2 class=fieldtip tabindex=0 aria-description="3-calendar-day weighted average of output tokens per second. By default, the top models by spend that have timing evidence." data-tip="3-calendar-day weighted average of output tokens per second. By default, the top models by spend that have timing evidence.">Speed over time</h2><p id=m-speedchart-note></p></div><div class=modelTrendControls><div class=filterControl><span>Models</span><details class=modelPicker id=m-speedchart-picker><summary aria-label="Choose models for the speed chart"><span id=m-speedchart-summary>Top 5 by spend</span></summary><div class=modelPickerMenu id=m-speedchart-options role=group aria-label="Models in the speed chart"></div></details></div><button class=tbtn id=m-speedchart-reset type=button>Reset to top 5</button></div></div>
+   <div class=modelSpeedLegend id=m-speedchart-legend></div>
+   <div class=modelChartWrap><svg class=modelChart id=m-speedchart-svg viewBox="0 0 1040 250" preserveAspectRatio="none" role=img aria-label="Smoothed daily output speed by model"></svg><div class="modelChartTip chartTip" id=m-speedchart-tip tabindex=0 aria-label="Model speed for hovered day"></div></div>
+  </div>
+  <div class="card pad modelTableWrap"><table class="tbl modelBoard" id=m-table><thead><tr><th class=modelRankCol>#</th><th><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=model data-tip="One model in one runtime. The same model can appear more than once when it ran through Claude Code, Claude Desktop, Claude-3P, Codex, or Cursor. Reasoning-effort variants are grouped under it; expand a row to see them. The log count covers all recorded history and does not change with the History filter." aria-description="One model in one runtime. The same model can appear more than once when it ran through Claude Code, Claude Desktop, Claude-3P, Codex, or Cursor. Reasoning-effort variants are grouped under it; expand a row to see them. The log count covers all recorded history and does not change with the History filter."><span>Model runtime</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=cost data-tip="Estimated cost in the selected window from local pricing. Bars are scaled to the top model; the percentage is its share of all estimated spend shown. * marks partial cost coverage." aria-description="Estimated cost in the selected window from local pricing. Bars are scaled to the top model; the percentage is its share of all estimated spend shown. * marks partial cost coverage."><span>Spend</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=cost_per_exec data-tip="Estimated cost divided by priced model executions in the window. * marks partial cost coverage." aria-description="Estimated cost divided by priced model executions in the window. * marks partial cost coverage."><span>$/exec</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=cache data-tip="Cache-read tokens divided by cache-covered input tokens. Higher usually means cheaper repeated context." aria-description="Cache-read tokens divided by cache-covered input tokens. Higher usually means cheaper repeated context."><span>Cache hit</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=executions data-tip="Trace-reported model response cycles in the selected history window. A single user turn can contain multiple model calls." aria-description="Trace-reported model response cycles in the selected history window. A single user turn can contain multiple model calls."><span>Executions</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=output data-tip="Trace-reported model output, or a Cursor estimate from model-authored text persisted in local bubbles; local token proxies are not comparable with trace-reported totals." aria-description="Trace-reported model output, or a Cursor estimate from model-authored text persisted in local bubbles; local token proxies are not comparable with trace-reported totals."><span>Output</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=speed data-tip="Average output speed in tokens per second: timed model output divided by timed generation seconds. Tool-free timing is preferred; otherwise end-to-end timing is used. Diagnostic, not a model verdict." aria-description="Average output speed in tokens per second: timed model output divided by timed generation seconds. Tool-free timing is preferred; otherwise end-to-end timing is used. Diagnostic, not a model verdict."><span>Speed</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=wait data-tip="Median prompt-to-completed-response wait. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded." aria-description="Median prompt-to-completed-response wait. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded."><span>Typical wait</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=pushback data-tip="Estimated from Work insights' local labels: how often your next prompt pushed back on this model's answer. Each request is credited to the model that answered it. Lower is better. * marks fewer than 20 labeled follow-ups." aria-description="Estimated from Work insights' local labels: how often your next prompt pushed back on this model's answer. Each request is credited to the model that answered it. Lower is better. * marks fewer than 20 labeled follow-ups."><span>Pushback</span></button></th></tr></thead><tbody></tbody></table></div>
+  <details class="card modelDiagnostics" id=m-diagnostics>
+   <summary><span>Speed &amp; timing diagnostics</span></summary>
+   <div class="modelHero modelDiagHero">
+	   <div class="card modelKpi metric"><div class="label fieldtip modelHelp" id=m-speed-label tabindex=0 aria-description="Observed model output divided by attributable timing. Tool-free samples are preferred, but Claude traces do not expose time to first token, so cross-runtime output pace remains diagnostic rather than a model verdict." data-tip="Observed model output divided by attributable timing. Tool-free samples are preferred, but Claude traces do not expose time to first token, so cross-runtime output pace remains diagnostic rather than a model verdict.">Observed output pace</div><div class="v mono" id=m-speed>--</div><div class=subline id=m-speed-note>waiting for timing evidence</div><div class="modelCoverage fieldtip" id=m-coverage tabindex=0 role=progressbar aria-label="Output timing coverage" aria-description="The share of selected output backed by attributable timing. Low coverage means observed tok/s may not represent the full history." aria-valuemin=0 aria-valuemax=100 aria-valuenow=0 data-tip="The share of selected output backed by attributable timing. Low coverage means observed tok/s may not represent the full history."><i id=m-coverage-bar></i></div></div>
+	   <div class="card modelKpi metric"><div class="label fieldtip modelHelp" id=m-change-label tabindex=0 aria-description="Pairwise end-to-end pace after matching completed turns on peak context, cumulative input, output, cache-read share, model calls, tool shape, and recency. A ratio above 1 favors the named faster runtime; a confidence interval crossing 1 means the evidence cannot separate them. Requires at least 20 matched pairs and 30% coverage of the smaller history." data-tip="Pairwise end-to-end pace after matching completed turns on peak context, cumulative input, output, cache-read share, model calls, tool shape, and recency. A ratio above 1 favors the named faster runtime; a confidence interval crossing 1 means the evidence cannot separate them. Requires at least 20 matched pairs and 30% coverage of the smaller history.">Matched pace</div><div class="v mono" id=m-change>--</div><div class="subline modelDelta" id=m-change-note>Select 2 models</div></div>
+	   <div class="card modelKpi metric"><div class="label fieldtip modelHelp" id=m-wait-label tabindex=0 aria-description="Median prompt-to-completed-response wait for timed requests. Lower is better. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded. The median is primary because the average can be pulled upward by a few very long turns." data-tip="Median prompt-to-completed-response wait for timed requests. Lower is better. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded. The median is primary because the average can be pulled upward by a few very long turns.">Typical wait</div><div class="v mono" id=m-wait>--</div><div class=subline id=m-wait-note>Timing unavailable</div></div>
+   </div>
+  <div class="modelTrendCard modelDiagTrend">
+	   <div class=modelTrendHead><div><h2 class=fieldtip id=m-trend-title tabindex=0 aria-description="In this chart, bars show output; lines show the selected metric, including observed tok/s for output pace." data-tip="In this chart, bars show output; lines show the selected metric, including observed tok/s for output pace.">Model trends</h2><p id=m-trend-note></p></div><div class=modelTrendControls><div class=seg id=m-metric><button data-model-metric=speed>Output pace</button><button data-model-metric=wait>Output wait</button><button data-model-metric=avg_input>Avg input</button><button data-model-metric=avg_output>Avg output</button></div></div></div>
+	   <div class=modelChartWrap><svg class=modelChart id=m-chart viewBox="0 0 1040 270" preserveAspectRatio="none" role=img aria-label="Daily model trends and output token volume"></svg><div class="modelChartTip chartTip" id=m-chart-tip tabindex=0 aria-label="Model details for hovered day"></div></div>
+	  </div>
+  </details>
+	 </div>
+
diff --git a/dashboard/page.manifest b/dashboard/page.manifest
new file mode 100644
index 00000000..1c93a979
--- /dev/null
+++ b/dashboard/page.manifest
@@ -0,0 +1,45 @@
+# Dashboard page parts, in serving order. The server concatenates these files
+# byte for byte into the single page it serves; see token_meter/dashboard_page.py.
+# Paths are relative to this directory.
+head.html
+styles/base.css
+styles/themes.css
+styles/components.css
+styles/shell.css
+styles/motion-sessions.css
+styles/tools.css
+styles/git.css
+styles/sessions-subagents.css
+styles/models-learn.css
+markup/shell.html
+markup/subagents-models.html
+markup/spend.html
+markup/efficiency-work.html
+markup/git-learn-tools.html
+markup/settings.html
+js/core.js
+js/deck.js
+js/theme-navigation.js
+js/goals.js
+js/router.js
+js/notifications-settings.js
+js/budgets-discounts.js
+js/agent-access.js
+js/session-budgets-filters.js
+js/charts.js
+js/session-detail.js
+js/capabilities.js
+js/spend.js
+js/motion-readouts.js
+js/git.js
+js/work-status.js
+js/work-insights.js
+js/efficiency.js
+js/models.js
+js/session-logs-compare.js
+js/subagents.js
+js/subagents-explorer.js
+js/all-sessions.js
+js/current-sessions.js
+js/live.js
+tail.html
diff --git a/dashboard/styles/base.css b/dashboard/styles/base.css
new file mode 100644
index 00000000..364fddc3
--- /dev/null
+++ b/dashboard/styles/base.css
@@ -0,0 +1,71 @@
+:root{
+ color-scheme:dark;
+ /* == Fixed palette: identical in every theme; hue hex plus rgb channels for rgb(var(--x-rgb)/alpha) tints == */
+ --white:#fff; --black:#000; --tint-rgb:255 255 255; --shade-rgb:0 0 0;
+ --pink:#f08cae; --pink-rgb:240 140 174;
+ --orange:#ffb457; --orange-rgb:255 180 87;
+ --green:#66d990; --green-rgb:102 217 144;
+ --red:#ff6f6f; --red-rgb:255 111 111;
+ /* == Lines: tinted by the theme line hue == */
+ --line:rgb(var(--line-rgb)/.09); --line2:rgb(var(--line-rgb)/.17); --line3:rgb(var(--line-rgb)/.24);
+ /* == Semantic states: never themed == */
+ --accent:var(--signal); --good:var(--green); --warn:var(--orange); --bad:var(--red);
+ --bad-text:#ffaaaa; --bad-text-strong:#ffd0d0; --bad-deep-rgb:91 30 35; --bad-ink-rgb:42 23 24;
+ /* == Data series that keep their meaning across themes == */
+ --coord:var(--signal-mid); --c-cache-read:#66d990; --c-cache-write:#ffb457; --c-context:var(--fg); --c-deleted:#5c7d92;
+ --chart-cost-fill:rgb(var(--c-cost-rgb)/.24); --chart-grid:rgb(var(--signal-rgb)/.16);
+ --chart-tip:var(--bg-deep); --chart-tip-head:rgb(var(--signal-rgb)/.16); --chart-tip-line:rgb(var(--tint-rgb)/.42);
+ /* == Ordered (Bayer 4x4) dither masks: 50% coverage in 2px cells; color comes from the masked fill == */
+ --dither-50:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='4' height='4'%3E%3Crect width='2' height='2'/%3E%3Crect x='2' y='2' width='2' height='2'/%3E%3C/svg%3E");
+ /* == Provider identity: one color per runtime for cards, Spend, badges, budgets, and model families == */
+ --provider-claude:#e3825c; --provider-claude-rgb:227 130 92;
+ --provider-codex:#6f9cff; --provider-codex-rgb:111 156 255;
+ --provider-cursor:#3cc6c0; --provider-cursor-rgb:60 198 192;
+ --provider-opencode:#ff8fb8; --provider-opencode-rgb:255 143 184;
+ --provider-kiro:#e3cc5c; --provider-kiro-rgb:227 204 92; --provider-other:#8b96a3;
+ --badge-neutral:#d5dce5; --badge-neutral-rgb:213 220 229;
+ /* == Theme swatches for the Appearance picker == */
+ --swatch-classic:linear-gradient(132deg,#00bceb,#7fdbf2 38%,#6d7bff 68%,#c7a7ff); --swatch-classic-bg:#07090c;
+ --swatch-nebula:linear-gradient(132deg,#9d8bff,#ff7ad9 38%,#7ef3ff 68%,#64ffda); --swatch-nebula-bg:#07061a;
+ --swatch-monolith:linear-gradient(132deg,#e4e7ee,#a7aebd 48%,#fff 82%,#ff6a3d); --swatch-monolith-bg:#09090a;
+ --swatch-voltage:linear-gradient(132deg,#f5e63d,#ffd23f 34%,#ff3df2 66%,#2ee6ff); --swatch-voltage-bg:#0a0907;
+ --swatch-phosphor:linear-gradient(132deg,#3dfc8f,#19d97a 40%,#c6ff4d 72%,#4dd2ff); --swatch-phosphor-bg:#040a06;
+ --swatch-omarchy:linear-gradient(132deg,#7aa2f7,#bb9af7 40%,#7dcfff 72%,#ff9e64); --swatch-omarchy-bg:#14151d;
+ --swatch-jadehorse:linear-gradient(132deg,#8bcbb1,#a7dfc5 40%,#96b7d0 72%,#c5cc91); --swatch-jadehorse-bg:#0c1a16;
+ --swatch-ferrous:linear-gradient(132deg,#ff5a36,#ffa27a 38%,#ffb36b 66%,#5ee6d8); --swatch-ferrous-bg:#0f0705;
+ --swatch-afterglow:linear-gradient(132deg,#ff5fa2,#ff8a5c 40%,#ffc775 70%,#8f7bff); --swatch-afterglow-bg:#0b0510;
+ /* == Type: families, size scale (11px floor), weights == */
+ --font-sans:-apple-system,BlinkMacSystemFont,"Segoe UI",Inter,system-ui,sans-serif; --font-mono:ui-monospace,"SF Mono",SFMono-Regular,Menlo,monospace;
+ --font-display:"Tektur Local","Avenir Next Condensed",-apple-system,BlinkMacSystemFont,sans-serif;
+ --fs-11:11px; --fs-12:12px; --fs-13:13px; --fs-14:14px; --fs-16:16px; --fs-18:18px; --fs-20:20px; --fs-22:22px; --fs-24:24px; --fs-28:28px; --fs-36:36px; --fs-44:44px; --fs-56:56px;
+ --fs-hero-fluid:clamp(36px,4.2vw,54px); --fs-readout-xl:clamp(32px,3.4vw,44px); --fs-readout-lg:clamp(28px,3.2vw,40px);
+ --fs-readout-md:clamp(18px,1.6vw,23px); --fs-readout-sm:clamp(16px,1.2vw,19px);
+ --fw-medium:500; --fw-semibold:600; --fw-bold:700; --fw-heavy:800;
+ /* == Shape: the corner scale itself is themed; pill and round stay fixed == */
+ --radius-pill:999px; --radius-round:50%;
+ --focus-ring:0 0 0 3px rgb(var(--signal-rgb)/.14);
+ /* == Depth == */
+ --tip-bg:linear-gradient(180deg,rgb(var(--bg-deep-rgb)/.98),rgb(var(--bg2-rgb)/.98)); --shadow-tip:0 16px 36px rgb(var(--shade-rgb)/.5);
+ --shadow:0 1px 0 rgb(var(--tint-rgb)/.055),0 18px 48px rgb(var(--shade-rgb)/.36);
+ --shadow-soft:0 1px 0 rgb(var(--tint-rgb)/.045),0 10px 28px rgb(var(--shade-rgb)/.22);
+ --inset:inset 0 1px 0 rgb(var(--tint-rgb)/.045);
+ /* == Spectrum system: shared atmosphere, cards, controls, active state; built only from theme tokens == */
+ --spectrum-border:rgb(var(--signal-rgb)/.2);--spectrum-border-strong:rgb(var(--signal-hi-rgb)/.38);
+ --spectrum-edge-light:rgb(var(--signal-pale-rgb)/.2);--spectrum-edge-hover:rgb(var(--signal-hi-rgb)/.52);
+ --spectrum-page:radial-gradient(ellipse 72% 48% at 13% -9%,rgb(var(--signal-rgb)/calc(.26*var(--glow))),transparent 62%),radial-gradient(ellipse 56% 42% at 96% 2%,rgb(var(--aura-rgb)/calc(.17*var(--glow))),transparent 60%),radial-gradient(ellipse 44% 34% at 58% 38%,rgb(var(--flare-rgb)/calc(.07*var(--glow))),transparent 70%),radial-gradient(ellipse 56% 38% at 68% 105%,rgb(var(--signal-mid-rgb)/calc(.13*var(--glow))),transparent 68%),linear-gradient(155deg,var(--bg-deep) 0%,var(--bg-lift) 42%,var(--bg2) 68%,var(--bg) 100%);
+ --spectrum-card:radial-gradient(ellipse 82% 90% at 102% -8%,rgb(var(--signal-hi-rgb)/calc(.1*var(--glow))),transparent 58%),radial-gradient(ellipse 74% 74% at -8% 108%,rgb(var(--aura-rgb)/calc(.08*var(--glow))),transparent 62%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.97),rgb(var(--panel-rgb)/.97) 55%,rgb(var(--bg2-rgb)/.98));
+ --spectrum-control:radial-gradient(circle at 88% 0,rgb(var(--signal-hi-rgb)/calc(.08*var(--glow))),transparent 46%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg2-rgb)/.98));
+ --spectrum-active:linear-gradient(132deg,var(--signal) 0%,var(--signal-mid) 48%,var(--signal-hi) 100%);
+ --spectrum-active-hover:linear-gradient(132deg,color-mix(in srgb,var(--signal) 86%,var(--white)) 0%,color-mix(in srgb,var(--signal-mid) 86%,var(--white)) 46%,color-mix(in srgb,var(--signal-hi) 86%,var(--white)) 100%);
+ --spectrum-foil:linear-gradient(90deg,transparent,var(--signal) 18%,var(--signal-hi) 40%,var(--flare) 60%,var(--aura) 80%,transparent);
+ --spectrum-glow:0 0 0 1px rgb(var(--signal-hi-rgb)/.34),0 8px 26px rgb(var(--signal-rgb)/calc(.34*var(--glow))),inset 0 1px 0 rgb(var(--tint-rgb)/.38);
+ --spectrum-ease:cubic-bezier(.16,1,.3,1);
+ /* == Motion: strong curves; UI stays under 300ms, data explanation may run longer == */
+ --ease-out:cubic-bezier(.23,1,.32,1); --ease-in-out:cubic-bezier(.77,0,.175,1);
+ --dur-press:160ms; --dur-enter:320ms; --dur-data:480ms;
+ --grain:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='180' height='180'%3E%3Cfilter id='g'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='.85' numOctaves='2' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 .6 0'/%3E%3C/filter%3E%3Crect width='180' height='180' filter='url(%23g)'/%3E%3C/svg%3E");
+ --spectrum-shadow:0 1px 0 var(--spectrum-edge-light),0 16px 38px rgb(var(--shade-rgb)/.32),0 5px 16px rgb(var(--signal-rgb)/calc(.06*var(--glow)));
+ --spectrum-depth-focus:0 1px 0 rgb(var(--signal-pale-rgb)/.22),0 20px 46px rgb(var(--shade-rgb)/.38),0 8px 28px rgb(var(--signal-rgb)/calc(.13*var(--glow)));
+  /* == Work insights: work-type, tier, effort, and outcome hues == */
+  --w1:#079bc2; --w2:#c17a01; --w3:#c36b95; --w4:#af851e; --w5:#9979cd; --w6:#d66555; --w7:#5f8adf; --w8:#05a386; --w-unclear:#56606d; --w-routine-2:#2a8fb4; --w-routine-3:#1d5f7a; --w-routine-4:#334050; --w-pending:#2c3541; --w-tier-light:#05a386; --w-tier-standard:#5f8adf; --w-tier-premium:#c17a01; --w-e1:#644493; --w-e2:#7858a9; --w-e3:#8d6dc0; --w-e4:#a282d7; --w-e5:#b798ee; --w-e6:#ccb0ff; --w-accepted:var(--good); --w-recovered:var(--warn); --w-ended:var(--bad); --w-single:var(--w-unclear);
+}
diff --git a/dashboard/styles/components.css b/dashboard/styles/components.css
new file mode 100644
index 00000000..92fd0dcb
--- /dev/null
+++ b/dashboard/styles/components.css
@@ -0,0 +1,495 @@
+/* == Components: shared building blocks. :where() gives them zero specificity, so any screen rule overrides them. They own identity (color, type, tracking), not layout. == */
+:where(.emptyState){display:grid;place-items:center;align-content:center;gap:4px;padding:18px;color:var(--dim);font-size:var(--fs-12);line-height:1.45;text-align:center}
+:where(.emptyState)[hidden]{display:none}
+:where(.emptyState>strong,.emptyState>h3){display:block;margin:0;color:var(--fg);font-size:var(--fs-13)}
+:where(.emptyState>p){max-width:56ch;margin:0 auto}
+:where(.metric){min-width:0}
+:where(.metric>span:first-child,.metric>.label){display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
+:where(.metric>strong,.metric>b,.metric>.v){display:block;margin-top:4px;color:var(--fg);font-family:var(--font-mono);font-size:var(--fs-16);font-weight:var(--fw-heavy);font-variant-numeric:tabular-nums}
+:where(.metric>small,.metric>.subline,.metric>.sm){display:block;margin-top:2px;color:var(--dim);font-size:var(--fs-11)}
+:where(.chartTip){position:absolute;pointer-events:none;border:1px solid rgb(var(--signal-rgb)/.42);border-radius:var(--radius-md);background:var(--tip-bg);box-shadow:var(--shadow-tip);color:var(--dim)}
+:where(.valueWithDelta){display:flex;flex-wrap:wrap;align-items:center;gap:6px 16px;min-width:0}
+@media(max-width:1180px){:where(.valueWithDelta){gap:6px 10px}}
+:where(.trendDelta){display:grid;justify-items:start;gap:2px;color:var(--dim);line-height:1.15}
+:where(.trendDelta)[hidden]{display:none}
+:where(.trendDelta>strong){font-family:var(--font-mono);font-size:var(--fs-20);font-weight:var(--fw-heavy);font-variant-numeric:tabular-nums;white-space:nowrap}
+:where(.trendDelta>span){max-width:16ch;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+:where(.trendDelta[data-tone=improving]>strong){color:var(--good)}
+:where(.trendDelta[data-tone=degrading]>strong){color:var(--bad)}
+:where(.trendDelta[data-direction=""]>strong){color:var(--faint);font-family:var(--font-sans);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+:where(.readoutScale){--scale-tone:var(--signal);position:relative;display:block;height:8px;margin-top:8px;border-radius:var(--radius-2xs);background:rgb(var(--tint-rgb)/.06)}
+:where(.readoutScale)[hidden]{display:none}
+:where(.readoutScale[data-tone=high]){--scale-tone:var(--warn)}
+:where(.readoutScale>.readoutScaleFill){position:absolute;inset:0 auto 0 0;width:var(--at,0%);border-radius:inherit;background:var(--scale-tone);-webkit-mask:var(--dither-50) 0 0/4px 4px;mask:var(--dither-50) 0 0/4px 4px;transition:width var(--dur-data) var(--ease-out)}
+:where(.readoutScale>.readoutScaleTypical){position:absolute;top:-3px;bottom:-3px;left:var(--typ,50%);width:2px;border-radius:var(--radius-2xs);background:var(--soft);transform:translateX(-50%)}
+:where(.readoutScale>.readoutScaleMark){position:absolute;top:-2px;bottom:-2px;left:var(--at,0%);width:4px;border-radius:var(--radius-2xs);background:var(--scale-tone);box-shadow:0 0 10px var(--scale-tone);transform:translateX(-50%);transition:left var(--dur-data) var(--ease-out)}
+:where(.readoutCaption){display:block;margin-top:6px;color:var(--soft);font-size:var(--fs-12);font-weight:var(--fw-medium);line-height:1.35}
+:where(.readoutCaption)[hidden]{display:none}
+:where(.chartGapBridge){fill:none;stroke:var(--faint);stroke-width:1.5;stroke-dasharray:2 4;stroke-linecap:round}
+:where(.readoutCaption)::before{content:"› ";color:var(--signal);font-family:var(--font-mono);font-weight:var(--fw-heavy)}
+:where(.conceptFrame){display:grid;align-content:start;gap:16px;min-width:0;margin:0;padding:20px;border:1px solid var(--spectrum-border);border-radius:var(--radius-lg);background:var(--spectrum-card);box-shadow:var(--spectrum-shadow);color:var(--fg)}
+:where(.conceptFrame)[hidden]{display:none}
+:where(.conceptFrame>.conceptFrameHead){display:flex;align-items:center;justify-content:space-between;gap:8px;min-height:22px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
+:where(.conceptFrame>.conceptFrameHead>.chip){letter-spacing:0;text-transform:none}
+:where(.conceptFrame>.conceptFrameStage){position:relative;display:grid;gap:12px;min-width:0}
+:where(.conceptFrame>.conceptFrameStage [data-callout]){position:relative}
+:where(.conceptFrame>figcaption){margin:0;padding-top:14px;border-top:1px solid var(--line)}
+:where(.frameCallout){display:inline-grid;flex:none;place-items:center;width:24px;height:24px;border:2px solid var(--bg-deep);border-radius:var(--radius-round);background:var(--spectrum-active);box-shadow:var(--spectrum-glow);color:var(--on-accent);font:var(--fw-heavy) var(--fs-12)/1 var(--font-mono);font-style:normal;letter-spacing:0;text-transform:none;vertical-align:middle}
+:where(.frameCallout)[hidden]{display:none}
+:where(.frameCallout[data-at]){position:absolute;z-index:3}
+:where(.frameCallout[data-at=tr]){top:-12px;right:-12px}
+:where(.frameCallout[data-at=tl]){top:-12px;left:-12px}
+:where(.frameCallout[data-at=t]){top:-14px;left:50%;transform:translateX(-50%)}
+:where(.frameCallout[data-at=r]){top:50%;right:-32px;transform:translateY(-50%)}
+:where(.frameCallout[data-at=l]){top:50%;left:-32px;transform:translateY(-50%)}
+:where(.frameCallout[data-at=bar]){bottom:calc(var(--bar-h) + 6px);left:50%;transform:translateX(-50%)}
+:where(.frameLegend){display:grid;gap:10px;margin:0;padding:0;list-style:none}
+:where(.frameLegend)[hidden]{display:none}
+:where(.frameLegend>li){display:grid;grid-template-columns:24px minmax(0,1fr);align-items:center;gap:12px;color:var(--fg);font-size:var(--fs-14);font-weight:var(--fw-medium);line-height:1.4}
+:where(.levelBar){--level-tone:var(--spectrum-active);position:relative;display:block;height:8px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.07)}
+:where(.levelBar)[hidden]{display:none}
+:where(.levelBar[data-tone=warn]){--level-tone:var(--warn)}
+:where(.levelBar>i){display:block;width:var(--fill,0%);min-width:2px;height:100%;border-radius:inherit;background:var(--level-tone);transition:width var(--dur-data) var(--ease-out)}
+:where(.levelBar>b){position:absolute;top:-4px;bottom:-4px;left:var(--mark,0%);width:2px;border-radius:var(--radius-2xs);background:var(--fg);transform:translateX(-50%)}
+@media(prefers-reduced-motion:reduce){:where(.readoutScale>i){transition:none}}
+.badge.codex{color:var(--provider-codex);border-color:rgb(var(--provider-codex-rgb)/.42);background:rgb(var(--provider-codex-rgb)/.08)}
+.badge.claude{color:var(--provider-claude);border-color:rgb(var(--provider-claude-rgb)/.42);background:rgb(var(--provider-claude-rgb)/.08)}
+.badge.cursor{color:var(--provider-cursor);border-color:rgb(var(--provider-cursor-rgb)/.44);background:rgb(var(--provider-cursor-rgb)/.08)}
+.badge.opencode{color:var(--provider-opencode);border-color:rgb(var(--provider-opencode-rgb)/.42);background:rgb(var(--provider-opencode-rgb)/.08)}
+.badge.kiro{color:var(--provider-kiro);border-color:rgb(var(--provider-kiro-rgb)/.42);background:rgb(var(--provider-kiro-rgb)/.08)}
+.srow .subagentTag{display:inline-block;margin-right:6px;padding:1px 6px;font-size:var(--fs-11);font-weight:var(--fw-bold);letter-spacing:.03em;vertical-align:1px;color:var(--aura);border-color:rgb(var(--aura-rgb)/.34);background:rgb(var(--aura-rgb)/.08)}
+/* Child-agent subsection inside a parent session card. The parent row stays a
+   single button; children are their own buttons nested in a non-interactive
+   container so a child click never double-fires the parent navigation. */
+.subagents{margin-top:10px;padding:10px 12px 8px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.022);display:grid;gap:6px;min-width:0}
+.subagentsHead{display:flex;align-items:center;justify-content:space-between;gap:10px;min-width:0}
+.subagentsTitle{display:inline-flex;align-items:center;gap:6px;font-size:var(--fs-11);font-weight:var(--fw-bold);text-transform:uppercase;letter-spacing:.06em;color:var(--faint);min-width:0}
+.subagentsTitle b{color:var(--dim);font-weight:var(--fw-bold);letter-spacing:0}
+.subagentsStats{font-size:var(--fs-12);color:var(--faint);white-space:nowrap;font-variant-numeric:tabular-nums}
+.subagentsStats b{color:var(--fg);font-weight:var(--fw-heavy)}
+.subagentList{display:grid;gap:4px;min-width:0}
+.subagentRow{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:10px;align-items:center;width:100%;text-align:left;font:inherit;color:inherit;background:rgb(var(--tint-rgb)/.028);border:1px solid transparent;border-radius:var(--radius-sm);padding:6px 8px;cursor:pointer;min-width:0;transition:border-color .16s,background .16s}
+.subagentRow:hover,.subagentRow:focus-visible{border-color:rgb(var(--signal-rgb)/.34);background:rgb(var(--signal-rgb)/.07);outline:none}
+.subagentMain{min-width:0;overflow:hidden}
+.subagentMain .t{font-size:var(--fs-13);font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentMain .meta{font-size:var(--fs-11);color:var(--faint);margin-top:2px;display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}
+.subagentRole{display:inline-flex;align-items:center;border:1px solid rgb(var(--pink-rgb)/.34);background:rgb(var(--pink-rgb)/.11);color:var(--pink);border-radius:var(--radius-xs);padding:1px 6px;font-size:var(--fs-11);font-weight:var(--fw-bold);margin-right:6px;white-space:nowrap;vertical-align:1px}
+.subagentTokens{font-size:var(--fs-12);color:var(--dim);white-space:nowrap;font-variant-numeric:tabular-nums}
+.subagentCost{font-size:var(--fs-13);font-weight:var(--fw-heavy);text-align:right;white-space:nowrap;font-variant-numeric:tabular-nums}
+.subagentZero{font-weight:var(--fw-semibold);color:var(--faint)}
+.subagentMore{font-size:var(--fs-11);color:var(--faint);padding:1px 2px}
+@media(max-width:1100px){.subagentRow{grid-template-columns:minmax(0,1fr) auto}.subagentTokens{display:none}}
+.signalEmpty{min-height:112px;padding:18px}
+.settingsLexicon{box-shadow:var(--shadow-soft)}
+.settingsLexiconHead{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}
+.settingsLexicon h2{font-size:var(--fs-16);line-height:1.25;margin:4px 0}
+.settingsLexicon p{color:var(--dim);font-size:var(--fs-12);line-height:1.45;margin:0;max-width:420px}
+.settingsField{display:grid;gap:6px;margin-top:12px}
+.settingsField span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.settingsField textarea{width:100%;min-height:150px;resize:vertical;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-md);padding:8px 10px;font:var(--fs-12)/1.45 var(--font-mono);box-shadow:var(--inset)}
+.settingsField textarea:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.settingsStatus{width:100%;font-size:var(--fs-11);color:var(--faint)}
+.settingsStatus.good{color:var(--good)}
+.settingsStatus.warn{color:var(--warn)}
+.previewHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin:3px 0 14px}
+.previewHeadCopy{max-width:760px}
+.previewHead h1{font-size:var(--fs-28);line-height:1.08;margin:6px 0 0}
+.previewHead p{color:var(--dim);font-size:var(--fs-13);margin:6px 0 0}
+.previewHead p:empty{display:none}
+.previewRunMeta{display:flex;align-items:center;gap:8px;margin-bottom:10px;min-width:0}
+.sessionBackRow{display:flex;margin-bottom:10px}
+.sessionBack{display:inline-flex;align-items:center;gap:6px}
+.previewRunMeta .repo{max-width:460px}
+.previewRunGrid{display:grid;grid-template-columns:minmax(0,1.75fr) minmax(300px,.65fr);gap:12px;align-items:stretch}
+.previewChartSlot,.previewDecision{min-width:0}
+.previewChartSlot{display:grid}
+.previewChartSlot #session-chart-module{display:grid;grid-template-rows:auto minmax(0,1fr);gap:12px}
+.previewChartSlot .section-h,.previewDecision>.section-h{margin:0}
+.previewChartSlot #session-chart-module>.card{min-height:350px}
+.previewChartSlot .chart{height:286px}
+.previewDecision{display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:auto minmax(0,1fr) auto;gap:12px}
+.previewStatus{display:flex;flex-direction:column;overflow:hidden;padding:16px;background:linear-gradient(155deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98))}
+.previewStatus:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--good),var(--accent),transparent)}
+.previewStatus.warn:before{background:linear-gradient(90deg,var(--bad),var(--warn),transparent)}
+.previewStatusTop{display:flex;align-items:center;justify-content:space-between;gap:12px}
+.previewState{display:inline-flex;align-items:center;gap:6px;color:var(--good);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.05em}
+.previewState:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
+.previewStatus.warn .previewState{color:var(--bad)}
+.previewIdle{color:var(--faint);font-size:var(--fs-11)}
+.previewCost{font-size:var(--fs-readout-xl);font-weight:var(--fw-heavy);line-height:1.02;margin-top:12px;white-space:nowrap}
+.previewCostNote{color:var(--dim);font-size:var(--fs-12);margin-top:6px}
+.previewPressure{margin-top:16px;padding-top:12px;border-top:1px solid var(--line)}
+.previewStatus .previewPressure{margin-block:auto}
+.previewPressureHead{display:flex;align-items:baseline;justify-content:space-between;gap:10px;color:var(--dim);font-size:var(--fs-12)}
+.previewPressureHead b{color:var(--fg)}
+.previewPressureHead>span{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.04em}
+.previewPressureBar{height:7px;margin-top:6px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.07);overflow:hidden}
+.previewPressureBar i{display:block;width:0;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi));transition:width .2s}
+.previewRunBudgetSlot .sessionBudget{margin:0;box-shadow:var(--shadow-soft)}
+.previewRunBudgetSlot .sessionBudgetHead{align-items:flex-start;flex-direction:column;gap:8px}
+.previewRunBudgetSlot .sessionBudgetExact{width:100%;justify-content:space-between}
+.previewRunBudgetSlot .sessionBudgetTrack{grid-template-columns:52px minmax(0,1fr) 60px}
+.previewKpis{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:8px;margin-top:12px}
+.previewKpi{padding:12px 12px;min-height:92px}
+.previewKpi .v{font-size:var(--fs-20);margin-top:4px;overflow-wrap:anywhere}
+.previewKpi .sm{font-size:var(--fs-11);margin-top:3px}
+.previewStartText{font-size:var(--fs-14);font-weight:var(--fw-bold);line-height:1.45;margin-top:6px;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}
+.sessionChartModule{min-width:0}
+.previewChartColumn{display:grid;grid-template-rows:minmax(0,1fr) auto;gap:12px;min-width:0}
+.previewChartColumn .previewTokenSlot{margin-top:0}
+.previewTimes{display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-top:12px;padding-top:12px;border-top:1px solid var(--line)}
+.previewTimes div{min-width:0}
+.previewTimes span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.04em}
+.previewTimes b{display:block;margin-top:4px;color:var(--dim);font-size:var(--fs-11);line-height:1.5;overflow:hidden;text-overflow:ellipsis;white-space:pre}
+.previewKpis{grid-template-columns:repeat(4,minmax(0,1fr));gap:8px}
+.previewKpi{min-height:96px}
+.previewKpi .v{font-size:var(--fs-readout-md)}
+.settingsPageLayout{display:grid;gap:10px}
+.themePicker{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px;margin:14px 0 10px}
+.themeOption{display:grid;gap:8px;min-width:0;padding:8px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02);color:var(--fg);text-align:left;font:inherit;cursor:pointer;transition:border-color .16s,box-shadow .16s,transform .16s}
+.themeOption:hover{border-color:var(--spectrum-edge-hover);transform:translateY(-1px)}
+.themeOption[aria-pressed=true]{border-color:var(--signal-hi);box-shadow:var(--spectrum-glow)}
+.themePreview{position:relative;display:block;height:48px;overflow:hidden;border-radius:var(--radius-sm);background:var(--theme-swatch-bg);box-shadow:inset 0 0 0 1px rgb(var(--tint-rgb)/.08)}
+.themePreview i{position:absolute;display:block;left:10px}
+.themePreview i:nth-child(1){top:9px;width:42%;height:8px;border-radius:var(--radius-pill);background:var(--theme-swatch)}
+.themePreview i:nth-child(2){top:24px;width:58%;height:4px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.16)}
+.themePreview i:nth-child(3){right:10px;bottom:8px;height:18px;background:var(--theme-swatch);opacity:.55;-webkit-mask-image:repeating-linear-gradient(90deg,var(--black) 0 7px,transparent 7px 11px),linear-gradient(0deg,var(--black),transparent);mask-image:repeating-linear-gradient(90deg,var(--black) 0 7px,transparent 7px 11px),linear-gradient(0deg,var(--black),transparent);-webkit-mask-composite:source-in;mask-composite:intersect}
+.themeCopy{display:grid;gap:2px;min-width:0}
+.themeCopy b{font-family:var(--font-display);font-size:var(--fs-14);font-weight:var(--fw-semibold)}
+.themeCopy small{display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;overflow:hidden;color:var(--dim);font-size:var(--fs-12);line-height:1.35}
+.appearanceSettings kbd{padding:1px 4px;border:1px solid var(--line2);border-radius:var(--radius-xs);color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.35 var(--font-mono)}
+.settingsMap{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));align-items:stretch;padding:8px 10px;overflow:hidden}
+.settingsMap:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent)}
+.settingsMap button{width:100%;display:grid;grid-template-columns:25px minmax(0,1fr);gap:8px;align-items:center;text-align:left;border:0;border-left:1px solid var(--line);background:transparent;color:var(--dim);padding:6px 10px;font:inherit;cursor:pointer;border-radius:0}
+.settingsMap button:hover,.settingsMap button:focus-visible{color:var(--fg);background:rgb(var(--tint-rgb)/.03)}
+.settingsMap button>span:first-child{display:grid;place-items:center;width:23px;height:23px;border:1px solid var(--line2);border-radius:var(--radius-sm);color:var(--signal-hi);font:var(--fw-heavy) var(--fs-11)/1 var(--font-mono)}
+.settingsMap button b,.settingsMap button small{display:block}
+.settingsMap button b{font-size:var(--fs-12)}
+.settingsMap button small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium);margin-top:1px}
+.settingsPageContent{display:grid;gap:10px;min-width:0}
+.settingsPageContent>.card{scroll-margin-top:100px;width:100%;padding:14px 16px}
+.settingsPageContent .settingsLexicon p{max-width:760px}
+.settingsPageContent .agentClients{margin-top:12px}
+.sessionChartModule{min-width:0}
+.previewSurface{display:none}
+.previewSurface.on{display:block}
+.previewStartStrip{display:grid;grid-template-columns:max-content minmax(0,1fr);align-items:center;gap:12px;margin-bottom:12px;padding:10px 14px;min-width:0;border-left:3px solid var(--accent)}
+.previewStartLabel{color:var(--signal-hi);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.05em;white-space:nowrap}
+.previewStartStrip .previewStartText{display:block;min-width:0;margin:0;color:var(--fg);font-size:var(--fs-13);font-weight:var(--fw-bold);line-height:1.35;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.previewStartStrip .previewStartText:after{bottom:auto;top:calc(100% + 8px);z-index:60}
+.previewTokenSlot{margin-top:12px;min-width:0}
+.previewTokenSlot>.usageSplit{width:100%;margin:0}
+.previewTokenSlot .bar{height:26px}
+.previewKpi.fieldtip{display:block;overflow:visible}
+.previewKpi.fieldtip:after{bottom:auto;top:calc(100% + 8px);z-index:45}
+.previewKpi:hover,.previewKpi:focus{z-index:50;border-color:rgb(var(--signal-rgb)/.34)}
+.previewSpeed .v{color:var(--accent);text-shadow:0 0 18px rgb(var(--signal-rgb)/.18)}
+.sessionChartModule{min-width:0}
+.currentSessionFilterGroups{display:flex;align-items:center;gap:10px;min-width:0;overflow-x:auto;scrollbar-width:none}
+.currentSessionFilterGroups::-webkit-scrollbar{display:none}
+.currentSessionFilterGroup{display:flex;align-items:center;gap:4px;flex:0 0 auto}
+.currentSessionFilterGroup[hidden]{display:none}
+.currentSessionFilterLabel{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.currentSessionsCount{white-space:nowrap}
+.currentOverviewHidden{display:none!important}
+.currentSessionsHead{display:flex;align-items:center;gap:12px;margin:0 0 12px}
+.currentSessionsCount{color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
+.currentSessionGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}
+.currentSessionCard{--harness:var(--provider-other);appearance:none;display:flex;flex-direction:column;width:100%;min-width:0;min-height:218px;overflow:hidden;padding:20px 20px 16px;border:1px solid color-mix(in srgb,var(--harness) 48%,var(--line));border-radius:var(--radius-lg);background:linear-gradient(160deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98));box-shadow:var(--shadow-soft);color:var(--fg);font:inherit;text-align:left;cursor:grab;transition:transform .16s,border-color .16s,box-shadow .16s,opacity .16s}
+.currentSessionCard:before{content:"";position:absolute;inset:0 auto 0 0;width:3px;background:var(--harness);box-shadow:0 0 18px color-mix(in srgb,var(--harness) 55%,transparent)}
+.currentSessionCard:hover{transform:translateY(-2px);border-color:color-mix(in srgb,var(--harness) 78%,var(--line));box-shadow:0 14px 30px rgb(var(--shade-rgb)/.34)}
+.currentSessionCard:focus-visible{outline:0;border-color:var(--harness);box-shadow:0 0 0 3px color-mix(in srgb,var(--harness) 20%,transparent),var(--shadow)}
+.currentSessionCard.dragging{opacity:.42;cursor:grabbing;transform:scale(.99)}
+.currentSessionCard.dropBefore{box-shadow:inset 4px 0 0 var(--harness),var(--shadow)}
+.currentSessionCard.dropAfter{box-shadow:inset -4px 0 0 var(--harness),var(--shadow)}
+.currentSessionTop{display:flex;align-items:center;justify-content:space-between;gap:12px}
+.currentSessionRuntime{display:inline-flex;align-items:center;gap:8px;min-width:0;color:var(--harness);font-size:var(--fs-12);font-weight:var(--fw-heavy);letter-spacing:.012em}
+.currentSessionRuntime:before{content:"";width:7px;height:7px;flex:0 0 auto;border-radius:var(--radius-2xs);background:currentColor;box-shadow:0 0 10px currentColor}
+.currentSessionRuntime span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.currentSessionStatus{display:inline-flex;align-items:center;gap:6px;flex:0 0 auto;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-bold)}
+.currentSessionStatus:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:currentColor}
+.currentSessionStatus.working{color:var(--good)}
+.currentSessionStatus.working:before{box-shadow:0 0 9px currentColor}
+.currentSessionStatus.waiting{color:var(--warn)}
+.currentSessionStatus.recent{color:var(--faint)}
+.cacheRing{--ring-tone:var(--good);position:relative;display:inline-grid;place-items:center;flex:0 0 auto;width:40px;height:40px;margin:-10px 0;color:var(--fg)}
+.cacheRing svg{position:absolute;inset:0;width:100%;height:100%;overflow:visible}
+.cacheRing line{stroke:var(--ring-tone);stroke-width:1.5;stroke-linecap:round;transition:stroke .5s,opacity .5s}
+.cacheRing line.off{stroke:var(--line2)}
+.cacheRing line.maybe{stroke:var(--warn);opacity:.38}
+.cacheRing b{position:relative;font-family:var(--font-mono);font-size:var(--fs-11);font-weight:var(--fw-semibold);letter-spacing:0;line-height:1}
+.cacheRing.warn{--ring-tone:var(--warn)}
+.cacheRing.bad{--ring-tone:var(--bad);animation:cacheRingPulse 1s ease-in-out infinite}
+.cacheRing.maybe b,.cacheRing.cold b{color:var(--faint)}
+@keyframes cacheRingPulse{50%{filter:drop-shadow(0 0 4px var(--bad))}}
+@media(prefers-reduced-motion:reduce){.cacheRing.bad{animation:none}.cacheRing line{transition:none}}
+.currentSessionIdentity{margin-top:18px;min-width:0}
+.currentSessionIdentity h3{margin:0;font-size:var(--fs-20);line-height:1.2;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.currentSessionIdentity p{margin:4px 0 0;color:var(--faint);font:var(--fs-11)/1.25 var(--font-mono);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.currentSessionMetrics{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px;margin-top:20px;padding-top:16px;border-top:1px solid var(--line)}
+.currentSessionMetric{min-width:0}
+.currentSessionMetric span{font-size:var(--fs-11)}
+.currentSessionMetric b{margin-top:6px;font-size:var(--fs-18);line-height:1.15;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.currentSessionMetric b.mono{font-size:var(--fs-18);letter-spacing:-.015em}
+.currentSessionMove{display:inline-flex;align-items:center;gap:4px}
+.currentSessionCaps{display:block;margin-top:6px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.currentSessionProject{flex:0 1 auto;color:var(--faint);font-family:var(--font-mono);font-size:var(--fs-11);font-weight:var(--fw-medium);letter-spacing:0}
+.currentSessionProject:before{content:"·";margin-right:8px}
+.currentSessionTopMeta{display:inline-flex;flex:0 0 auto;align-items:center;gap:12px;color:var(--faint);font-size:var(--fs-11)}
+.currentSessionMove b{color:var(--harness);font-size:var(--fs-13);letter-spacing:-2px}
+.currentSessionOrderStatus{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
+.currentSessionsEmpty{padding:32px 20px;text-align:center}
+.currentSessionsEmpty h3{font-size:var(--fs-18);margin:0}
+.currentSessionsEmpty p{margin:4px auto 0;color:var(--dim);font-size:var(--fs-12)}
+.budgetDashboard{display:block}
+.budgetLead{overflow:hidden;background:linear-gradient(145deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98))}
+.budgetLead:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent 78%)}
+.budgetLead h2,.budgetConfig h2{font-size:var(--fs-18);margin:4px 0 0}
+.budgetLeadHeadActions{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap}
+.budgetLeadBody{display:grid;grid-template-columns:minmax(0,1.08fr) minmax(440px,.92fr);gap:18px;align-items:stretch;margin-top:14px}
+.budgetSpend{margin:0;display:flex;flex-direction:column;justify-content:center}
+.budgetSpendValue{font-size:var(--fs-hero-fluid);font-weight:var(--fw-heavy);line-height:1;letter-spacing:-1.5px;margin-top:4px}
+.budgetState{display:inline-flex;align-items:center;gap:6px}
+.budgetState:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
+.budgetState.on_track{color:var(--good);border-color:rgb(var(--green-rgb)/.32);background:rgb(var(--green-rgb)/.07)}
+.budgetState.warning{color:var(--warn);border-color:rgb(var(--orange-rgb)/.34);background:rgb(var(--orange-rgb)/.07)}
+.budgetState.over{color:var(--bad);border-color:rgb(var(--red-rgb)/.36);background:rgb(var(--red-rgb)/.08)}
+.budgetProgress{position:relative;height:10px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.035);overflow:hidden;margin-top:12px}
+.budgetProgress>i{display:block;height:100%;width:0;background:linear-gradient(90deg,var(--accent),var(--signal));border-radius:var(--radius-pill);transition:width .2s}
+.budgetProgress.warn>i{background:linear-gradient(90deg,var(--warn),var(--bad))}
+.budgetProgressMarkers{position:absolute;inset:0;pointer-events:none}
+.budgetProgressMarkers span{position:absolute;top:0;bottom:0;width:1px;background:rgb(var(--tint-rgb)/.58);box-shadow:0 0 0 1px rgb(var(--shade-rgb)/.18);transform:translateX(-1px)}
+.budgetRuntimeCard{min-width:0;overflow:hidden;padding:14px 16px}
+.spendBudgetSection{display:grid;gap:10px;margin:0 0 12px}
+.spendBudgetEditor .budgetConfig{margin-top:0}
+.budgetConfig[hidden]{display:none}
+.spendBudgetSection .budgetForm.budgetInlineForm{grid-template-columns:minmax(220px,.7fr) minmax(0,1.3fr);column-gap:24px;row-gap:12px;align-items:start}
+.spendBudgetSection .budgetConfigHead,.spendBudgetSection .budgetInlineForm .budgetActions{grid-column:1/-1}
+.spendBudgetSection .budgetRuntimeFields{grid-column:2;grid-row:2}
+.spendBudgetSection .budgetSessionDefault{grid-template-columns:minmax(0,220px)}
+@media(max-width:900px){.spendBudgetSection .budgetForm.budgetInlineForm{grid-template-columns:1fr}.spendBudgetSection .budgetRuntimeFields{grid-column:auto;grid-row:auto}}
+.spendBudgetSection .budgetLead{padding:16px 18px 14px;background:linear-gradient(150deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg-rgb)/.96))}
+.spendBudgetSection .budgetLead:before{height:2px;opacity:.75}
+.budgetLeadTop{display:flex;align-items:center;justify-content:space-between;gap:14px}
+.budgetLeadTitle{display:flex;align-items:baseline;gap:10px;min-width:0;flex-wrap:wrap}
+.spendBudgetSection .budgetLead h2{font-size:var(--fs-16);margin:0}
+.budgetMonth{color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold);opacity:.82}
+.budgetMeta{color:var(--faint);font-size:var(--fs-12)}
+.budgetMeta:not(:empty):before{content:"·";margin-right:10px;color:var(--line3)}
+.spendBudgetSection .budgetLeadBody{grid-template-columns:minmax(0,1fr) minmax(250px,.42fr);gap:24px;align-items:center;margin-top:12px}
+.budgetFigure{display:grid;gap:6px}
+.budgetFigureLine{display:flex;align-items:baseline;gap:10px;flex-wrap:wrap;min-width:0}
+.spendBudgetSection .budgetSpendValue{font-size:var(--fs-readout-lg);font-weight:var(--fw-heavy);letter-spacing:-1px;line-height:1;margin:0;font-variant-numeric:tabular-nums}
+.budgetQualifier{align-self:center;padding:3px 8px;border:1px solid rgb(var(--orange-rgb)/.34);border-radius:var(--radius-pill);color:var(--warn);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
+.budgetQualifier[hidden]{display:none}
+.budgetOf{color:var(--dim);font-size:var(--fs-14)}
+.budgetOf b{color:var(--fg);font-size:var(--fs-18);font-weight:var(--fw-bold)}
+.budgetTotalNote{color:var(--faint);font-size:var(--fs-11)}
+.spendBudgetSection .budgetProgress{height:7px;margin-top:12px;border-color:rgb(var(--tint-rgb)/.08)}
+.budgetMeterFoot{display:flex;justify-content:space-between;gap:12px;flex-wrap:wrap;margin-top:8px;color:var(--dim);font-size:var(--fs-12)}
+.spendBudgetSection .budgetCoverage{margin:0;font-size:var(--fs-11)}
+.budgetStats{display:grid;gap:0;margin:0;padding-left:24px;border-left:1px solid var(--line)}
+.budgetStats>div{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:baseline;gap:2px 12px;padding:10px 0}
+.budgetStats>div+div{border-top:1px solid var(--line)}
+.budgetStats dt{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
+.budgetStats dd{margin:0}
+.budgetStats dd.mono{font-size:var(--fs-20);font-weight:var(--fw-heavy);text-align:right;font-variant-numeric:tabular-nums}
+.budgetStats dd.mono.warn{color:var(--warn)}
+.budgetStatNote{grid-column:1/-1;color:var(--faint);font-size:var(--fs-11);line-height:1.35}
+.budgetRuntimeList{display:grid;margin-top:6px}
+.budgetRuntime{--provider-color:var(--accent);display:grid;grid-template-columns:minmax(0,1fr) auto;gap:4px 12px;padding:8px 0;border-top:1px solid var(--line)}
+.budgetRuntime:first-child{border-top:0;padding-top:2px}
+.budgetRuntimeName{display:flex;align-items:center;gap:8px;font-weight:var(--fw-heavy)}
+.budgetRuntimeName:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:var(--provider-color);box-shadow:0 0 9px var(--provider-color)}
+.budgetRuntimeValue{display:flex;align-items:baseline;justify-content:flex-end;gap:6px}
+.budgetRuntimeValue b{font-weight:var(--fw-heavy)}
+.budgetRuntimeValue small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-semibold)}
+.budgetRuntimeTrack{grid-column:1/-1;height:5px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.05);overflow:hidden}
+.budgetRuntimeTrack i{display:block;height:100%;border-radius:inherit;background:var(--provider-color)}
+.budgetConfig{min-width:0;margin-top:12px;transition:border-color .18s ease,box-shadow .18s ease}
+.budgetConfig.attention{border-color:rgb(var(--signal-rgb)/.62);box-shadow:var(--focus-ring),var(--shadow-soft)}
+.budgetConfigHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px}
+.budgetConfigHead .subline{margin-top:3px}
+.budgetForm{display:grid;grid-template-columns:minmax(300px,.75fr) minmax(440px,1.15fr) auto;gap:14px;margin-top:12px;align-items:end}
+.budgetFormGroup{min-width:0;margin:0;padding:0;border:0}
+.budgetFormGroup legend{width:100%;padding:0 0 6px;border-bottom:1px solid var(--line);color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
+.budgetForm label{display:grid;gap:4px}
+.budgetForm label span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.budgetForm input[type=number],.budgetForm input[type=text]{width:100%;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:var(--fs-12)/1.2 var(--font-mono)}
+.budgetForm input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.budgetActions{display:grid;align-content:end;justify-items:start;gap:6px;min-width:128px;padding:0;border:0}
+.budgetActions .tbtn{white-space:nowrap}
+.budgetActions .settingsStatus{font-size:var(--fs-11);line-height:1.25}
+.budgetCoverage{margin-top:6px;color:var(--dim);font-size:var(--fs-11)}
+.budgetCoverage.warn{color:var(--warn)}
+.budgetForm.budgetInlineForm{grid-template-columns:1fr;gap:10px;margin-top:12px;align-items:stretch}
+.budgetInlineForm .budgetActions{display:flex;align-items:center;justify-content:flex-start;gap:8px;min-width:0;padding-top:8px;border-top:1px solid var(--line)}
+.budgetInlineForm .budgetRuntimeList{grid-template-columns:1fr;gap:0;margin-top:0}
+.budgetRuntimeHead{display:grid;grid-template-columns:minmax(90px,.6fr) minmax(135px,1fr) minmax(100px,.8fr);gap:12px;padding:6px 0;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.budgetRuntime{grid-template-columns:minmax(90px,.6fr) minmax(135px,1fr) minmax(100px,.8fr);grid-template-areas:"name value input";gap:4px 12px;align-items:center;padding:8px 0;border:0;border-top:1px solid var(--line);border-radius:0;background:transparent}
+.budgetRuntime:first-child{border-top:1px solid var(--line);padding-top:8px}
+.budgetRuntimeName{grid-area:name}
+.budgetRuntimeValue{grid-area:value;align-self:start;display:flex;gap:6px;justify-content:flex-start;justify-items:start}
+.budgetRuntimeTrack{grid-area:value;grid-column:auto;align-self:end;height:3px;transform:translateY(2px)}
+.budgetRuntimeInput{grid-area:input;align-self:center;display:grid;gap:4px}
+.budgetRuntimeInput span{display:none;font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.budgetConfigHead{display:grid;grid-template-columns:minmax(108px,1fr) auto;align-items:center;gap:14px}
+.budgetConfigHead .subline{margin-top:3px}
+.budgetAlertInline{display:flex;align-items:center;justify-content:flex-end;gap:8px;min-height:32px}
+.budgetAlertTitle{color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);white-space:nowrap}
+.budgetThresholds{display:flex;align-items:center;gap:4px}
+.budgetThresholds label{position:relative;display:block}
+.budgetForm .budgetThresholds input[type=number]{width:46px;padding:6px 14px 6px 4px;text-align:right;appearance:textfield}
+.budgetThresholds input::-webkit-inner-spin-button,.budgetThresholds input::-webkit-outer-spin-button{margin:0;appearance:none}
+.budgetForm .budgetThresholds label span{position:absolute;right:5px;top:50%;transform:translateY(-50%);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono);pointer-events:none}
+.budgetNotifySwitch{position:relative;display:flex!important;align-items:center;cursor:pointer}
+.budgetNotifySwitch input{position:absolute;width:1px;height:1px;opacity:0;pointer-events:none}
+.budgetNotifySwitch input:checked+.sw{background:var(--good)}
+.budgetNotifySwitch input:checked+.sw:after{left:16px}
+.budgetNotifySwitch input:focus-visible+.sw{outline:2px solid var(--accent);outline-offset:2px}
+.budgetForm.budgetInlineForm{margin-top:0}
+.budgetSessionDefault{display:grid;grid-template-columns:minmax(160px,220px);gap:12px;align-items:end;margin-top:8px}
+.settingsPricing{grid-column:1/-1}
+.settingsPricing .agentAccessBadge[hidden]{display:none}
+.modelPricingProvenance{display:flex;align-items:center;gap:6px;flex-wrap:wrap;margin-top:8px;color:var(--faint);font-size:var(--fs-11)}
+.modelPricingProvenance a{color:var(--dim);text-decoration:none}
+.modelPricingProvenance a:hover{color:var(--accent);text-decoration:underline}
+.modelPriceScope{display:flex;align-items:end;gap:12px;flex-wrap:wrap;margin:12px 0 0;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025)}
+.modelPriceScope legend{position:static;width:100%;height:auto;padding:0;margin:0;overflow:visible;clip:auto;white-space:normal;border:0;color:var(--fg);font-size:var(--fs-11);font-weight:var(--fw-heavy)}
+.modelPriceScopeOptions{display:flex;border:1px solid var(--line2);border-radius:var(--radius-md);padding:2px;background:rgb(var(--shade-rgb)/.14)}
+.modelPriceScopeOptions label{position:relative;display:flex;cursor:pointer}
+.modelPriceScopeOptions input{position:absolute;opacity:0;pointer-events:none}
+.modelPriceScopeOptions span{padding:6px 10px;border-radius:var(--radius-sm);color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-heavy)}
+.modelPriceScopeOptions input:checked+span{background:rgb(var(--signal-rgb)/.16);color:var(--fg);box-shadow:var(--inset)}
+.modelPriceScopeOptions input:focus-visible+span{outline:2px solid var(--accent);outline-offset:1px}
+.modelPriceEffective{display:grid;gap:4px;margin-left:auto}
+.modelPriceEffective span{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
+.modelPriceEffective input{width:190px;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 6px;font:var(--fs-11)/1.2 var(--font-mono);color-scheme:dark}
+.modelPriceEffective input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.modelPriceEffective input:disabled{opacity:.45}
+.modelPriceScope>span{flex:1 1 100%;color:var(--dim);font-size:var(--fs-12)}
+#model-price-selection-count{color:var(--fg);font-weight:var(--fw-bold)}
+.modelPriceScope.history{border-color:rgb(var(--orange-rgb)/.48);background:rgb(var(--orange-rgb)/.07)}
+.modelPriceScope.history>span{color:var(--warn)}
+.modelPriceTabs{display:flex;gap:3px;width:max-content;max-width:100%;overflow-x:auto;margin-top:12px;padding:3px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--shade-rgb)/.14);scrollbar-width:none}
+.modelPriceTabs:empty{display:none}
+.modelPriceTabs button{display:flex;align-items:center;gap:8px;border:0;border-radius:var(--radius-sm);background:transparent;color:var(--dim);padding:6px 12px;font:inherit;font-size:var(--fs-12);font-weight:var(--fw-heavy);white-space:nowrap;cursor:pointer}
+.modelPriceTabs button:hover{color:var(--fg);background:rgb(var(--signal-rgb)/.07)}
+.modelPriceTabs button[aria-selected=true]{background:rgb(var(--signal-rgb)/.16);color:var(--fg);box-shadow:var(--inset)}
+.modelPriceTabs button:focus-visible{outline:2px solid var(--accent);outline-offset:1px}
+.modelPriceTabs .count{color:var(--faint);font:var(--fs-11)/1 var(--font-mono)}
+.modelPriceTabs .edited{width:6px;height:6px;border-radius:var(--radius-round);background:var(--warn)}
+.modelPriceTable tr[hidden]{display:none!important}
+.modelPriceTableWrap{overflow:auto;max-height:min(460px,58vh);overscroll-behavior:contain;margin-top:8px;border:1px solid var(--line);border-radius:var(--radius-md)}
+.modelPriceTable{min-width:1030px}
+.modelPriceTable th{white-space:nowrap}
+.modelPriceTable td{vertical-align:middle}
+.modelPriceTable tr.selected{outline:1px solid rgb(var(--signal-rgb)/.58);outline-offset:-1px;background:rgb(var(--signal-rgb)/.055)}
+.modelPriceSelectCell{width:54px;text-align:center}
+.modelPriceSelectCell input{width:16px;height:16px;accent-color:var(--accent);cursor:pointer}
+.modelPriceModel{display:grid;gap:3px;min-width:205px}
+.modelPriceModel code{font-size:var(--fs-12);color:var(--fg)}
+.modelPriceSource{font-size:var(--fs-11);color:var(--faint);text-transform:capitalize}
+.modelPriceLifecycle{justify-self:start;border:0;background:transparent;color:var(--accent);padding:1px 0;text-align:left;font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);line-height:1.3;cursor:pointer}
+.modelPriceLifecycle:hover{text-decoration:underline}
+.modelPriceLifecycle:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:var(--radius-2xs)}
+.modelPriceInput{width:90px;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 6px;font:var(--fs-11)/1.2 var(--font-mono)}
+.modelPriceInput:focus,.modelPriceAdd input:focus,.modelPriceAdd select:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.modelPriceAdd{display:grid;grid-template-columns:150px minmax(180px,1.4fr) repeat(4,minmax(105px,.65fr)) auto;gap:8px;align-items:end;margin-top:14px;padding-top:12px;border-top:1px solid var(--line)}
+.modelPriceAdd label{display:grid;gap:4px;min-width:0}
+.modelPriceAdd label span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.modelPriceAdd input,.modelPriceAdd select{width:100%;min-width:0;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:var(--fs-11)/1.2 var(--font-mono)}
+.modelPriceAdd select{font-family:inherit}
+.discountCue{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap;margin-top:12px;padding:10px 12px;border:1px solid rgb(var(--signal-rgb)/.35);border-radius:var(--radius-md);background:rgb(var(--signal-rgb)/.07);color:var(--dim);font-size:var(--fs-12)}
+.discountCue.active{border-color:var(--line);background:rgb(var(--tint-rgb)/.03)}
+.discountCue b{color:var(--fg)}
+.discountCue .discountCueText{display:grid;gap:2px;min-width:0}
+.discountCue .discountCueActions{display:flex;gap:8px;align-items:center}
+.discountCueList{display:flex;gap:6px;flex-wrap:wrap;align-items:center}
+.discountLink{border:0;background:none;padding:0;color:var(--faint);font:inherit;font-size:var(--fs-11);cursor:pointer;text-decoration:underline}
+.discountCard,.spendBudgetEditor{min-width:0}
+.discountCard .modelPriceTable{min-width:760px}
+.discountCard h2{font-size:var(--fs-16);margin:0}
+.discountAdd{grid-template-columns:repeat(auto-fill,minmax(150px,1fr))}
+.discountAdd .tbtn{justify-self:start;align-self:end;padding:6px 12px}
+.discountAdd .hint{display:block;font-size:var(--fs-11);color:var(--faint);text-transform:none;font-weight:var(--fw-medium)}
+.discountMore{margin-top:12px;border-top:1px solid var(--line);padding-top:10px}
+.discountMore summary{cursor:pointer;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-heavy)}
+.discountMore p{margin:8px 0;color:var(--faint);font-size:var(--fs-12)}
+.discountMore code{color:var(--dim)}
+.discountApps{display:flex;gap:12px;flex-wrap:wrap}
+.discountApps label{display:grid;gap:4px}
+.discountApps label span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.discountApps select{border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:inherit;font-size:var(--fs-12)}
+.modelPriceAdd .tbtn{height:31px;white-space:nowrap}
+.modelPricingFooter{display:flex;align-items:center;gap:10px;justify-content:flex-end;margin-top:12px;padding-top:12px;border-top:1px solid var(--line)}
+.modelPricingFooter .settingsStatus{margin-right:auto}
+.modelPricingFooter .tbtn:disabled{opacity:.42;cursor:not-allowed}
+.modelPricingEmpty{padding:18px;text-align:center;color:var(--faint)}
+.softwareUpdates{display:grid;gap:8px;padding:12px 16px!important}
+.softwareUpdateHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
+.softwareUpdateHead h2{margin-top:2px}
+.softwareUpdateHead p{margin-top:3px;color:var(--dim);font-size:var(--fs-12);line-height:1.4}
+.softwareUpdateToggle{display:flex;align-items:flex-start;gap:8px;padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025);cursor:pointer}
+.softwareUpdateToggle input{margin-top:2px;accent-color:var(--accent)}
+.softwareUpdateToggle span{display:grid;gap:1px}
+.softwareUpdateToggle b{font-size:var(--fs-13)}
+.softwareUpdateToggle small{color:var(--faint);font-size:var(--fs-11);line-height:1.35}
+.softwareUpdateActions{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:10px}
+.softwareUpdateActions .tbtn:disabled{opacity:.45;cursor:not-allowed}
+.softwareUpdateActions .settingsStatus{width:auto;min-width:0}
+.softwareUpdateMeta{justify-self:end;color:var(--faint);font:var(--fs-11)/1.4 var(--font-mono);white-space:nowrap}
+.settingsMap:before,.agentAccess:before,.budgetLead:before{display:none}
+.settingsPageContent .agentAccessHead h2{font-size:var(--fs-16);margin:0}
+.settingsPageContent :is(.learnSectionHead,.softwareUpdateHead) h2.fieldtip{display:flex;width:fit-content;margin:0}
+.workSettings>.softwareUpdateHead{margin-bottom:14px}
+.workSettings>.softwareUpdateHead .subline{margin-top:4px}
+.softwareUpdateToggles{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}
+.softwareUpdateToggle:has(input:disabled){opacity:.55;cursor:not-allowed}
+@media(max-width:900px){.modelPriceAdd{grid-template-columns:repeat(2,minmax(0,1fr))}.modelPriceAdd .tbtn{justify-self:start}.softwareUpdateToggles{grid-template-columns:1fr}}
+@media(max-width:700px){.modelPriceTableWrap{overflow:visible;border:0}.modelPriceTable{display:block;min-width:0}.modelPriceTable thead{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.modelPriceTable tbody{display:grid;gap:10px}.modelPriceTable tr{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;padding:10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02)}.modelPriceTable td{display:grid;gap:4px;padding:0;border:0;text-align:left}.modelPriceTable td:before{content:attr(data-label);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.modelPriceTable td:nth-child(1){grid-column:1;grid-row:1}.modelPriceTable td:nth-child(2){grid-column:1/-1;grid-row:2}.modelPriceTable td:nth-child(3){grid-column:2;grid-row:1}.modelPriceTable td:nth-child(n+4){grid-column:auto}.modelPriceTable .badge{justify-self:start}.modelPriceSelectCell{width:auto;text-align:left}.modelPriceModel{min-width:0}.modelPriceInput{width:100%}.modelPricingEmpty{display:block!important;grid-column:1/-1!important}.modelPriceScopeOptions{width:100%}.modelPriceScopeOptions label{flex:1}.modelPriceScopeOptions span{width:100%;text-align:center}.modelPriceEffective{width:100%;margin-left:0}.modelPriceEffective input{width:100%}.modelPricingFooter{align-items:flex-start;flex-direction:column}.modelPricingFooter .settingsStatus{margin-right:0}}
+@media(max-width:520px){.modelPriceAdd{grid-template-columns:1fr}.modelPriceScope .modelPriceEffective{width:100%;margin-left:0;justify-content:space-between}.modelPriceEffective input{width:min(210px,62vw)}}
+@media(max-width:520px){.updateNotice{right:14px;bottom:14px;max-width:calc(100vw - 28px)}.updateReady .toastbox{bottom:66px}.softwareUpdateHead{display:block}.softwareUpdateHead .agentAccessBadge{display:inline-block;margin-top:6px}.softwareUpdateActions{grid-template-columns:1fr;align-items:stretch;gap:6px}.softwareUpdateActions .tbtn{width:100%}.softwareUpdateMeta{justify-self:start;white-space:normal}}
+.spark .b.estimated{background:repeating-linear-gradient(135deg,var(--accent) 0 5px,rgb(var(--signal-rgb)/.28) 5px 10px)}
+.capFilters{grid-template-columns:minmax(220px,1fr) auto auto minmax(130px,auto)}
+.capFilters select{border:1px solid var(--line2);background:var(--panel);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:inherit;font-weight:var(--fw-bold);color-scheme:dark}
+@media(max-width:900px){.section-h{flex-wrap:wrap}}
+@media(max-width:1120px){.hero{grid-template-columns:1fr}.costcard{min-height:0}.overview{grid-template-columns:repeat(2,minmax(0,1fr))}}
+@media(max-width:900px){.budgetLeadBody{grid-template-columns:1fr}}
+@media(max-width:980px){.budgetForm{grid-template-columns:minmax(280px,.8fr) minmax(0,1.2fr)}.budgetActions{grid-column:1/-1;display:flex;align-items:center;justify-items:normal;padding-top:8px;border-top:1px solid var(--line)}}
+@media(max-width:1120px){.previewRunGrid{grid-template-columns:minmax(0,1.5fr) minmax(280px,.7fr)}.previewKpis{grid-template-columns:repeat(3,minmax(0,1fr))}}
+.currentSessionGrid{gap:10px}
+.currentSessionCard{min-height:190px;padding:16px 18px 14px}
+.currentSessionIdentity{margin-top:14px}
+.currentSessionIdentity h3{font-size:var(--fs-18)}
+.currentSessionMetrics{gap:12px;margin-top:14px;padding-top:12px}
+.currentSessionMetric b{margin-top:4px;font-size:var(--fs-18)}
+.currentSessionMetric b.mono{font-size:var(--fs-18)}
+.currentSessionContextValue{display:flex;align-items:flex-end;gap:8px;min-width:0}
+.currentSessionContextValue b{flex:0 0 auto}
+.currentSessionContextUnavailable{display:block;min-width:0;margin:0 0 2px;color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.1 var(--font-mono);letter-spacing:.02em;white-space:nowrap}
+.currentSessionContextSpark{--context-tone:var(--harness);display:block;flex:1 1 44px;width:auto;min-width:30px;max-width:88px;height:20px;margin:0 0 1px;overflow:visible}
+.currentSessionContextSpark.watch{--context-tone:var(--warn)}
+.currentSessionContextSpark.high{--context-tone:var(--bad)}
+.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-20)}
+.currentSessionContextSpark{height:22px}
+.currentSessionContextBaseline{fill:none;stroke:rgb(var(--tint-rgb)/.1);stroke-width:1;vector-effect:non-scaling-stroke}
+.currentSessionContextBar{fill:var(--harness);opacity:.42}
+.currentSessionContextBar.watch{fill:var(--warn);opacity:.78}
+.currentSessionContextBar.high{fill:var(--bad);opacity:.86}
+.currentSessionContextBar.latest{opacity:1;filter:drop-shadow(0 0 2px color-mix(in srgb,var(--harness) 60%,transparent))}
+.currentSessionContextBar.watch.latest{filter:drop-shadow(0 0 2px rgb(var(--orange-rgb)/.48))}
+.currentSessionContextBar.high.latest{filter:drop-shadow(0 0 2px rgb(var(--red-rgb)/.52))}
+@media(max-width:1120px){.currentSessionGrid{grid-template-columns:repeat(2,minmax(0,1fr))}}
+@media(max-width:1120px) and (min-width:901px){.globalControls{grid-template-columns:minmax(220px,1fr) minmax(190px,.8fr) minmax(150px,.55fr)}.filterSort{grid-column:1/3}.filterCount{align-self:end}}
+@media(max-width:900px){.logsSummary{grid-template-columns:1fr}.logKpis,.modelHero{grid-template-columns:repeat(2,minmax(0,1fr))}.modelHead{align-items:flex-start;flex-direction:column}.modelControls{width:100%;grid-template-columns:repeat(2,minmax(0,1fr))}.efficiencySupport{grid-template-columns:repeat(2,minmax(0,1fr))}.efficiencyHead{align-items:flex-start;flex-direction:column}.efficiencyRange{width:100%;min-width:0}}
+@media(max-width:900px){.budgetForm{grid-template-columns:1fr}}
+@media(max-width:900px){.wrap{padding:14px}.top{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:8px 8px;padding-top:8px}.top .brand{grid-column:1/-1;min-width:0}.top .tabs{grid-column:1/-1;justify-self:stretch;justify-content:flex-start;width:100%;max-width:100%;overflow-x:auto}.top .spacer{display:none}.top .notify{grid-column:3;justify-self:end}.globalControls,.capHero,.capFilters,.agentClients,.budgetDashboard{grid-template-columns:1fr}.globalControls .seg,.capFilters .seg{justify-content:flex-start}.globalMeta{white-space:normal}.srow{grid-template-columns:26px 132px minmax(0,1fr) auto 28px}.srow .models{display:none}.meter{font-size:var(--fs-44);overflow-wrap:anywhere}.costcard .meter{font-size:var(--fs-56)}.sessionhead{flex-wrap:wrap}.sessid{max-width:100%}.pill{white-space:normal}.statgrid{grid-template-columns:repeat(2,minmax(0,1fr))}.dailyHead{align-items:flex-start;flex-direction:column}.agentDiscovery{align-items:flex-start;flex-wrap:wrap}.agentAccessHead{display:block}.agentAccessBadge{display:inline-block;margin-top:10px}}
+@media(max-width:900px){.previewHead{align-items:flex-start;flex-direction:column}.previewRunGrid{grid-template-columns:1fr}.settingsMap{grid-template-columns:repeat(2,minmax(0,1fr))}.settingsMap button{border:1px solid var(--line);border-radius:var(--radius-sm);padding:8px}.previewChartSlot .chart{height:250px}.previewKpis{grid-template-columns:repeat(3,minmax(0,1fr))}}
+@media(max-width:520px){body{overflow-x:hidden}.tab,.seg button{padding:6px 10px}.top{grid-template-columns:minmax(0,1fr) auto}.top .notify{grid-column:1/-1;justify-self:start}.commandPalette{width:calc(100vw - 20px)}.commandSearch{padding:12px}.commandFooter{justify-content:flex-start;flex-wrap:wrap}.commandDescription{white-space:normal}.sessionStart{grid-template-columns:1fr;gap:3px}.overview,.modelHero,.efficiencyHero{grid-template-columns:1fr;gap:8px}.efficiencySupport{grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}.efficiencyHeadline{min-height:226px;padding:16px}.efficiencyHeadline .v{font-size:var(--fs-36)}.efficiencyModelHead,.efficiencyEvidence{align-items:flex-start;flex-direction:column}.ov{padding:12px 12px}.stat .v,.ov .v{font-size:var(--fs-22)}.meter{font-size:var(--fs-44)}.costcard .meter{font-size:var(--fs-44)}.costcard .subline{white-space:normal}.costmeta,.statgrid,.modelControls{grid-template-columns:1fr}.repo{max-width:100%}.dailyHead{width:100%}.modelChart{height:230px}.modelTrendHead{display:block}.outputPair{display:block}.outputRate{justify-items:start;margin-top:4px}.settingsLexiconHead{display:block}.settingsStatus{width:100%;margin-left:0}}
+@media(max-width:520px){.previewHead h1{font-size:var(--fs-24)}.previewRunMeta{flex-wrap:wrap}.previewRunMeta .repo{max-width:100%;width:100%}.previewChartSlot #session-chart-module>.card{min-height:0}.previewChartSlot .chart{height:226px}.previewChartSlot .chartbar{align-items:flex-start}.previewChartSlot .chartbar .label{width:100%;margin:0}.previewKpis{grid-template-columns:repeat(2,minmax(0,1fr))}.previewKpi{min-height:82px;padding:10px}.previewKpi .v{font-size:var(--fs-18)}.previewCost{font-size:var(--fs-36)}.budgetForm,.settingsMap{grid-template-columns:1fr}.budgetLeadHeadActions{justify-content:flex-start;margin-top:10px}.learnSectionHead .budgetLeadHeadActions .tbtn{margin-top:0}.budgetConfigHead{display:block}.budgetActions .settingsStatus{width:auto}.budgetRuntimeValue{display:grid;gap:1px;justify-items:end}.settingsMap button{width:100%;margin:0}.settingsPageContent>.card{padding:12px}.settingsPageContent .modelPriceTableWrap{margin-left:-4px;margin-right:-4px}}
+@media(max-width:520px){.budgetRuntimeHead{display:none}.budgetRuntime{grid-template-columns:minmax(0,1fr) minmax(100px,108px);grid-template-areas:"name input" "value input";padding:8px 0}.budgetRuntime:first-child{padding-top:8px}.budgetRuntimeValue{justify-items:start}.budgetRuntimeInput span{display:block}}
+@media(max-width:520px){.budgetSpendValue{font-size:var(--fs-readout-xl)}}
+@media(max-width:520px){.previewStartStrip{grid-template-columns:1fr;gap:4px}.previewTokenSlot .legend{gap:8px}}
+@media(max-width:700px){.currentSessionGrid{grid-template-columns:1fr;gap:8px}.currentSessionCard{min-height:184px;padding:14px 14px 12px}.currentSessionIdentity{margin-top:12px}.currentSessionIdentity h3{font-size:var(--fs-18)}.currentSessionMetrics{grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;margin-top:12px;padding-top:10px}.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-16);letter-spacing:-.025em}.currentSessionContextValue{gap:4px}.currentSessionContextSpark{min-width:24px;max-width:58px;height:17px}.currentSessionCard.dropBefore{box-shadow:inset 0 4px 0 var(--harness),var(--shadow)}.currentSessionCard.dropAfter{box-shadow:inset 0 -4px 0 var(--harness),var(--shadow)}}
+@media(max-width:700px){.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-18)}.currentSessionContextSpark{height:19px}}
diff --git a/dashboard/styles/git.css b/dashboard/styles/git.css
new file mode 100644
index 00000000..51ebf51c
--- /dev/null
+++ b/dashboard/styles/git.css
@@ -0,0 +1,98 @@
+/* git-delivery-economics-v1 */
+.deliveryInsightSection{margin-top:24px}
+.deliveryInsightHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:10px;padding-top:20px;border-top:1px solid var(--line)}
+.deliveryInsightHead h2{margin:0;font-size:var(--fs-18)}
+.deliveryInsightHead p{max-width:760px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.5}
+.deliveryInsightGrid{display:grid;grid-template-columns:minmax(300px,.78fr) minmax(0,1.22fr);align-items:start;gap:12px}
+.deliverySignalCard,.deliveryShapeCard{padding:16px 18px}
+.deliveryInsightCardHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
+.deliveryInsightCardHead h3{margin:0;font-size:var(--fs-14)}
+.deliveryInsightCardHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.45}
+.deliverySignalCard{display:flex;height:360px;min-height:0;flex-direction:column}
+.deliverySignalList{display:grid;flex:1;min-height:0;margin-top:12px;padding-right:6px;overflow-y:auto;overscroll-behavior:contain;scrollbar-gutter:stable;scrollbar-width:thin;border-top:1px solid var(--line)}
+.deliverySignal{display:grid;grid-template-columns:8px minmax(0,1fr);gap:8px;align-items:start;border-bottom:1px solid var(--line);padding:10px 0}
+.deliverySignal:last-child{border-bottom:0}
+.deliverySignal i{width:7px;height:7px;border-radius:var(--radius-round);margin-top:4px;background:var(--accent)}
+.deliverySignal.warn i{background:var(--warn)}
+.deliverySignal.good i{background:var(--good)}
+.deliverySignalBody b{display:block;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.deliverySignalBody span{display:block;margin-top:2px;color:var(--dim);font-size:var(--fs-11);line-height:1.45}
+.deliverySignalEmpty{min-height:150px;padding:16px}
+.deliveryShape{margin-top:10px}
+.deliveryShapeHeader,.deliveryShapeRow{display:grid;grid-template-columns:130px minmax(150px,1fr) minmax(230px,.86fr);align-items:center;gap:12px}
+.deliveryShapeHeader{padding:0 0 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.deliveryShapeHeader span:last-child{display:grid;grid-template-columns:minmax(0,.78fr) minmax(0,1.44fr) minmax(0,.78fr);gap:8px;text-align:right}
+.deliveryShapeRow{min-height:62px;border-top:1px solid var(--line)}
+.deliveryShapeIdentity b{display:block;font-size:var(--fs-12)}
+.deliveryShapeIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.deliveryShapeRail{position:relative;height:22px}
+.deliveryShapeRail:before{content:"";position:absolute;top:10px;right:0;left:0;height:2px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.09)}
+.deliveryShapeIqr{position:absolute;top:7px;left:var(--p25);width:calc(var(--p75) - var(--p25));height:8px;border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.3)}
+.deliveryShapeMedian,.deliveryShapeHigh{position:absolute;top:4px;left:var(--median);width:2px;height:14px;border-radius:var(--radius-2xs);background:var(--accent);transform:translateX(-50%)}
+.deliveryShapeHigh{top:7px;left:var(--p90);width:7px;height:7px;border:1px solid var(--panel);background:var(--signal-hi);transform:translateX(-50%) rotate(45deg)}
+.deliveryShapeHigh.beyond{border-color:var(--signal-hi);background:transparent;transform:translateX(-90%) rotate(45deg)}
+.deliveryShapeValues{display:grid;grid-template-columns:minmax(0,.78fr) minmax(0,1.44fr) minmax(0,.78fr);gap:8px;text-align:right}
+.deliveryShapeValues span{min-width:0;overflow:hidden;color:var(--dim);font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono);text-overflow:ellipsis;white-space:nowrap}
+.deliveryShapeEmpty{min-height:212px}
+.deliveryChartViewport{min-width:0}
+.deliveryMobileScrollHint{display:none}
+.deliveryModels{margin-top:12px;overflow:hidden;box-shadow:var(--shadow-soft)}
+.deliveryModelNote{color:var(--faint);font-size:var(--fs-11);text-align:right}
+.deliveryModels .modelName{max-width:280px}
+.deliverySpendShare,.deliveryComposition{display:block;height:4px;margin-top:4px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.06)}
+.deliverySpendShare i{display:block;width:calc(var(--share,0)*1%);height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--signal-mid),var(--signal-hi))}
+.deliveryComposition{display:flex}
+.deliveryComposition i{height:100%;background:var(--signal)}
+.deliveryComposition i.deleted{background:var(--c-deleted)}
+@media(max-width:1180px){.deliveryShapeHeader,.deliveryShapeRow{grid-template-columns:112px minmax(96px,1fr) minmax(240px,.88fr)}}
+@media(max-width:900px){.deliveryInsightGrid{grid-template-columns:1fr}.deliveryInsightHead{align-items:flex-start;flex-direction:column}.deliveryShapeHeader,.deliveryShapeRow{grid-template-columns:minmax(0,1fr) minmax(150px,1fr)}.deliveryShapeHeader span:last-child,.deliveryShapeValues{grid-column:1/-1;grid-row:2}.deliveryShapeRow{padding-bottom:8px}}
+@media(max-width:520px){.deliverySignalCard,.deliveryShapeCard{padding:14px 12px}.deliveryShapeHeader{display:none}.deliveryShapeRow{grid-template-columns:1fr}.deliveryShapeValues{grid-row:auto}.deliveryShapeValues span{display:grid;gap:2px;text-align:left}.deliveryShapeValues span:before{content:attr(data-label);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-sans);text-transform:uppercase}.deliveryMobileScrollHint{display:block;margin:6px 0 2px;color:var(--faint);font-size:var(--fs-11);text-align:right}.deliveryChartViewport{overflow-x:auto;overscroll-behavior-x:contain;scrollbar-width:thin}.deliveryChartWrap{min-width:720px}.deliveryChart .axis{font-size:var(--fs-11)}}
+/* git-evidence-explorer-v2 */
+.deliveryCoverageState{font-family:inherit;cursor:pointer}
+.deliveryCoverageState:after{content:"›";color:var(--faint);font-size:var(--fs-13);line-height:8px;transform:rotate(90deg);transition:transform .15s ease}
+.deliveryCoverageState[aria-expanded=true]:after{transform:rotate(-90deg)}
+.deliveryCoverageState:hover,.deliveryCoverageState:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.5);color:var(--fg);outline:none}
+.deliveryEvidencePanel{margin-top:8px;padding:16px 18px;background:linear-gradient(135deg,rgb(var(--signal-rgb)/.045),rgb(var(--orange-rgb)/.025));box-shadow:var(--shadow-soft)}
+.deliveryEvidencePanel[hidden]{display:none}
+.deliveryEvidenceHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px}
+.deliveryEvidenceHead h2{margin:0;font-size:var(--fs-14)}
+.deliveryEvidenceHead p{max-width:720px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-11);line-height:1.45}
+.deliveryEvidenceClose{flex:none;width:28px;height:28px;border:1px solid var(--line);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-18);cursor:pointer}
+.deliveryEvidenceClose:hover,.deliveryEvidenceClose:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
+.deliveryEvidenceSummary{display:flex;align-items:baseline;gap:8px;margin-top:14px}
+.deliveryEvidenceSummary strong{color:var(--fg);font:var(--fw-heavy) var(--fs-22)/1 var(--font-mono)}
+.deliveryEvidenceSummary span{color:var(--dim);font-size:var(--fs-11)}
+.deliveryEvidenceChoices{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:12px}
+.deliveryEvidenceChoice{display:grid;grid-template-columns:1fr auto;align-items:center;gap:10px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.018);color:var(--dim);text-align:left;cursor:pointer}
+.deliveryEvidenceChoice:hover,.deliveryEvidenceChoice:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.4);background:rgb(var(--signal-rgb)/.04);outline:none}
+.deliveryEvidenceChoice span{font-size:var(--fs-11);font-weight:var(--fw-bold)}
+.deliveryEvidenceChoice strong{color:var(--fg);font:var(--fw-bold) var(--fs-14)/1 var(--font-mono)}
+.deliveryEvidenceMeta{display:flex;justify-content:space-between;gap:18px;margin-top:10px;padding-top:10px;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11);line-height:1.45}
+.deliveryDayInspector{display:grid;grid-template-columns:minmax(150px,.72fr) minmax(0,1.6fr) auto;align-items:center;gap:18px;margin-top:8px;padding:10px 12px;border:1px solid rgb(var(--signal-rgb)/.24);border-radius:var(--radius-md);background:rgb(var(--signal-rgb)/.035)}
+.deliveryDayInspector[hidden]{display:none}
+.deliveryDayIdentity span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.deliveryDayIdentity strong{display:block;margin-top:3px;color:var(--fg);font-size:var(--fs-12)}
+.deliveryDayIdentity small{display:block;margin-top:2px;color:var(--warn);font-size:var(--fs-11)}
+.deliveryDayMetrics{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:8px}
+.deliveryDayMetric span{font-size:var(--fs-11)}
+.deliveryDayMetric b{margin-top:3px;font-size:var(--fs-11);line-height:1.2}
+.deliveryDayActions{display:flex;align-items:center;gap:4px}
+.deliveryDayActions button{height:28px;padding:0 8px;border:1px solid var(--line);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-11);cursor:pointer}
+.deliveryDayActions button:hover:not(:disabled),.deliveryDayActions button:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
+.deliveryDayActions button:disabled{opacity:.36;cursor:default}
+.deliveryDayActions .deliveryDayClose{width:28px;padding:0;font-size:var(--fs-16)}
+.deliveryProjectControls{display:flex;align-items:center;gap:8px}
+.deliveryEvidenceFilter{display:flex;align-items:center;gap:6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.deliveryEvidenceFilter select{height:32px;min-width:150px}
+.deliveryTableWrap .tbl{min-width:660px}
+.deliveryProjectLink{padding:0;border:0;background:none;color:var(--fg);font:inherit;font-weight:var(--fw-bold);text-align:left;cursor:pointer}
+.deliveryProjectLink:hover,.deliveryProjectLink:focus-visible{color:var(--accent);outline:none;text-decoration:underline;text-underline-offset:3px}
+.deliverySignal{width:100%;background:none;color:inherit;font:inherit;text-align:left}
+.deliverySignal[data-delivery-signal-action]{grid-template-columns:8px minmax(0,1fr) auto;border:0;border-bottom:1px solid var(--line);cursor:pointer}
+.deliverySignal[data-delivery-signal-action]:after{content:"›";align-self:center;color:var(--faint);font-size:var(--fs-16)}
+.deliverySignal[data-delivery-signal-action]:hover .deliverySignalBody b,.deliverySignal[data-delivery-signal-action]:focus-visible .deliverySignalBody b{color:var(--accent)}
+.deliverySignal[data-delivery-signal-action]:focus-visible{outline:1px solid rgb(var(--signal-hi-rgb)/.4);outline-offset:3px;border-radius:var(--radius-xs)}
+.deliveryEvidenceFilter select,.deliveryMobileSort select{padding-top:4px;padding-bottom:4px}
+@media(max-width:900px){.deliveryEvidenceChoices{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryDayInspector{grid-template-columns:minmax(140px,.7fr) minmax(0,1.3fr)}.deliveryDayActions{grid-column:1/-1;justify-content:flex-end}}
+@media(max-width:700px){.deliveryProjectHead{align-items:flex-start;flex-direction:column}.deliveryProjectControls{width:100%;align-items:flex-end}.deliveryEvidenceFilter{display:grid;grid-template-columns:auto minmax(132px,180px)}}
+@media(max-width:520px){.deliveryEvidencePanel{padding:14px 12px}.deliveryEvidenceChoices{grid-template-columns:1fr}.deliveryChartTip{display:none!important}.deliveryEvidenceMeta{flex-direction:column;gap:4px}.deliveryDayInspector{grid-template-columns:1fr;gap:10px}.deliveryDayMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryDayActions{grid-column:auto;justify-content:flex-start}.deliveryProjectControls{align-items:stretch;flex-direction:column}.deliveryEvidenceFilter,.deliveryMobileSort{grid-template-columns:42px minmax(0,1fr)}}
diff --git a/dashboard/styles/models-learn.css b/dashboard/styles/models-learn.css
new file mode 100644
index 00000000..4349e860
--- /dev/null
+++ b/dashboard/styles/models-learn.css
@@ -0,0 +1,209 @@
+/* models-leaderboard-v1 */
+#view-models .modelSpend{padding:16px 16px 14px}
+:is(#view-models,.conceptFrame) .modelSpendHead{display:flex;align-items:baseline;justify-content:space-between;gap:14px;margin-bottom:10px}
+:is(#view-models,.conceptFrame) .modelSpendHead h2{font-size:var(--fs-16);margin:0}
+:is(#view-models,.conceptFrame) .modelSpendTotal{font:var(--fw-heavy) var(--fs-16)/1.2 var(--font-mono);color:var(--fg);white-space:nowrap}
+:is(#view-models,.conceptFrame) .modelSpendBar{display:flex;gap:2px;height:38px;border-radius:var(--radius-md);overflow:hidden;background:rgb(var(--tint-rgb)/.04)}
+:is(#view-models,.conceptFrame) .modelSpendSeg{display:flex;align-items:center;justify-content:space-between;gap:8px;min-width:4px;padding:0 10px;border:0;color:var(--on-accent-deep);font:inherit;font-size:var(--fs-12);cursor:default;overflow:hidden;white-space:nowrap}
+#view-models button.modelSpendSeg{cursor:pointer}
+#view-models button.modelSpendSeg:hover,#view-models button.modelSpendSeg:focus-visible{filter:brightness(1.12);outline:none}
+:is(#view-models,.conceptFrame) .modelSpendSeg span{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis}
+:is(#view-models,.conceptFrame) .modelSpendSeg b{font-weight:var(--fw-heavy)}
+#view-models .modelSpendEmpty{display:flex;align-items:center;padding:0 12px;color:var(--faint);font-size:var(--fs-12)}
+:is(#view-models,.conceptFrame) .modelSpendLegend{display:flex;flex-wrap:wrap;gap:6px 8px;margin-top:10px}
+:is(#view-models,.conceptFrame) .modelSpendChip{display:inline-flex;align-items:center;gap:6px;max-width:100%;padding:4px 8px;border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.03);color:var(--dim);font:inherit;font-size:var(--fs-12)}
+#view-models button.modelSpendChip{cursor:pointer}
+#view-models button.modelSpendChip:hover,#view-models button.modelSpendChip:focus-visible{border-color:var(--accent);color:var(--fg);outline:none}
+:is(#view-models,.conceptFrame) .modelSpendChip i{width:9px;height:9px;border-radius:var(--radius-xs);flex:0 0 auto}
+:is(#view-models,.conceptFrame) .modelSpendChipName{color:var(--fg);font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:190px}
+#view-models .modelSpendChip small{color:var(--faint);font-size:var(--fs-11)}
+:is(#view-models,.conceptFrame) .modelSpendChip b{color:var(--fg);font-size:var(--fs-12)}
+:is(#view-models,.conceptFrame) .modelSpendChip em{font-style:normal;color:var(--faint)}
+#view-models .modelSpendNote{margin:8px 0 0;color:var(--faint);font-size:var(--fs-11)}
+#view-models .modelSpendNote:empty{display:none}
+#view-models .modelLinkBtn{border:0;background:none;padding:0;color:var(--accent);font:inherit;cursor:pointer;text-decoration:underline}
+#view-models .modelMixCard .modelChart,#view-models .modelSpeedCard .modelChart{height:250px}
+#view-models .modelSpeedCard .modelTrendControls{align-items:flex-end;flex-wrap:nowrap}
+#view-models .modelSpeedCard .modelPicker{width:260px}
+#view-models .modelSpeedLegend{display:flex;flex-wrap:wrap;gap:6px 14px;margin-top:8px;color:var(--dim);font-size:var(--fs-12)}
+#view-models .modelSpeedChip{display:inline-flex;align-items:center;gap:6px;max-width:320px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+#view-models .modelSpeedChip i{width:14px;height:3px;border-radius:var(--radius-2xs);flex:0 0 auto}
+#view-models .modelSpeedChip small{color:var(--faint)}
+#view-models .modelTableWrap{max-height:none;overflow-x:auto}
+#m-table.modelBoard{min-width:0}
+#m-table.modelBoard th{vertical-align:bottom;white-space:normal;line-height:1.25}
+#m-table .modelSortBtn{display:inline-flex;align-items:center;gap:4px;border:0;background:none;padding:0;color:inherit;font:inherit;text-transform:inherit;letter-spacing:inherit;cursor:pointer}
+#m-table th.num .modelSortBtn{justify-content:flex-end}
+#m-table .modelSortBtn:after{content:"";width:8px;color:var(--faint);font-size:var(--fs-11)}
+#m-table .modelSortBtn.fieldtip{cursor:pointer}
+#m-table .modelSortBtn:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:var(--radius-xs)}
+#m-table .modelSortBtn.on{color:var(--fg)}
+#m-table .modelSortBtn.on[data-direction=desc]:after{content:"\25BE"}
+#m-table .modelSortBtn.on[data-direction=asc]:after{content:"\25B4"}
+#m-table .modelRankCol{width:30px;color:var(--faint);text-align:right;padding-right:4px}
+#m-table td.num{white-space:nowrap}
+#m-table .modelNameCell{min-width:210px}
+#m-table .modelName{max-width:230px}
+#m-table .modelRuntime{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:250px}
+#m-table .modelNameLine{gap:0}
+#m-table .modelExpand,#m-table .modelExpandSpacer{display:inline-flex;align-items:center;justify-content:center;width:18px;height:18px;margin-right:4px;flex:0 0 auto}
+#m-table .modelExpand{border:1px solid var(--line2);border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.04);color:var(--dim);font-size:var(--fs-11);cursor:pointer;padding:0}
+#m-table .modelExpand:hover,#m-table .modelExpand:focus-visible{border-color:var(--accent);color:var(--fg);outline:none}
+#m-table .modelRuntime{padding-left:20px}
+#m-table .modelSpendCell{min-width:170px}
+#m-table .modelSpendCell .modelSpendTrack{display:inline-block;width:72px;height:7px;margin-right:8px;vertical-align:middle;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.06);overflow:hidden}
+#m-table .modelSpendCell .modelSpendTrack i{display:block;height:100%;border-radius:var(--radius-pill)}
+#m-table .modelSpendCell b{display:inline-block;min-width:66px;font-size:var(--fs-13);color:var(--fg)}
+#m-table .modelSpendCell small{display:inline-block;min-width:34px;margin-left:6px;color:var(--faint);font-size:var(--fs-11)}
+#m-table .modelMuted{color:var(--faint)}
+#m-table .modelVariantRow td{background:rgb(var(--tint-rgb)/.018);padding-top:6px;padding-bottom:6px;font-size:var(--fs-12)}
+#m-table .modelVariantName{padding-left:44px;color:var(--dim);font-weight:var(--fw-bold)}
+#m-table .modelVariantName small{margin-left:8px;color:var(--faint);font-weight:var(--fw-medium)}
+#m-table .modelVariantRow .modelSpendCell b{font-size:var(--fs-12);color:var(--dim)}
+#view-models .modelDiagnostics{margin-top:12px;padding:0}
+#view-models .modelDiagnostics>summary{display:flex;align-items:baseline;gap:12px;padding:14px 16px;cursor:pointer;list-style:none}
+#view-models .modelDiagnostics>summary::-webkit-details-marker{display:none}
+#view-models .modelDiagnostics>summary:before{content:"\25B8";color:var(--faint);font-size:var(--fs-11);transition:transform .15s ease}
+#view-models .modelDiagnostics[open]>summary:before{transform:rotate(90deg)}
+#view-models .modelDiagnostics>summary span{font-size:var(--fs-14);font-weight:var(--fw-heavy);color:var(--fg)}
+#view-models .modelDiagnostics>summary:focus-visible{outline:2px solid var(--accent);outline-offset:-3px;border-radius:var(--radius-md)}
+#view-models .modelDiagHero{grid-template-columns:repeat(3,minmax(0,1fr));padding:0 16px}
+#view-models .modelDiagTrend{padding:4px 16px 16px;margin-top:4px}
+@media(max-width:1180px){#m-table .modelSpendCell{min-width:0}#m-table .modelSpendCell .modelSpendTrack{width:40px;margin-right:6px}#m-table .modelSpendCell b{min-width:0}#m-table .modelSpendCell small{display:none}#m-table .modelNameCell{min-width:180px}#m-table .modelName{max-width:170px}#m-table td,#m-table th{padding-left:4px;padding-right:4px}#m-table .modelHelp:before{display:none}#m-table th{font-size:var(--fs-11)}#m-table td.num{font-size:var(--fs-12)}#m-table .modelRuntime{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:200px}#view-models .modelSpeedCard .modelPicker{width:210px}}
+#view-models .modelKpi .modelValueQual{display:block;margin-top:3px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-bold);line-height:1.2;letter-spacing:0}
+.goalsSection{margin:18px 0}
+.goalsPrevious{margin-top:14px}
+.goalsPrevious summary{cursor:pointer;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold);margin-bottom:10px}
+.goalsHead{display:flex;align-items:flex-end;justify-content:space-between;gap:16px;margin-bottom:12px}
+.goalsHead h2{font-size:var(--fs-18);margin:0 0 4px}
+.goalsHead p{margin:0;color:var(--dim);font-size:var(--fs-12)}
+.goalsNotice{margin:0 0 12px;padding:10px 12px;border:1px solid var(--line2);border-radius:var(--radius-md);color:var(--dim);font-size:var(--fs-12)}
+.goalsNotice.tone-warn{border-color:var(--warn)}
+.goalsNotice[hidden],.goalsCustom[hidden],.goalsDates[hidden],.goalsFormError[hidden],.goalsRepeat[hidden],.goalsStep[hidden],.goalsList[hidden]{display:none}
+.goalActions button:disabled{opacity:.5;cursor:not-allowed}
+.goalsDialog{width:min(920px,calc(100vw - 28px));max-height:calc(100vh - 40px);overflow:auto}
+.goalsForm{display:grid;gap:16px}
+.goalsFormBody{display:grid;grid-template-columns:minmax(0,1fr) minmax(260px,300px);gap:24px;align-items:start;padding:0 20px}
+.goalsFields{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px 12px;min-width:0}
+.goalsSpan2{grid-column:span 2}
+.goalsModelSearch{display:grid;gap:4px;padding:4px 4px 8px;border-bottom:1px solid var(--line);margin-bottom:6px}
+.goalsModelSearch input{box-sizing:border-box;width:100%;min-height:32px;border:1px solid var(--line2);border-radius:var(--radius-md);background:var(--panel);color:var(--fg);font:var(--fs-13) var(--font-sans);padding:6px 10px}
+.goalPreview{position:sticky;top:16px;display:grid;gap:12px;min-width:0;padding:16px;border:1px solid var(--line2);border-radius:var(--radius-md);background:linear-gradient(160deg,var(--panel2),var(--bg2))}
+.goalPreviewKicker{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
+.goalPreview h4{margin:0 0 4px;font-size:var(--fs-16);overflow-wrap:anywhere}
+.goalPreview .goalMeta{margin:0}
+.goalPreviewLedger{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px;padding-top:12px;border-top:1px solid var(--line)}
+.goalPreviewReadout strong{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.goalPreview .readoutScale,.goalPreview .readoutCaption{margin-top:0}
+.goalPreviewNote{display:block}
+.goalsForm h3{margin:0;padding:20px 20px 0;font-size:var(--fs-18)}
+.goalsStep{display:grid;gap:6px;min-width:0;margin:0;padding:0;border:0;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.goalsStep legend{padding:0;margin-bottom:6px}
+.goalsWide{grid-column:1/-1}
+.goalsHelp{margin:0;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-medium);line-height:1.45}
+.goalsDates{display:grid;grid-template-columns:1fr 1fr;gap:8px}
+.goalsStep input:not([type=checkbox]){box-sizing:border-box;width:100%;min-height:38px;border:1px solid var(--line2);border-radius:var(--radius-md);background:var(--panel);color:var(--fg);font:var(--fs-13) var(--font-sans);padding:8px 10px;color-scheme:dark}
+.goalsRepeat{display:flex;align-items:center;align-self:end;gap:6px;min-height:38px;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-semibold)}
+.goalsOptions{display:flex;flex-wrap:wrap;gap:8px}
+.goalOption{border:1px solid var(--line2);border-radius:var(--radius-md);background:var(--panel);color:var(--fg);font:var(--fw-bold) var(--fs-12) var(--font-sans);padding:8px 12px;cursor:pointer;text-align:left}
+.goalOption small{display:block;color:var(--dim);font-weight:var(--fw-semibold)}
+.goalOption[aria-pressed=true]{border-color:var(--accent);background:rgb(var(--signal-rgb)/.12)}
+.goalOption:focus-visible{outline:none;box-shadow:var(--focus-ring)}
+.goalsCustom{display:grid;grid-template-columns:minmax(0,160px) minmax(0,1fr);gap:8px;margin-top:8px}
+.goalsFormError{flex:1;min-width:0;padding:6px 10px;border:1px solid var(--warn);border-radius:var(--radius-md);color:var(--warn);font-size:var(--fs-12)}
+.goalsFormActions{position:sticky;bottom:0;display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:14px 20px;border-top:1px solid var(--line);background:var(--panel2)}
+.goalsList{display:grid;grid-template-columns:repeat(auto-fill,minmax(320px,1fr));gap:12px}
+.goalsEmpty{grid-column:1/-1}
+.goalCard{display:grid;gap:10px;align-content:start;padding:16px;min-width:0;transition:border-color .3s,box-shadow .3s}
+.goalCard.is-saved{border-color:var(--accent);box-shadow:var(--focus-ring)}
+.goalCardHead{display:flex;justify-content:space-between;gap:10px;align-items:flex-start}
+.goalCard h4{margin:0;font-size:var(--fs-14);overflow-wrap:anywhere}
+.goalCard .goalMeta{margin:0}
+.goalStatus{flex:none;font-weight:var(--fw-heavy)}
+.goalStatus.on_track,.goalStatus.met{color:var(--good);border-color:currentColor}
+.goalStatus.at_risk{color:var(--warn);border-color:currentColor}
+.goalStatus.missed{color:var(--bad);border-color:currentColor}
+.goalStatus.no_result{color:var(--faint);border-style:dashed}
+.goalStatus.ended{color:var(--faint)}
+.goalMeta{margin:4px 0 10px;color:var(--dim);font-size:var(--fs-12)}
+.goalNumbers{display:flex;align-items:baseline;gap:10px;flex-wrap:wrap}
+.goalNumbers strong{font-size:var(--fs-20)}
+.goalNumbers span,.goalDetail{color:var(--dim);font-size:var(--fs-12)}
+.goalNumbers .goalConfidence{margin-left:auto;color:var(--faint)}
+.goalDetail{margin:0}
+.goalFoot{display:flex;align-items:center;gap:10px;min-height:28px}
+.goalFoot>:first-child{flex:1;min-width:0}
+.goalCard .readoutScale,.goalFoot .readoutCaption{margin-top:0}
+.goalFoot .goalActions{margin:0;align-items:center}
+.goalDots{display:flex;gap:4px}
+.goalDots i{width:8px;height:8px;border-radius:var(--radius-round);background:currentColor}
+.goalMenu{position:relative}
+.goalMenu>summary{list-style:none;padding:4px 8px;font-size:var(--fs-12);line-height:1;cursor:pointer}
+.goalMenu>summary::-webkit-details-marker{display:none}
+.goalMenuList{width:160px;display:grid;gap:2px}
+.goalMenuList button{border:0;border-radius:var(--radius-sm);background:none;color:var(--fg);font:var(--fw-semibold) var(--fs-12) var(--font-sans);text-align:left;padding:8px 10px;cursor:pointer}
+.goalMenuList button:hover,.goalMenuList button:focus-visible{outline:none;background:var(--line)}
+.goalMenuList .goalMenuDanger{color:var(--bad)}
+.goalSparkLine{fill:none;stroke:var(--accent);stroke-width:1.6;vector-effect:non-scaling-stroke}
+.goalSparkTarget{stroke:var(--faint);stroke-width:1;stroke-dasharray:3 3;vector-effect:non-scaling-stroke}
+.goalHistory{display:flex;flex-wrap:wrap;gap:6px;margin-top:8px}
+.goalActions{display:flex;gap:8px;margin-top:10px}
+.goalActions button{font-size:var(--fs-11);padding:4px 8px}
+#view-efficiency.goalDetailOpen>:not(#efficiency-goals){display:none}
+.goalDetailView{display:grid;gap:14px}
+.goalDetailView[hidden]{display:none}
+.goalDetailHead{display:flex;align-items:flex-start;gap:14px}
+.goalDetailTitle{flex:1;min-width:0}
+.goalDetailHead h3{margin:0 0 4px;font-size:var(--fs-20);overflow-wrap:anywhere}
+.goalDetailHead .goalMeta{margin:0}
+.goalDetailSummary{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px}
+.goalDetailMetric{padding:14px 16px}
+.goalDetailCard{padding:16px 18px;min-width:0}
+.goalDetailCard h4{margin:0 0 10px;font-size:var(--fs-14)}
+.goalDetailCard h5{margin:12px 0 6px;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.goalDetailGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}
+.goalTrend{display:block;width:100%;height:160px}
+.goalTrendTip{white-space:normal;width:max-content;max-width:calc(100% - 16px)}
+.goalTrendAxis{display:flex;justify-content:space-between;gap:12px;margin-top:6px;color:var(--faint);font-size:var(--fs-11)}
+.goalDriverRow{display:grid;grid-template-columns:minmax(0,1.4fr) minmax(0,1fr) auto;gap:10px;align-items:center;padding:4px 0;font-size:var(--fs-12)}
+.goalDriverRow span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.goalDriverRow b{font-family:var(--font-mono);font-weight:var(--fw-bold);color:var(--fg)}
+.goalDriverBar{height:8px;border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.07);overflow:hidden}
+.goalDriverBar i{display:block;height:100%;background:var(--accent)}
+.goalDriverNote{margin:8px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
+.goalCoachTip{padding:12px 0;border-top:1px solid var(--line)}
+.goalCoachTip:first-of-type{border-top:0;padding-top:0}
+.goalCoachTip h5{margin:0 0 4px;color:var(--fg);font-size:var(--fs-13)}
+.goalCoachTip p{margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
+.goalCoachTip .goalCoachSaving{color:var(--good);font-weight:var(--fw-bold)}
+.goalCoachSaving small{display:block;margin-top:2px;color:var(--dim);font-weight:var(--fw-medium)}
+.goalTitleLink{color:inherit;text-decoration:none}
+.goalTitleLink:hover{color:var(--accent)}
+@media(max-width:1200px){.goalDetailSummary{grid-template-columns:repeat(2,minmax(0,1fr))}.goalDetailGrid{grid-template-columns:minmax(0,1fr)}}
+
+/* Concept frames show real dashboard components with sample values; these rules only fit them to the frame and keep them still. */
+:where(.conceptFrame) :is(.currentSessionCard,.capReviewQueue,.subagentRoleTrendList,.spendPlot,.efficiencyHeadline){overflow:visible}
+:where(.conceptFrame) .currentSessionCard{min-height:0;cursor:default}
+:where(.conceptFrame) .currentSessionCard:hover{transform:none;border-color:color-mix(in srgb,var(--harness) 48%,var(--line));box-shadow:var(--shadow-soft)}
+:where(.conceptFrame) .currentSessionContextSpark{max-width:96px;height:22px}
+:where(.conceptFrame) .spendChartInner{height:132px}
+:where(.conceptFrame) .spendDayTrack{background:repeating-linear-gradient(to top,transparent 0 44px,rgb(var(--tint-rgb)/.035) 44px 45px)}
+:where(.conceptFrame) .spendDay{cursor:default}
+:where(.conceptFrame) .spendDay:hover{background:transparent}
+:where(.conceptFrame) .spendChart{min-height:0;margin-top:0;grid-template-columns:minmax(0,1fr)}
+:where(.conceptFrame) .budgetSpend{display:grid;justify-content:normal;gap:4px}
+:where(.conceptFrame) .budgetSpendValue{font-size:var(--fs-readout-md);letter-spacing:-.02em}
+:where(.conceptFrame) .budgetProgress{margin-top:4px}
+:where(.conceptFrame) .budgetMeterFoot>span:last-child{display:inline-flex;align-items:center;gap:8px;color:var(--fg);font-weight:var(--fw-semibold)}
+:where(.conceptFrame) .efficiencyHeadline{min-height:0;padding:16px 18px 12px}
+:where(.conceptFrame) .efficiencyValueRow{display:flex;align-items:center;gap:20px}
+:where(.conceptFrame) .efficiencyHeadline .efficiencyChart{height:88px;cursor:default}
+:where(.conceptFrame) .capReviewHead,:where(.conceptFrame) .capReviewItem{grid-template-columns:minmax(0,1fr)}
+:where(.conceptFrame) .capReviewCols{grid-template-columns:0 minmax(0,1fr) 92px 168px}
+:where(.conceptFrame) .capReviewRow{min-height:40px;display:grid;align-items:center}
+:where(.conceptFrame) .capReviewHead>span:last-child{text-align:left}
+:where(.conceptFrame) .capReviewNum{display:inline-flex;align-items:center;gap:6px;overflow:visible}
+:where(.conceptFrame) .subagentRoleTrendRow{grid-template-columns:minmax(0,1fr) auto minmax(0,1.1fr);min-height:0;padding:14px 16px}
+:where(.conceptFrame) .compareCardTitle{overflow:hidden;font-size:var(--fs-13);text-overflow:ellipsis;white-space:nowrap}
+:where(.conceptFrame) .compareBreakdownRow b{display:inline-flex;align-items:center;justify-content:flex-end;gap:8px}
+:where(.conceptFrame) .compareSection{padding:14px 16px}
diff --git a/dashboard/styles/motion-sessions.css b/dashboard/styles/motion-sessions.css
new file mode 100644
index 00000000..21b1837b
--- /dev/null
+++ b/dashboard/styles/motion-sessions.css
@@ -0,0 +1,324 @@
+/* spectrum-motion-v1: purposeful motion and material detail shared by every theme */
+html:after{content:"";position:fixed;inset:0;z-index:-1;pointer-events:none;background-image:var(--grain);background-size:180px 180px;opacity:var(--grain-opacity);mix-blend-mode:overlay}
+body.spectrumApp .card:not(.currentSessionCard):not(.budgetConfig){transition:border-color .16s,box-shadow .16s}
+body.spectrumApp :is(.tbtn,.seg button,.themeOption){transition:border-color .16s,background .16s,box-shadow .16s,color .16s,transform var(--dur-press) var(--ease-out)}
+body.spectrumApp :is(.tbtn,.seg button,.themeOption):active:not(:disabled){transform:scale(.97)}
+body.spectrumApp .top .tab:active{transform:scale(.98)}
+@keyframes viewEnter{from{opacity:0;transform:translateY(8px)}}
+.view.viewEnter>*{animation:viewEnter var(--dur-enter) var(--ease-out) both;animation-delay:calc(var(--enter-i,0)*45ms)}
+html.themeReveal::view-transition-old(root),html.themeReveal::view-transition-new(root){animation:none;mix-blend-mode:normal}
+html.themeReveal::view-transition-new(root){z-index:1}
+@media(prefers-reduced-motion:reduce){body.spectrumApp :is(.tbtn,.seg button,.themeOption,.top .tab):active{transform:none}.view.viewEnter>*{animation-name:none}body.spectrumApp .card:not(.currentSessionCard):not(.budgetConfig){transition:none}}
+/* session-spectrum-field-v2 */
+body.sessionRoute{--session-signal:var(--signal);--session-signal-mid:var(--signal-mid);--session-signal-hi:var(--signal-hi);--session-aura:var(--aura);--session-orange:var(--orange)}
+/* session-signal-field-v1 */
+body.sessionRoute #view-session .sessionFlowStatus{display:inline-flex;width:auto;min-height:28px;align-items:center;gap:8px;margin:0;padding:6px 10px;border:1px solid rgb(var(--signal-hi-rgb)/.22);border-radius:var(--radius-pill);background:rgb(var(--bg-lift-rgb)/.72);box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.035);color:var(--session-signal-hi);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono);letter-spacing:.055em;text-transform:uppercase}
+body.sessionRoute #view-session .sessionFlowStatus i{width:6px;height:6px;flex:0 0 auto;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
+body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=working] .sessionFlowStatus{border-color:rgb(var(--green-rgb)/.3);color:var(--good)}
+body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=working] .sessionFlowStatus i{animation:sessionFlowStatusPulse 2.8s ease-out infinite}
+body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=waiting] .sessionFlowStatus{color:var(--warn)}
+body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=recent] .sessionFlowStatus{color:var(--session-aura)}
+body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=idle] .sessionFlowStatus{color:var(--dim)}
+body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=unavailable] .sessionFlowStatus{border-style:dashed;color:var(--faint)}
+body.sessionRoute #view-session .sessionFlowHead[data-session-flow=waiting] .pageSignalField{opacity:.86}
+body.sessionRoute #view-session .sessionFlowHead[data-session-flow=recent] .pageSignalField{opacity:.8}
+body.sessionRoute #view-session .sessionFlowHead[data-session-flow=idle] .pageSignalField{opacity:.72}
+body.sessionRoute #view-session .sessionFlowHead[data-session-flow=unavailable] .pageSignalField{opacity:.62}
+body.sessionRoute #view-session.sessionDetail .sessionFlowHead :is(.pageSignalField,.pageHeroBorder),body.sessionRoute #view-session.sessionDetail .spectrumPageActions{display:none}
+@keyframes sessionFlowStatusPulse{0%,70%{box-shadow:0 0 0 0 rgb(var(--green-rgb)/.4)}100%{box-shadow:0 0 0 9px transparent}}
+body.sessionRoute #view-session .sessionScopeTabs{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:4px;width:100%;margin:-4px 0 12px;padding:4px;border-color:rgb(var(--signal-rgb)/.24);background:rgb(var(--bg-rgb)/.72)}
+body.sessionRoute #view-session .sessionScopeTabs .tab{display:flex;min-height:44px;align-items:center;justify-content:center;gap:8px;padding:10px 14px;text-align:center}
+body.sessionRoute #view-session .sessionScopeTabs .tab .tabIcon{width:17px;height:17px;flex:0 0 auto}
+body.sessionRoute #view-session .sessionScopeTabs .tab[aria-selected=true]{background:var(--spectrum-active);color:var(--on-accent);box-shadow:0 7px 20px rgb(var(--signal-rgb)/.16)}
+body.sessionRoute #view-session .sessionScopeTabs .tab[aria-selected=false]:hover{background:rgb(var(--signal-rgb)/.07);color:var(--fg)}
+body.sessionRoute #view-session .currentDaySummary{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:stretch;gap:18px;margin:0 0 10px;padding:10px 12px;border-top:1px solid rgb(var(--signal-rgb)/.16);border-bottom:1px solid rgb(var(--signal-rgb)/.13);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.055),rgb(var(--signal-hi-rgb)/.025) 62%,rgb(var(--aura-rgb)/.035))}
+body.sessionRoute #view-session .currentDayReadouts{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));min-width:0}
+body.sessionRoute #view-session .currentDayMetric{min-width:0;padding:0 16px;border-left:1px solid rgb(var(--tint-rgb)/.08)}
+body.sessionRoute #view-session .currentDayMetric:first-child{padding-left:0;border-left:0}
+body.sessionRoute #view-session .currentDayMetricLabel{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.045em;text-transform:uppercase}
+body.sessionRoute #view-session .currentDayMetricValue{display:block;margin-top:3px;color:var(--fg);font-size:var(--fs-18);font-weight:var(--fw-bold);line-height:1.15;font-variant-numeric:tabular-nums;overflow-wrap:anywhere}
+body.sessionRoute #view-session .currentDayMetricNote{display:block;margin-top:3px;color:var(--faint);font-size:var(--fs-11);line-height:1.3;overflow-wrap:anywhere}
+body.sessionRoute #view-session .currentDayActions{align-self:center;display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap}
+body.sessionRoute #view-session :is(.currentDayMonth,.currentDayLearn){display:inline-flex;align-items:center;justify-content:center;gap:6px;min-height:40px;white-space:nowrap}
+body.sessionRoute #view-session .currentDayLearn{text-decoration:none}
+body.sessionRoute #view-session .currentDayLearnIcon{width:14px;height:14px;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
+body.sessionRoute #view-session .currentSessionsHead{justify-content:space-between;margin:-4px 0 8px;padding:0 2px}
+body.sessionRoute #view-session .currentSessionsCount{color:var(--faint);font-size:var(--fs-11);letter-spacing:.02em}
+body.sessionRoute #view-session .currentSessionFilterGroups{max-width:calc(100% - 96px)}
+body.sessionRoute #view-session .currentSessionRuntimeFilters,body.sessionRoute #view-session .currentSessionActivityFilters{display:flex;min-width:0}
+body.sessionRoute #view-session .currentSessionRuntimeFilters[hidden],body.sessionRoute #view-session .currentSessionActivityFilters[hidden]{display:none}
+body.sessionRoute #view-session .currentSessionRuntimeFilters button,body.sessionRoute #view-session .currentSessionActivityFilters button{min-height:30px;padding:6px 10px;white-space:nowrap}
+body.sessionRoute #view-session .currentSessionGrid{gap:12px}
+body.sessionRoute #view-session .currentSessionCard{isolation:isolate;min-height:0;padding:18px 20px 16px;border-color:rgb(var(--signal-rgb)/.16);border-radius:var(--radius-md);background:radial-gradient(circle at 92% 8%,rgb(var(--signal-hi-rgb)/.1),transparent 28%),radial-gradient(circle at 8% 100%,rgb(var(--aura-rgb)/.07),transparent 34%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.99));box-shadow:var(--shadow-soft);transition:transform .18s cubic-bezier(.16,1,.3,1),border-color .18s,box-shadow .18s,opacity .18s}
+body.sessionRoute #view-session .currentSessionCard:before{content:none}
+body.sessionRoute #view-session .currentSessionCard.activity-working{border-color:rgb(var(--signal-rgb)/.42);background:radial-gradient(circle at 88% 4%,rgb(var(--signal-rgb)/.18),transparent 34%),linear-gradient(135deg,rgb(var(--signal-deep-rgb)/.98),rgb(var(--bg-lift-rgb)/.99) 56%,rgb(var(--bg2-rgb)/.99))}
+body.sessionRoute #view-session .currentSessionCard.is-arriving{animation:currentSessionArrive .82s var(--spectrum-ease) both}
+@keyframes currentSessionArrive{0%{opacity:.15;transform:translateY(9px);box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.06)}55%{opacity:1;box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.58),0 0 34px rgb(var(--signal-rgb)/.18)}100%{opacity:1;transform:none;box-shadow:var(--shadow-soft)}}
+body.sessionRoute #view-session .currentSessionCard:hover{transform:translateY(-3px);border-color:color-mix(in srgb,var(--harness) 72%,var(--session-signal));box-shadow:0 18px 38px rgb(var(--shade-rgb)/.3)}
+body.sessionRoute #view-session .currentSessionCard:focus-visible{outline:2px solid var(--session-signal);outline-offset:3px;border-color:var(--session-signal);box-shadow:none}
+body.sessionRoute #view-session .currentSessionIdentity{position:relative;z-index:1;margin-top:20px}
+body.sessionRoute #view-session .currentSessionIdentity h3{font-family:var(--font-display);font-size:var(--fs-22);font-stretch:91%;font-weight:var(--fw-semibold);letter-spacing:-.025em}
+body.sessionRoute #view-session .currentSessionIdentity p{margin-top:6px;color:var(--faint);font-size:var(--fs-11)}
+body.sessionRoute #view-session .currentSessionMetrics{grid-template-columns:.9fr 1.2fr 1fr;gap:0;margin-top:14px;padding-top:14px;border-top:1px solid rgb(var(--signal-rgb)/.13)}
+body.sessionRoute #view-session .currentSessionMetric{padding:0 14px;border-left:1px solid rgb(var(--tint-rgb)/.08)}
+body.sessionRoute #view-session .currentSessionMetric:first-child{padding-left:0;border-left:0}
+body.sessionRoute #view-session .currentSessionMetric:last-child{padding-right:0}
+body.sessionRoute #view-session .currentSessionMetric span{color:var(--faint);font-size:var(--fs-11);letter-spacing:.04em}
+body.sessionRoute #view-session .currentSessionMetric b,body.sessionRoute #view-session .currentSessionMetric b.mono{margin-top:6px;color:var(--fg);font-size:var(--fs-readout-sm);font-weight:var(--fw-bold)}
+:is(body.sessionRoute #view-session,.conceptFrame) .currentSessionHero{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:end;gap:8px 24px;margin-top:16px}
+body.sessionRoute #view-session .currentSessionHeroCompare{min-width:0;padding-bottom:4px}
+:is(body.sessionRoute #view-session,.conceptFrame) .currentSessionHeroLabel{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
+:is(body.sessionRoute #view-session,.conceptFrame) .currentSessionHeroValue{display:block;margin-top:4px;color:var(--fg);font-family:var(--font-sans);font-size:var(--fs-readout-lg);font-weight:var(--fw-bold);line-height:1;letter-spacing:-.035em;font-variant-numeric:tabular-nums;white-space:nowrap}
+body.sessionRoute #view-session .currentSessionHero .readoutScale{max-width:280px;margin-top:0}
+body.sessionRoute #view-session .currentSessionContextSpark{--context-tone:var(--session-signal);max-width:98px;height:24px}
+body.sessionRoute #view-session .currentSessionContextBaseline{stroke:rgb(var(--signal-rgb)/.12)}
+body.sessionRoute #view-session .currentSessionContextBar{fill:var(--session-signal);opacity:.52}
+body.sessionRoute #view-session .currentSessionGrip{width:12px;height:16px;fill:var(--session-signal);opacity:.7}
+body.sessionRoute #view-session .currentSessionsEmpty{border-color:rgb(var(--signal-rgb)/.18);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--panel2-rgb)/.95),rgb(var(--bg2-rgb)/.98))}
+body.sessionRoute #view-session .currentSessionsEmpty{position:relative;display:flex;grid-column:1/-1;min-height:390px;overflow:hidden;align-items:center;justify-content:center;padding:36px 24px 36px;text-align:center;background:radial-gradient(ellipse at 50% 48%,rgb(var(--signal-rgb)/.13),transparent 44%),radial-gradient(ellipse at 76% 42%,rgb(var(--aura-rgb)/.08),transparent 36%),linear-gradient(150deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg-rgb)/.98))}
+body.sessionRoute #view-session .currentSessionsEmpty:after{content:"";position:absolute;right:7%;bottom:-120px;left:7%;height:210px;border-radius:var(--radius-round);background:rgb(var(--signal-rgb)/.07);filter:blur(38px)}
+body.sessionRoute #view-session .currentSessionsEmptyInner{position:relative;z-index:1;width:min(720px,100%)}
+body.sessionRoute #view-session .currentSessionsEmpty h3{margin:0;font-family:var(--font-display);font-size:var(--fs-readout-lg);font-stretch:91%;font-weight:var(--fw-semibold);letter-spacing:-.03em}
+body.sessionRoute #view-session .currentSessionsEmptyCopy{max-width:65ch;margin:8px auto 0;color:var(--dim);font-size:var(--fs-13);line-height:1.55}
+body.sessionRoute #view-session .currentSessionsArrival{width:min(390px,100%);margin:20px auto 28px;padding:14px 16px 14px;border:1px solid rgb(var(--aura-rgb)/.48);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg-lift-rgb)/.98));box-shadow:0 14px 30px rgb(var(--shade-rgb)/.24),0 0 30px rgb(var(--aura-rgb)/.08);text-align:left}
+body.sessionRoute #view-session .currentSessionsArrivalHead{display:flex;align-items:center;gap:8px}
+body.sessionRoute #view-session .currentSessionsArrivalHead:before{content:"";width:7px;height:7px;flex:0 0 auto;border-radius:var(--radius-round);background:var(--session-aura);box-shadow:0 0 12px rgb(var(--aura-rgb)/.72)}
+body.sessionRoute #view-session .currentSessionsArrivalHead strong{font-size:var(--fs-13)}
+body.sessionRoute #view-session .currentSessionsArrivalHead span{margin-left:auto;color:var(--session-aura);font-size:var(--fs-11);font-weight:var(--fw-bold)}
+body.sessionRoute #view-session .currentSessionsArrivalMetrics{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:14px;margin-top:12px;padding-top:12px;border-top:1px solid rgb(var(--signal-hi-rgb)/.14)}
+body.sessionRoute #view-session .currentSessionsArrivalMetric span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+body.sessionRoute #view-session .currentSessionsArrivalMetric strong{display:block;margin-top:4px;font:var(--fw-bold) var(--fs-14)/1.1 var(--font-mono)}
+body.sessionRoute #view-session .currentSessionsHistorySummary{display:flex;align-items:baseline;justify-content:center;gap:14px;margin-bottom:3px}
+body.sessionRoute #view-session .currentSessionsHistorySummary>strong{font-family:var(--font-display);font-size:var(--fs-24);font-weight:var(--fw-semibold);letter-spacing:-.03em}
+body.sessionRoute #view-session .currentSessionsHistorySummary>span{color:var(--dim);font-size:var(--fs-12)}
+body.sessionRoute #view-session .currentSessionsHistorySummary>span b{color:var(--fg);font:var(--fw-bold) var(--fs-12)/1.2 var(--font-mono)}
+body.sessionRoute #view-session .currentSessionsHorizon{position:relative;display:grid;grid-template-columns:repeat(7,minmax(0,1fr));height:92px;margin:0 auto 20px;padding:0 10px}
+body.sessionRoute #view-session .currentSessionsHorizon:before{content:"";position:absolute;right:10px;bottom:25px;left:10px;height:1px;background:linear-gradient(90deg,rgb(var(--signal-rgb)/.14),rgb(var(--signal-hi-rgb)/.7) 72%,rgb(var(--aura-rgb)/.72));box-shadow:0 8px 28px rgb(var(--signal-rgb)/.18)}
+body.sessionRoute #view-session .currentSessionsHistoryDay{position:relative;display:grid;grid-template-rows:1fr auto 24px;justify-items:center;min-width:0}
+body.sessionRoute #view-session .currentSessionsHistoryValue{align-self:end;margin-bottom:6px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.1 var(--font-mono)}
+body.sessionRoute #view-session .currentSessionsHistoryBar{width:clamp(9px,1.5vw,15px);height:var(--activity);min-height:0;align-self:end;border-radius:var(--radius-xs) var(--radius-xs) 0 0;background:linear-gradient(to top,rgb(var(--signal-rgb)/.36),var(--session-signal-hi));box-shadow:0 0 20px rgb(var(--signal-rgb)/.17)}
+body.sessionRoute #view-session .currentSessionsHistoryDay small{align-self:end;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-bold);letter-spacing:.05em;text-transform:uppercase}
+body.sessionRoute #view-session .currentSessionsEmptyActions{display:flex;align-items:center;justify-content:center;gap:20px}
+body.sessionRoute #view-session .currentSessionsEmptyAction{appearance:none;display:inline-flex;align-items:center;gap:6px;padding:2px;border:0;background:transparent;color:var(--session-signal-hi);font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);line-height:1.2;text-decoration:none;cursor:pointer}
+body.sessionRoute #view-session .currentSessionsEmptyAction.secondary{color:var(--dim)}
+body.sessionRoute #view-session .currentSessionsEmptyAction:hover{color:var(--fg)}
+body.sessionRoute #view-session .currentSessionsEmptyAction:focus-visible{outline:2px solid var(--session-signal);outline-offset:4px;border-radius:var(--radius-xs)}
+body.sessionRoute #view-session .currentSessionsEmptyAction svg{width:15px;height:15px;fill:none;stroke:currentColor;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round}
+@media(max-width:700px){body.sessionRoute #view-session .currentSessionsEmpty{min-height:0;padding:32px 14px 32px}body.sessionRoute #view-session .currentSessionsEmpty h3{font-size:var(--fs-28)}body.sessionRoute #view-session .currentSessionsArrival{margin:20px auto 24px}body.sessionRoute #view-session .currentSessionsHistorySummary{flex-wrap:wrap;gap:3px 10px}body.sessionRoute #view-session .currentSessionsHistorySummary>strong{font-size:var(--fs-24)}body.sessionRoute #view-session .currentSessionsHistorySummary>span{flex-basis:100%}body.sessionRoute #view-session .currentSessionsHorizon{height:86px;padding:0}body.sessionRoute #view-session .currentSessionsHorizon:before{right:0;left:0}body.sessionRoute #view-session .currentSessionsHistoryValue{visibility:hidden}body.sessionRoute #view-session .currentSessionsHistoryDay small{font-size:0}body.sessionRoute #view-session .currentSessionsHistoryDay small:after{content:attr(data-short);font-size:var(--fs-11)}body.sessionRoute #view-session .currentSessionsEmptyActions{flex-direction:column;gap:14px}}
+body.sessionRoute #view-session #all-session-history{margin-top:2px}
+body.sessionRoute #view-session .allSessionsHead{display:flex;align-items:flex-end;justify-content:space-between;gap:16px;margin:0 0 10px;padding:2px 2px 0}
+body.sessionRoute #view-session .allSessionsHead h2{margin:0;font-family:var(--font-display);font-size:var(--fs-22);font-weight:var(--fw-semibold);letter-spacing:-.025em}
+body.sessionRoute #view-session .allSessionsHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-12)}
+body.sessionRoute #view-session .allSessionsHint{margin-left:auto;color:var(--faint);font-size:var(--fs-11);white-space:nowrap}
+body.sessionRoute #view-session .logsToolbar{margin-top:0}
+body.sessionRoute #view-session .logsToolbarStatus{margin-bottom:8px}
+body.sessionRoute #view-session .logsSummary{display:block;margin:0 0 12px}
+body.sessionRoute #view-session .logsSummary .logKpis{grid-template-columns:repeat(5,minmax(0,1fr));gap:0;border:1px solid rgb(var(--signal-rgb)/.16);border-radius:var(--radius-md);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.055),rgb(var(--signal-hi-rgb)/.025) 62%,rgb(var(--aura-rgb)/.035));box-shadow:var(--shadow-soft)}
+body.sessionRoute #view-session .logsSummary .logStat{min-height:76px;padding:12px 12px;border:0;border-left:1px solid rgb(var(--tint-rgb)/.08);border-radius:0;background:transparent;box-shadow:none}
+body.sessionRoute #view-session .logsSummary .logStat:first-child{border-left:0}
+body.sessionRoute #view-session .logsSummary .logStat.waitStat{grid-column:auto;min-height:76px}
+body.sessionRoute #view-session .logsSummary .logStat .v{font-size:var(--fs-20)}
+body.sessionRoute #view-session .logsSummary .logStat .subline{font-size:var(--fs-11)}
+body.sessionRoute #view-session .historyModels{margin-top:8px;border:1px solid var(--line);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--panel-rgb)/.8),rgb(var(--bg2-rgb)/.78));box-shadow:var(--shadow-soft)}
+body.sessionRoute #view-session .historyModels>summary{display:flex;align-items:center;gap:8px;min-height:42px;padding:0 12px;cursor:pointer;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-heavy);list-style:none}
+body.sessionRoute #view-session .historyModels>summary::-webkit-details-marker{display:none}
+body.sessionRoute #view-session .historyModels>summary:after{content:"▾";margin-left:auto;color:var(--faint);font-size:var(--fs-11);transition:transform .16s ease}
+body.sessionRoute #view-session .historyModels[open]>summary{border-bottom:1px solid var(--line)}
+body.sessionRoute #view-session .historyModels[open]>summary:after{transform:rotate(180deg)}
+body.sessionRoute #view-session .historyModels>summary:focus-visible{outline:2px solid var(--session-signal);outline-offset:-3px}
+body.sessionRoute #view-session .historyModels .logModelList{padding:2px 12px 10px}
+body.sessionRoute #view-session .historyModels .logModelCount{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium)}
+body.sessionRoute #view-session.sessionDetail .previewRunMeta{gap:6px;margin-bottom:10px;padding:0 2px}
+body.sessionRoute #view-session.sessionDetail .previewRunMeta .badge,body.sessionRoute #view-session.sessionDetail .previewRunMeta .repo,body.sessionRoute #view-session.sessionDetail .previewRunMeta .pill,body.sessionRoute #view-session.sessionDetail .sessionDelete{background:rgb(var(--panel-rgb)/.86)}
+body.sessionRoute #view-session.sessionDetail .previewStartStrip{border-color:rgb(var(--signal-rgb)/.18);background:linear-gradient(100deg,rgb(var(--signal-rgb)/.11),rgb(var(--panel2-rgb)/.92) 46%,rgb(var(--aura-rgb)/.05));box-shadow:none}
+body.sessionRoute #view-session.sessionDetail .previewStartLabel{color:var(--session-signal-hi);font-size:var(--fs-11)}
+body.sessionRoute #view-session.sessionDetail .previewChartSlot #session-chart-module>.card{border-color:rgb(var(--signal-rgb)/.15);border-radius:var(--radius-md);background:radial-gradient(circle at 100% 0,rgb(var(--signal-rgb)/.07),transparent 28%),linear-gradient(160deg,rgb(var(--panel-rgb)/.98),rgb(var(--bg-rgb)/.98));box-shadow:none}
+body.sessionRoute #view-session.sessionDetail .previewChartSlot .chart{border-color:rgb(var(--tint-rgb)/.07);border-radius:var(--radius-sm);background:linear-gradient(180deg,rgb(var(--bg-rgb)/.72),rgb(var(--bg-deep-rgb)/.5))}
+body.sessionRoute #view-session.sessionDetail .previewStatus{padding:18px;border-color:rgb(var(--signal-rgb)/.24);border-radius:var(--radius-md);background:radial-gradient(circle at 96% 5%,rgb(var(--signal-hi-rgb)/.16),transparent 34%),radial-gradient(circle at 8% 100%,rgb(var(--aura-rgb)/.1),transparent 40%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.99),rgb(var(--bg2-rgb)/.99));box-shadow:var(--shadow-soft)}
+body.sessionRoute #view-session.sessionDetail .previewState{color:var(--good);font-size:var(--fs-11)}
+body.sessionRoute #view-session.sessionDetail .previewCost{color:var(--session-signal-hi);font-size:var(--fs-readout-xl);font-weight:var(--fw-bold);letter-spacing:-.02em;white-space:nowrap}
+body.sessionRoute #view-session.sessionDetail .previewCostNote{color:var(--dim)}
+body.sessionRoute #view-session.sessionDetail .previewPressure{border-top-color:rgb(var(--signal-rgb)/.14)}
+body.sessionRoute #view-session.sessionDetail .previewPressureHead{color:var(--dim)}
+body.sessionRoute #view-session.sessionDetail .previewPressureBar{height:8px;border-color:rgb(var(--signal-rgb)/.2);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.72)}
+body.sessionRoute #view-session.sessionDetail .previewPressureBar i{border-radius:inherit;background:linear-gradient(90deg,var(--session-signal),var(--session-signal-mid) 58%,var(--session-signal-hi))}
+body.sessionRoute #view-session.sessionDetail .previewTimes{border-top-color:rgb(var(--signal-rgb)/.12)}
+body.sessionRoute #view-session.sessionDetail .previewTimes span{color:var(--faint);font-size:var(--fs-11)}
+body.sessionRoute #view-session.sessionDetail .previewTimes b{overflow:visible;white-space:pre-line;line-height:1.35}
+body.sessionRoute #view-session.sessionDetail .previewRunBudgetSlot .sessionBudget{padding:18px;border-color:rgb(var(--signal-rgb)/.14);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--panel-rgb)/.96),rgb(var(--bg-rgb)/.98));box-shadow:none}
+body.sessionRoute #view-session.sessionDetail .previewTokenSlot .bar{border-color:rgb(var(--signal-rgb)/.16);background:rgb(var(--bg-rgb)/.7)}
+body.sessionRoute #view-session.sessionDetail .previewKpi.previewSpeed .v{color:var(--session-signal-hi);text-shadow:none}
+@media(max-width:900px){body.sessionRoute #view-session .logsSummary .logKpis{grid-template-columns:repeat(3,minmax(0,1fr))}body.sessionRoute #view-session .logsSummary .logStat:nth-child(4){border-left:0}body.sessionRoute #view-session .logsSummary .logStat:nth-child(n+4){margin-top:8px;padding-top:12px;border-top:1px solid rgb(var(--tint-rgb)/.08)}}
+@media(max-width:700px){body.sessionRoute #view-session .currentSessionMetric{padding:0 8px}body.sessionRoute #view-session .currentSessionMetric b,body.sessionRoute #view-session .currentSessionMetric b.mono{font-size:var(--fs-18)}}
+@media(max-width:520px){body.sessionRoute #view-session .sessionFlowStatus{padding:4px 8px;font-size:var(--fs-11)}body.sessionRoute #view-session .currentDaySummary{grid-template-columns:1fr;gap:10px;padding:10px 12px}body.sessionRoute #view-session .currentDayReadouts{grid-template-columns:repeat(2,minmax(0,1fr))}body.sessionRoute #view-session .currentDayMetric{padding:0 10px}body.sessionRoute #view-session .currentDayMetric:nth-child(3){grid-column:1/-1;margin-top:8px;padding:8px 10px 0;border-top:1px solid rgb(var(--signal-rgb)/.12);border-left:0}body.sessionRoute #view-session .currentDayActions{display:grid;grid-template-columns:1fr}body.sessionRoute #view-session :is(.currentDayMonth,.currentDayLearn){width:100%}body.sessionRoute #view-session .currentSessionsHead{display:grid;grid-template-columns:minmax(0,1fr) auto}body.sessionRoute #view-session .currentSessionRuntimeFilters{width:100%;max-width:none}body.sessionRoute #view-session .currentSessionCard{min-height:224px;padding:16px 14px 12px}body.sessionRoute #view-session .currentSessionIdentity h3{display:-webkit-box;min-height:44px;overflow:hidden;font-size:var(--fs-20);line-height:1.16;white-space:normal;-webkit-box-orient:vertical;-webkit-line-clamp:2}body.sessionRoute #view-session .currentSessionMetrics{margin-top:16px}body.sessionRoute #view-session .currentSessionMetric{padding-right:10px}body.sessionRoute #view-session .currentSessionMetric b,body.sessionRoute #view-session .currentSessionMetric b.mono{font-size:var(--fs-18)}body.sessionRoute #view-session .currentSessionsArrivalMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}body.sessionRoute #view-session.sessionDetail .previewCost{font-size:var(--fs-36)}}
+@media(max-width:520px){body.sessionRoute #view-session .allSessionsHead{display:block}body.sessionRoute #view-session .allSessionsHint{display:block;margin-top:6px}body.sessionRoute #view-session .logsSummary .logKpis{grid-template-columns:1fr}body.sessionRoute #view-session .logsSummary .logStat,body.sessionRoute #view-session .logsSummary .logStat:nth-child(4){margin-top:0;padding:10px 12px;border-top:1px solid rgb(var(--tint-rgb)/.08);border-left:0}body.sessionRoute #view-session .logsSummary .logStat:first-child{border-top:0}}
+@media(max-width:520px){body.sessionRoute #view-session .currentSessionFilterGroups{display:grid;width:100%;max-width:none;overflow:visible}body.sessionRoute #view-session .currentSessionFilterGroup{min-width:0;max-width:100%;overflow-x:auto;overflow-y:hidden;scrollbar-width:thin}}
+@media(prefers-reduced-motion:reduce){body.sessionRoute #view-session .currentSessionCard{transition:none}body.sessionRoute #view-session :is(.sessionFlowStatus i,.currentSessionCard.is-arriving){animation:none!important}}
+.modelCellTip.fieldtip{display:table-cell}
+.modelCellTip>span{display:none}
+.modelKpi:hover,.modelKpi:focus-within{z-index:50}
+.modelKpi:nth-child(n+4) .fieldtip:after{left:auto;right:0}
+.modelHelp:before{content:"i";display:inline-grid;place-items:center;width:13px;height:13px;margin-right:4px;border:1px solid currentColor;border-radius:var(--radius-round);font:var(--fw-heavy) var(--fs-11)/1 var(--font-mono);opacity:.72}
+.modelCoverage.fieldtip{display:block}
+.modelCoverage.fieldtip:after{bottom:auto;top:calc(100% + 7px)}
+.learnSectionHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}
+.learnSectionHead .subline{margin-top:4px;max-width:820px}
+@media(max-width:520px){.learnSectionHead{display:block}.learnSectionHead .tbtn{margin-top:10px}}
+.srOnly{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
+.welcome{position:fixed;inset:0;width:100%;max-width:none;height:100%;max-height:none;margin:0;padding:0;border:0;background:var(--spectrum-page);color:var(--fg);overflow:hidden}
+.welcome[open]{display:grid;grid-template-rows:auto minmax(0,1fr);animation:welcomeFade var(--dur-enter) var(--ease-out)}
+.welcome::backdrop{background:var(--bg-deep)}
+.welcome:before{content:"";position:absolute;inset:0;z-index:-1;pointer-events:none;background-image:var(--page-texture);background-size:var(--page-texture-size);mask-image:linear-gradient(180deg,rgb(var(--shade-rgb)/.9),rgb(var(--shade-rgb)/.28) 52%,transparent)}
+.welcomeTop{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:16px 32px;border-bottom:1px solid var(--line)}
+.welcomeBrand{display:flex;align-items:baseline;gap:12px;min-width:0}
+.welcomeBrand b{color:var(--fg);font-family:var(--font-display);font-size:var(--fs-18);font-weight:var(--fw-semibold);letter-spacing:-.01em}
+.welcomeTopActions{display:flex;align-items:center;gap:12px}
+.welcomeClose{display:grid;place-items:center;width:40px;height:40px;padding:0;border:1px solid var(--line3);border-radius:var(--radius-round);background:rgb(var(--panel-rgb)/.72);color:var(--fg);font-size:var(--fs-16);line-height:1;cursor:pointer;transition:border-color var(--dur-press) var(--ease-out),background var(--dur-press) var(--ease-out),transform var(--dur-press) var(--ease-out)}
+.welcomeClose:hover{border-color:var(--spectrum-edge-hover);background:rgb(var(--signal-rgb)/.16)}
+.welcomeClose:active{transform:scale(.94)}
+:is(.welcomeClose,.welcomeSkip,.deckSkip,.deckStep,.deckPrimary,.leverRow):focus-visible{outline:2px solid var(--signal-hi);outline-offset:2px}
+:is(.welcomeSkip,.deckSkip){padding:8px 4px;border:0;border-radius:var(--radius-sm);background:none;color:var(--dim);font:inherit;font-size:var(--fs-13);font-weight:var(--fw-semibold);cursor:pointer}
+:is(.welcomeSkip,.deckSkip):hover{color:var(--fg)}
+.deckPrimary.tourReturn{position:fixed;right:24px;bottom:24px;z-index:40;display:inline-flex;align-items:center;gap:10px;padding:14px 24px;border-radius:var(--radius-lg);font-size:var(--fs-16);font-weight:var(--fw-heavy);box-shadow:var(--spectrum-glow);animation:tourReturnIn .42s cubic-bezier(.2,.8,.2,1) both,tourReturnPulse 1.6s ease-out .45s 3}
+.tourReturn[hidden]{display:none}
+.tourReturnArrow{display:inline-block;font-size:var(--fs-18);animation:tourReturnNudge 1.6s ease-in-out .45s 3}
+.tourReturn:hover .tourReturnArrow{transform:translateX(-3px)}
+@keyframes tourReturnIn{from{transform:translateY(16px) scale(.94)}to{transform:none}}
+@keyframes tourReturnPulse{0%{box-shadow:var(--spectrum-glow),0 0 0 0 rgb(var(--signal-rgb)/.55)}70%,100%{box-shadow:var(--spectrum-glow),0 0 0 14px rgb(var(--signal-rgb)/0)}}
+@keyframes tourReturnNudge{0%,100%{transform:none}50%{transform:translateX(-5px)}}
+@media(prefers-reduced-motion:reduce){.tourReturn,.tourReturnArrow{animation:none}}
+.deck{display:grid;grid-template-columns:212px minmax(0,1fr);min-width:0;min-height:0}
+.deckInline{min-height:560px;border:1px solid var(--spectrum-border);border-radius:var(--radius-lg);background:rgb(var(--panel-rgb)/.42);overflow:clip}
+.deckInline .deckRail{position:sticky;top:0;align-self:start;max-height:100vh;border-right:0}
+.deckInline .deckMain{border-left:1px solid var(--line)}
+.deckInline .deckStage{overflow:visible}
+.deckInline .deckFoot{position:sticky;bottom:0;z-index:2;background:rgb(var(--panel-rgb)/.94);backdrop-filter:blur(12px)}
+.deckRail{min-height:0;padding:24px 12px 24px 20px;overflow:auto;border-right:1px solid var(--line)}
+.welcome .deckRail{padding-left:28px}
+.deckChapters{display:grid;gap:18px;margin:0;padding:0;list-style:none}
+.deckChapter{display:grid;gap:4px}
+.deckChapter>h3{display:flex;align-items:baseline;gap:8px;margin:0 0 2px;padding-left:8px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.deckChapter[data-state=current]>h3{color:var(--signal-hi)}
+.deckChapter ol{display:grid;gap:2px;margin:0;padding:0;list-style:none}
+.deckStep{display:grid;grid-template-columns:14px minmax(0,1fr);align-items:baseline;gap:8px;width:100%;padding:6px 8px;border:0;border-radius:var(--radius-sm);background:none;color:var(--dim);font:inherit;font-size:var(--fs-13);line-height:1.35;text-align:left;cursor:pointer;transition:background var(--dur-press) var(--ease-out),color var(--dur-press) var(--ease-out)}
+.deckStep>i{color:var(--faint);font-family:var(--font-mono);font-size:var(--fs-11);font-style:normal}
+.deckStep:hover{background:rgb(var(--tint-rgb)/.05);color:var(--fg)}
+.deckStep[data-state=done]>i{color:var(--good)}
+.deckStep[aria-current=step]{background:rgb(var(--signal-rgb)/.12);color:var(--fg);font-weight:var(--fw-semibold)}
+.deckStep[aria-current=step]>i{color:var(--signal-hi)}
+.deckMain{display:grid;grid-template-rows:minmax(0,1fr) auto;min-width:0;min-height:0}
+.deckStage{display:grid;align-items:center;min-height:0;padding:28px 40px;overflow:auto}
+.deckSlide{display:grid;grid-template-columns:minmax(0,5fr) minmax(0,6fr);align-items:center;gap:40px;width:100%;max-width:1080px;margin:0 auto}
+.deckCopy{display:grid;justify-items:start;gap:14px;min-width:0}
+.deckKicker{color:var(--signal-hi);font-size:var(--fs-12);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.deckCopy h2{margin:0;font-family:var(--font-display);font-size:var(--fs-36);font-weight:var(--fw-semibold);line-height:1.08;letter-spacing:-.02em;text-wrap:balance}
+.deckCopy p{margin:0;max-width:46ch;color:var(--dim);font-size:var(--fs-16);line-height:1.55}
+.deckInline .deckCopy h2{font-size:var(--fs-28)}
+.deckInline .deckCopy p{font-size:var(--fs-14)}
+.deckActions{display:flex;flex-wrap:wrap;align-items:center;gap:10px}
+.deckActions .tbtn{display:inline-flex;align-items:center;gap:6px;padding:8px 14px;font-size:var(--fs-13)}
+.deckVisual{padding:20px}
+.deckFoot{display:grid;grid-template-columns:minmax(0,1fr) auto minmax(0,1fr);align-items:center;gap:16px;padding:14px 40px 18px;border-top:1px solid var(--line)}
+.deckFoot[hidden]{display:none}
+.deckSkip{justify-self:start}
+.deckSkip:disabled{visibility:hidden}
+.deckCount{color:var(--faint);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.deckNav{display:flex;justify-content:flex-end;gap:8px}
+.deckNav .tbtn{min-width:88px;padding:10px 16px;font-size:var(--fs-13)}
+.deckNav .tbtn:disabled{opacity:.4;cursor:default}
+.deckPrimary{display:inline-flex;align-items:center;justify-content:center;gap:8px;min-width:88px;padding:10px 18px;border:0;border-radius:var(--radius-md);background:var(--spectrum-active);box-shadow:var(--spectrum-glow);color:var(--on-accent);font:inherit;font-size:var(--fs-13);font-weight:var(--fw-heavy);cursor:pointer;transition:transform var(--dur-press) var(--ease-out)}
+.deckPrimary:hover{background:var(--spectrum-active-hover)}
+.deckPrimary:active{transform:scale(.97)}
+.deckArrow{width:14px;height:14px;flex:0 0 auto;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
+@keyframes welcomeFade{from{opacity:0}to{opacity:1}}
+@keyframes deckRise{from{opacity:0;transform:translateY(8px)}to{opacity:1;transform:none}}
+.deckSlide.deckEnter>*{animation:deckRise var(--dur-enter) var(--ease-out) both}
+.deckSlide.deckEnter>.deckVisual{animation-delay:60ms}
+.deckVisual{min-width:0}
+.deckVisual>.conceptFrame{padding:20px 24px}
+.deckList{display:grid;gap:12px;min-width:0}
+.priceLadder{display:grid;gap:14px}
+.priceRow{display:grid;grid-template-columns:minmax(200px,auto) minmax(0,1fr) 52px 44px 24px;align-items:center;gap:12px;font-size:var(--fs-13)}
+.priceRow>b{text-align:right}
+.priceRow>small{color:var(--faint);font-size:var(--fs-12);text-align:right}
+.priceType{display:inline-flex;align-items:center;gap:8px;color:var(--fg);white-space:nowrap}
+.priceType>i{width:10px;height:10px;border-radius:var(--radius-2xs);background:var(--seg)}
+.leverList{display:grid;gap:8px;margin:0;padding:0;list-style:none}
+.leverRow{display:grid;grid-template-columns:20px minmax(0,1fr) auto 14px;align-items:center;gap:14px;width:100%;padding:14px 16px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025);color:var(--fg);font:inherit;text-align:left;cursor:pointer;transition:border-color var(--dur-press) var(--ease-out),background var(--dur-press) var(--ease-out)}
+.leverRow:hover{border-color:var(--spectrum-edge-hover);background:rgb(var(--signal-rgb)/.08)}
+.leverRow>.deckArrow{color:var(--signal-hi)}
+.leverIcon{width:20px;height:20px;fill:none;stroke:var(--signal-hi);stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round}
+.leverName{min-width:0}
+.leverName>b{font-size:var(--fs-16);font-weight:var(--fw-semibold)}
+.leverPage{color:var(--faint);font-size:var(--fs-12);white-space:nowrap}
+.menuMock{display:grid;max-width:360px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--bg-deep-rgb)/.6)}
+.menuMockBar{display:flex;align-items:center;justify-content:flex-end;gap:10px;padding:8px 12px;border-bottom:1px solid var(--line);border-radius:var(--radius-md) var(--radius-md) 0 0;background:rgb(var(--tint-rgb)/.06);font-size:var(--fs-13)}
+.menuMockBar>b{color:var(--fg)}
+.menuMockBar>span{color:var(--dim)}
+.menuMockMark{width:12px;height:12px;border:2px solid var(--signal-hi);border-radius:var(--radius-round)}
+.menuMockRows{display:grid;gap:2px;margin:0;padding:8px 12px 10px}
+.menuMockRows>div{display:flex;align-items:center;gap:12px;padding:6px 0;font-size:var(--fs-14)}
+.menuMockRows dt{margin-right:auto;color:var(--dim)}
+.menuMockRows dd{margin:0;color:var(--fg)}
+.teamsRow{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:12px;padding:12px 14px;border:1px dashed var(--line3);border-radius:var(--radius-md)}
+.teamsRow>span{display:flex;align-items:baseline;gap:10px}
+.teamsRow b{font-size:var(--fs-16)}
+.teamsRow>.tbtn{padding:8px 14px;font-size:var(--fs-13);text-decoration:none}
+.chatMock{display:grid;gap:10px}
+.chatMock>p{margin:0;font-size:var(--fs-14);line-height:1.5}
+.chatAsk{justify-self:end;max-width:85%;padding:8px 12px;border-radius:var(--radius-lg) var(--radius-lg) var(--radius-2xs) var(--radius-lg);background:rgb(var(--signal-rgb)/.14);color:var(--fg)}
+.chatTool{color:var(--faint);font-size:var(--fs-12)}
+.chatAnswer{padding:10px 12px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.04);color:var(--fg)}
+@media(max-width:1180px){.deck{grid-template-columns:200px minmax(0,1fr)}.deckStage{padding:20px 28px}.deckFoot{padding:12px 28px 16px}.deckSlide{grid-template-columns:1fr;gap:20px;max-width:760px}.deckCopy{grid-template-columns:minmax(0,1fr) auto;column-gap:24px;row-gap:8px}.deckCopy>*{grid-column:1}.deckCopy>.deckActions{grid-column:2;grid-row:1/span 3;align-self:end}.deckCopy h2,.deckInline .deckCopy h2{font-size:var(--fs-28)}.deckCopy p,.deckInline .deckCopy p{font-size:var(--fs-14)}}
+@media(max-height:800px){.welcomeTop{padding:10px 32px}.deckStage{padding-top:16px;padding-bottom:16px}.deckSlide{gap:16px}.deckCopy{gap:8px}.deckVisual>.conceptFrame{gap:12px;padding:16px 20px}.deckVisual .frameLegend{gap:6px}.deckVisual .conceptFrame>figcaption{padding-top:10px}}
+@media(max-width:900px){.deck{grid-template-columns:1fr}.deckRail{display:none}.deckFoot{grid-template-columns:auto 1fr}.deckCount{display:none}}
+@media(prefers-reduced-motion:reduce){.welcome[open],.deckSlide.deckEnter>*{animation:none}.welcomeClose,.deckPrimary,.deckStep,.leverRow,:where(.levelBar>i){transition:none}.welcomeClose:active,.deckPrimary:active{transform:none}}
+.globalControls.logsToolbar{grid-template-columns:minmax(260px,1.25fr) repeat(3,minmax(145px,.62fr));padding:14px;border:1px solid var(--line);border-radius:var(--radius-lg);background:linear-gradient(180deg,rgb(var(--panel-rgb)/.8),rgb(var(--bg2-rgb)/.78));box-shadow:var(--shadow-soft)}
+.logsToolbarRow{grid-column:1/-1;display:flex;flex-wrap:wrap;align-items:flex-end;gap:12px 20px;padding-top:12px;border-top:1px solid var(--line)}
+.logsToolbarRow .filterSort{order:1}
+.logsToolbarRow .filterChildren{order:2}
+.logsToolbar .filterClear{order:3;margin-left:auto;min-width:0}
+.logsToolbar .clearFilters{height:32px;padding:0 12px;font-size:var(--fs-12)}
+.logsToolbar .searchbox,.logsToolbar .filterSelect{height:40px}
+.logsToolbar .searchbox{background:rgb(var(--bg-rgb)/.58)}
+.logsToolbar .filterSelect{background:var(--panel)}
+.logsToolbarStatus{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:start;gap:12px;min-height:18px;margin:-3px 0 12px;padding:0 2px}
+.logsToolbarStatus .filterCount{grid-column:2;max-width:min(560px,50vw);white-space:normal;overflow-wrap:anywhere;line-height:1.3}
+.logsSummary .logStat .v{font-size:var(--fs-readout-md)}
+.activeFilters{display:flex;align-items:center;gap:6px;flex-wrap:wrap;margin:0;color:var(--faint);font-size:var(--fs-11)}
+.activeFilters[hidden]{display:none}
+.activeFilters>span{font-weight:var(--fw-bold);text-transform:uppercase}
+.activeFilters button{display:inline-flex;align-items:center;gap:6px;border:1px solid rgb(var(--signal-rgb)/.26);border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.08);color:var(--dim);padding:4px 8px;font:inherit;cursor:pointer}
+.activeFilters button:hover,.activeFilters button:focus-visible{border-color:rgb(var(--signal-rgb)/.55);color:var(--fg);outline:none}
+.activeFilters button b{color:var(--signal-hi);font-size:var(--fs-14);line-height:1}
+.srow:focus-visible{outline:0;border-color:rgb(var(--signal-rgb)/.7);box-shadow:var(--focus-ring),var(--shadow-soft)}
+.badge.app{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
+.badge.app:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
+.badge.chatgpt{color:var(--badge-neutral);border-color:rgb(var(--badge-neutral-rgb)/.3);background:rgb(var(--badge-neutral-rgb)/.08)}
+@media(max-width:1120px) and (min-width:901px){.globalControls.logsToolbar{grid-template-columns:minmax(240px,1fr) repeat(2,minmax(150px,.7fr));}.logsToolbar .logSearchControl{grid-column:1/3}}
+@media(max-width:900px){.globalControls.logsToolbar{grid-template-columns:1fr 1fr}.logsToolbar .logSearchControl{grid-column:1/-1}.logsToolbarStatus{grid-template-columns:1fr;gap:6px}.logsToolbarStatus .filterCount{grid-column:1;max-width:none;text-align:left}}
+@media(max-width:520px){.globalControls.logsToolbar{grid-template-columns:1fr}.logsToolbar .logSearchControl{grid-column:1}.srow{padding:10px 10px;gap:8px}.badge.app{font-size:var(--fs-11)}}
+@media(max-width:520px){.sessionBudgetHead,.sessionBudgetMeta{align-items:flex-start;flex-direction:column}.sessionBudgetHead{gap:8px}.sessionBudgetExact{width:100%;justify-content:space-between}.sessionBudgetExact input{width:96px}.sessionBudgetTrack{grid-template-columns:44px minmax(0,1fr) 54px;gap:6px}.sessionBudgetMeta{gap:3px}}
+@media(max-width:520px){.budgetConfigHead{display:grid;grid-template-columns:1fr;gap:8px}.budgetAlertInline{justify-content:flex-start}.budgetSessionDefault{grid-template-columns:1fr}.budgetForm input[type=number],.budgetForm input[type=text]{font-size:var(--fs-16)}.budgetForm .budgetThresholds input[type=number]{width:48px;padding-right:16px;font-size:var(--fs-14)}}
+.modelHead>div:first-child{min-width:0}
+.modelControls{grid-template-columns:minmax(150px,210px) minmax(200px,280px) minmax(130px,160px)}
+.modelControls.deliveryControls{grid-template-columns:minmax(150px,210px) minmax(130px,160px)}
+.modelScopeStatus{margin:-6px 0 10px;padding:6px 10px;border-left:2px solid var(--accent);border-radius:0 var(--radius-sm) var(--radius-sm) 0;background:rgb(var(--signal-rgb)/.055);color:var(--dim);font-size:var(--fs-11)}
+.modelScopeStatus.warn{border-left-color:var(--warn);background:rgb(var(--orange-rgb)/.055);color:var(--warn)}
+.modelScopeStatus:empty{display:none}
+.modelTrendControls #m-metric{white-space:nowrap}
+.modelChartTip{max-width:min(620px,calc(100% - 16px))}
+.modelTipMetrics{grid-template-columns:repeat(7,minmax(0,1fr));gap:6px}
+#m-chart-tip{pointer-events:auto;overscroll-behavior:contain;scrollbar-gutter:stable;scrollbar-color:var(--line2) transparent;cursor:default}
+#m-chart-tip .h{position:sticky;top:0;z-index:1}
+.signalEmpty{min-height:82px;padding:12px}
+@media(max-width:1120px) and (min-width:901px){.modelControls{grid-template-columns:minmax(130px,180px) minmax(170px,230px) minmax(120px,145px)}.modelControls.deliveryControls{grid-template-columns:minmax(130px,180px) minmax(120px,145px)}}
+@media(max-width:900px){.modelControls{grid-template-columns:repeat(3,minmax(0,1fr))}}
+@media(max-width:700px){#m-metric{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));width:100%}.modelTrendControls{display:grid;justify-content:stretch;margin-top:8px}.modelTipMetrics{grid-template-columns:repeat(4,minmax(0,1fr))}}
+@media(max-width:520px){.modelControls{grid-template-columns:1fr}}
+:is(.modelHead,.efficiencyHead).spectrumPageHead{overflow:hidden;z-index:2}
+.spectrumPageHeadFrame:has(.modelControls){z-index:10}
+.modelPickerMenu{max-height:min(360px,calc(100dvh - 136px))}
+.modelPicker.opensUp .modelPickerMenu{top:auto;bottom:calc(100% + 6px)}
+body.spectrumApp .currentSessionCard:hover,body.spectrumApp.sessionRoute #view-session .currentSessionCard:hover{transform:none}
+body.spectrumApp.sessionRoute #view-session .srow:hover{transform:none}
diff --git a/dashboard/styles/sessions-subagents.css b/dashboard/styles/sessions-subagents.css
new file mode 100644
index 00000000..db31c138
--- /dev/null
+++ b/dashboard/styles/sessions-subagents.css
@@ -0,0 +1,342 @@
+/* sessions-agent-observability-v1 */
+.agentActivity{margin-top:14px;padding:16px 18px;overflow:hidden}
+.agentActivity[hidden]{display:none}
+.agentActivity:before{content:"";position:absolute;inset:0 0 auto;height:2px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent 72%)}
+.agentActivityHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}
+.agentActivityHead h2{margin:1px 0 0;font-size:var(--fs-16)}
+.agentActivityHead p{margin:3px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
+.agentCoverage{max-width:380px;color:var(--faint);font-size:var(--fs-11);text-align:right}
+.agentActivityMetrics{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:12px}
+.agentActivityMetric{padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.025)}
+.agentActivityMetric span{font-size:var(--fs-11)}
+.agentActivityMetric strong{margin-top:3px;font-size:var(--fs-16);line-height:1.2}
+.agentActivityMetric small{margin-top:2px;font-size:var(--fs-11)}
+.agentActivityTree{margin-top:12px;overflow-x:auto;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.24);scrollbar-width:thin}
+.agentTreeHeader,.agentRow{display:grid;grid-template-columns:minmax(220px,1.5fr) minmax(105px,.8fr) 82px repeat(4,minmax(70px,.5fr));align-items:center;gap:8px;min-width:820px}
+.agentTreeHeader{padding:6px 10px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.agentTreeHeader span:not(:first-child){text-align:right}
+.agentTreeHeader .fieldtip{justify-content:flex-end}
+.agentRow{width:100%;min-height:58px;padding:8px 10px;border:0;border-top:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;text-align:left;cursor:pointer}
+.agentRow:hover,.agentRow:focus-visible{background:rgb(var(--signal-rgb)/.045);outline:none}
+.agentRow.selected{background:rgb(var(--signal-rgb)/.07);box-shadow:inset 2px 0 var(--accent)}
+.agentRow.attention{box-shadow:inset 2px 0 var(--warn)}
+.agentRow.selected.attention{box-shadow:inset 2px 0 var(--warn),inset 5px 0 rgb(var(--signal-rgb)/.38)}
+.agentIdentity{min-width:0;padding-left:calc(var(--agent-depth)*18px)}
+.agentIdentity strong{display:flex;align-items:center;gap:6px;min-width:0;color:var(--fg);font-size:var(--fs-12)}
+.agentIdentity strong span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.agentIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.agentMetric{text-align:right;font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono)}
+.agentState{display:inline-flex;align-items:center;gap:4px;justify-content:flex-end;color:var(--dim);font-size:var(--fs-11);text-transform:capitalize}
+.agentState:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:var(--faint)}
+.agentState.working:before{background:var(--good);box-shadow:0 0 0 3px rgb(var(--green-rgb)/.1)}
+.agentState.waiting:before{background:var(--warn)}
+.agentAttentionBadge{flex:none;padding:2px 6px;font-weight:var(--fw-heavy);text-transform:uppercase}
+.agentAttentionDetail{margin-top:8px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.018);color:var(--dim);font-size:var(--fs-11);line-height:1.45}
+.agentAttentionDetail b{color:var(--fg)}
+.agentAttentionDetail ul{margin:4px 0 0;padding-left:16px}
+.subagentUsageStat{padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.022);min-width:0}
+.subagentUsageStat span{font-size:var(--fs-11)}
+.subagentUsageStat strong{margin-top:3px;font-size:var(--fs-16);line-height:1.2;overflow:hidden;text-overflow:ellipsis}
+.subagentUsageStat small{margin-top:2px;font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentUsageRow{display:grid;grid-template-columns:minmax(170px,1.15fr) minmax(120px,.8fr) repeat(4,minmax(72px,.45fr));align-items:center;gap:10px;min-height:58px;border-bottom:1px solid var(--line);padding:8px 0}
+.subagentUsageIdentity strong{display:block;color:var(--fg);font-size:var(--fs-12)}
+.subagentUsageIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.subagentUsageBar{height:5px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.055)}
+.subagentUsageBar i{display:block;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi))}
+.subagentUsageValue{text-align:right}
+.subagentUsageValue span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
+.subagentUsageValue b{display:block;margin-top:2px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
+.subagentUsageEmpty{padding:24px}
+.subagentExplorerMeta{color:var(--faint);font-size:var(--fs-11);white-space:nowrap}
+.subagentExplorerStat{min-width:0;padding:12px 14px;border-left:1px solid var(--line)}
+.subagentExplorerStat:first-child{border-left:0}
+.subagentExplorerStat span{font-size:var(--fs-11)}
+.subagentExplorerStat strong{margin-top:3px;font-size:var(--fs-20);line-height:1.2}
+.subagentExplorerStat small{margin-top:3px;font-size:var(--fs-11);line-height:1.35}
+.subagentInsight{padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02)}
+.subagentInsight strong{display:flex;align-items:center;justify-content:space-between;gap:10px;color:var(--fg);font-size:var(--fs-12)}
+.subagentInsight strong b{color:var(--warn);font:var(--fw-heavy) var(--fs-14)/1 var(--font-mono)}
+.subagentInsight p{margin:4px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.4}
+.subagentInventoryHeader,.subagentInventoryRow{display:grid;grid-template-columns:minmax(230px,1.35fr) minmax(170px,1fr) minmax(125px,.75fr) 95px 105px 105px 90px;gap:10px;align-items:center;min-width:960px}
+.subagentInventoryHeader{padding:8px 14px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.subagentInventoryHeader span:not(:first-child){text-align:right}
+.subagentInventoryRow{width:100%;min-height:64px;padding:8px 14px;border:0;border-top:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;text-align:left;cursor:pointer}
+.subagentInventoryRow:hover,.subagentInventoryRow:focus-visible{background:rgb(var(--signal-rgb)/.045);outline:none}
+.subagentInventoryIdentity{min-width:0}
+.subagentInventoryIdentity strong{display:flex;align-items:center;gap:6px;min-width:0;color:var(--fg);font-size:var(--fs-12)}
+.subagentInventoryIdentity strong>span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentInventoryIdentity small{display:block;margin-top:2px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentInventoryProject{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentInventoryMetric{text-align:right;font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono)}
+.subagentInventoryEmpty{padding:32px 16px}
+.subagentInventoryWarning{margin-top:10px;border:1px solid rgb(var(--orange-rgb)/.3);border-radius:var(--radius-md);background:rgb(var(--orange-rgb)/.065);padding:10px 12px;color:var(--warn);font-size:var(--fs-11)}
+.subagentInventoryWarning[hidden]{display:none}
+.subagentCoverageNote{margin-top:10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02);padding:8px 12px;color:var(--dim);font-size:var(--fs-11);line-height:1.45}
+.subagentCoverageNote b{color:var(--fg)}
+.subagentCoverageNote[hidden]{display:none}
+@media(max-width:1100px){.agentActivityMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}.agentActivityHead{align-items:flex-start;flex-direction:column}.agentCoverage{text-align:left}.subagentUsageRow{grid-template-columns:minmax(150px,1fr) minmax(105px,.7fr) repeat(4,minmax(68px,.4fr))}}
+@media(max-width:1100px){.subagentExplorerStat:nth-child(3){border-left:0;border-top:1px solid var(--line)}.subagentExplorerStat:nth-child(4){border-top:1px solid var(--line)}}
+/* subagent-investigation-v2 */
+.subagentFilterPrimary{display:grid;grid-template-columns:minmax(240px,1.4fr) repeat(3,minmax(130px,.72fr)) auto;gap:8px;align-items:end}
+.subagentFilterPrimary .filterControl,.subagentFilterAdvanced .filterControl{min-width:0}
+.subagentFilterPrimary input,.subagentFilterPrimary select,.subagentFilterAdvanced select{width:100%}
+.subagentFilterMore{height:38px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);padding:0 12px;color:var(--dim);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);white-space:nowrap;cursor:pointer}
+.subagentFilterMore:hover,.subagentFilterMore:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.48);color:var(--fg);outline:none}
+.subagentFilterMore[aria-expanded=true]{border-color:rgb(var(--signal-rgb)/.38);background:rgb(var(--signal-rgb)/.07);color:var(--fg)}
+.subagentFilterMore span:not(:empty){display:inline-grid;min-width:18px;height:18px;margin-left:4px;place-items:center;border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.16);color:var(--signal-hi);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.subagentFilterAdvanced{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:10px;padding-top:10px;border-top:1px solid var(--line)}
+.subagentFilterAdvanced[hidden]{display:none}
+.subagentFilterFooter{display:flex;align-items:center;gap:12px;min-height:34px;margin-top:10px;padding-top:10px;border-top:1px solid var(--line)}
+.subagentActiveFilters{display:flex;flex:1;align-items:center;gap:6px;min-width:0;flex-wrap:wrap}
+.subagentActiveFilters>span{color:var(--faint);font-size:var(--fs-11)}
+.subagentFilterChip{display:inline-flex;align-items:center;gap:6px;max-width:230px;border:1px solid rgb(var(--signal-rgb)/.28);border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.065);padding:4px 8px;color:var(--dim);font:inherit;font-size:var(--fs-11);cursor:pointer}
+.subagentFilterChip:hover,.subagentFilterChip:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.58);color:var(--fg);outline:none}
+.subagentFilterChip b{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:var(--fw-bold)}
+.subagentFilterChip i{color:var(--signal-hi);font-style:normal}
+.subagentFilterFooter>.clearFilters{flex:none}
+.subagentInsight{width:100%;color:inherit;font:inherit;text-align:left;cursor:pointer}
+.subagentInsight:hover,.subagentInsight:focus-visible{border-color:rgb(var(--orange-rgb)/.36);background:rgb(var(--orange-rgb)/.04);outline:none}
+.subagentInsight[aria-pressed=true]{border-color:rgb(var(--orange-rgb)/.52);background:rgb(var(--orange-rgb)/.08);box-shadow:inset 2px 0 var(--warn)}
+.subagentInsight p{min-height:27px}
+.subagentInventoryRow.selected{background:rgb(var(--signal-rgb)/.07);box-shadow:inset 2px 0 var(--accent)}
+.subagentInventoryRow.attention.selected{box-shadow:inset 2px 0 var(--warn),inset 5px 0 rgb(var(--signal-rgb)/.38)}
+.subagentEvidence{padding:14px 16px 16px;border-top:1px solid rgb(var(--signal-rgb)/.26);border-bottom:1px solid rgb(var(--signal-rgb)/.18);background:linear-gradient(135deg,rgb(var(--signal-rgb)/.07),rgb(var(--bg2-rgb)/.84) 54%,rgb(var(--aura-rgb)/.04));box-shadow:inset 3px 0 var(--accent)}
+.subagentEvidenceHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
+.subagentEvidenceHead h4{margin:0;color:var(--fg);font-size:var(--fs-14)}
+.subagentEvidenceHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11)}
+.subagentEvidenceClose{flex:none;width:28px;height:28px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-16);cursor:pointer}
+.subagentEvidenceClose:hover,.subagentEvidenceClose:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
+.subagentEvidenceContext{display:flex;gap:6px;margin-top:10px;flex-wrap:wrap}
+.subagentEvidenceContext span{border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.025);padding:4px 8px;color:var(--dim);font-size:var(--fs-11)}
+.subagentEvidenceGrid{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:6px;margin-top:10px}
+.subagentEvidenceMetric{min-width:0;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.024);padding:8px 10px}
+.subagentEvidenceMetric span{font-size:var(--fs-11)}
+.subagentEvidenceMetric strong{margin-top:3px;overflow:hidden;font-size:var(--fs-12);line-height:1.2;text-overflow:ellipsis;white-space:nowrap}
+.subagentEvidenceSignals{margin-top:10px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.3);color:var(--dim);font-size:var(--fs-11);line-height:1.45}
+.subagentEvidenceSignals strong{color:var(--fg)}
+.subagentEvidenceSignals ul{margin:4px 0 0;padding-left:16px}
+.subagentEvidenceActions{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-top:10px}
+.subagentEvidenceActions p{margin:0;color:var(--faint);font-size:var(--fs-11)}
+.subagentOpenParent{flex:none;border:1px solid rgb(var(--signal-rgb)/.44);border-radius:var(--radius-sm);background:rgb(var(--signal-rgb)/.09);padding:6px 10px;color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer}
+.subagentOpenParent:hover,.subagentOpenParent:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.7);background:rgb(var(--signal-rgb)/.15);color:var(--fg);outline:none}
+@media(max-width:1100px){.subagentFilterPrimary{grid-template-columns:minmax(220px,1.2fr) repeat(2,minmax(125px,.7fr));}.subagentFilterPrimary .filterControl:nth-child(4){grid-column:1/2}.subagentFilterMore{grid-column:3/4}.subagentEvidenceGrid{grid-template-columns:repeat(3,minmax(0,1fr))}}
+@media(max-width:760px){.subagentFilterPrimary,.subagentFilterAdvanced{grid-template-columns:1fr 1fr}.subagentFilterPrimary .filterControl:first-child{grid-column:1/-1}.subagentFilterPrimary .filterControl:nth-child(4),.subagentFilterMore{grid-column:auto}.subagentEvidenceGrid{grid-template-columns:repeat(2,minmax(0,1fr))}.subagentEvidenceActions{align-items:flex-start;flex-direction:column}}
+/* subagent-investigation-v3 */
+body.sessionRoute #view-session.sessionSubagents .currentDaySummary{display:none}
+.subagentCommand{overflow:hidden;padding:0;box-shadow:var(--shadow-soft)}
+.subagentViewTabs{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));border-bottom:1px solid var(--line);background:rgb(var(--bg-rgb)/.26)}
+.subagentViewTabs{grid-template-columns:repeat(2,minmax(0,1fr))}
+#view-subagents .subagentViewTabs{display:none}
+#view-session .subagentViewTabs [data-subagent-view=roles]{display:none}
+.subagentViewTabs button{display:flex;min-height:48px;align-items:center;justify-content:center;gap:8px;border:0;border-right:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;font-size:var(--fs-12);font-weight:var(--fw-heavy);cursor:pointer}
+.subagentViewTabs button:last-child{border-right:0}
+.subagentViewTabs button:hover,.subagentViewTabs button:focus-visible{background:rgb(var(--signal-rgb)/.045);color:var(--fg);outline:none}
+.subagentViewTabs button[aria-selected=true]{background:linear-gradient(180deg,rgb(var(--signal-rgb)/.12),rgb(var(--signal-rgb)/.035));box-shadow:inset 0 -2px var(--accent);color:var(--fg)}
+.subagentViewTabs small{display:inline-grid;min-width:24px;height:20px;place-items:center;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.035);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.subagentViewTabs button[aria-selected=true] small{border-color:rgb(var(--signal-rgb)/.38);background:rgb(var(--signal-rgb)/.1);color:var(--signal-hi)}
+.subagentCommand .subagentFilterPrimary{padding:12px 12px 0}
+.subagentCommand .subagentFilterAdvanced{margin:10px 12px 0}
+.subagentCommand .subagentFilterFooter{margin:10px 12px 0;padding-bottom:10px}
+.subagentCommand .subagentFilterFooter[hidden]{display:none}
+.subagentCompactSummary{display:flex;align-items:center;gap:8px;margin-top:10px;overflow-x:auto;scrollbar-width:thin}
+.subagentCompactMetric{display:flex;min-width:max-content;align-items:baseline;gap:6px;border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.022);padding:6px 10px;color:var(--faint);font:inherit;font-size:var(--fs-11)}
+.subagentCompactMetric b{color:var(--fg);font:var(--fw-heavy) var(--fs-12)/1 var(--font-mono)}
+.subagentCompactMetric.warn{border-color:rgb(var(--orange-rgb)/.3);background:rgb(var(--orange-rgb)/.055)}
+.subagentCompactMetric.warn b{color:var(--warn)}
+.subagentCompactMetric.dim b{color:var(--dim)}
+.subagentCompactMetric.actionable{cursor:pointer}
+.subagentCompactMetric.actionable:hover,.subagentCompactMetric.actionable:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.52);background:rgb(var(--signal-rgb)/.075);color:var(--fg);outline:none}
+.subagentCompactMetric.actionable[aria-pressed=true]{border-color:rgb(var(--signal-rgb)/.58);background:rgb(var(--signal-rgb)/.13);box-shadow:inset 0 0 0 1px rgb(var(--signal-rgb)/.12);color:var(--signal-hi)}
+.subagentCompactMetric.actionable[aria-pressed=true] b{color:var(--signal-hi)}
+.subagentWorkspace{display:grid;grid-template-columns:minmax(0,1fr) minmax(300px,340px);gap:12px;align-items:start;margin-top:12px}
+.subagentResultsCard{overflow:hidden;box-shadow:var(--shadow-soft)}
+.subagentResultsHead{display:flex;min-height:58px;align-items:center;justify-content:space-between;gap:14px;padding:12px 14px;border-bottom:1px solid var(--line)}
+.subagentResultsHead h3{margin:0;font-size:var(--fs-13)}
+.subagentResultsHead p{margin:2px 0 0;color:var(--faint);font-size:var(--fs-11)}
+.subagentResultsHead>span{flex:none;color:var(--faint);font-size:var(--fs-11)}
+.subagentResultsEmpty{min-height:220px;padding:28px}
+.subagentResultsEmpty strong{display:block;margin-bottom:4px;color:var(--fg);font-size:var(--fs-13)}
+.subagentWorkspace.roleView{grid-template-columns:1fr}
+.subagentWorkspace.roleView .subagentInspector{display:none}
+.subagentModelDistribution{margin-top:12px;padding:12px 14px}
+.subagentModelHead{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-bottom:10px}
+.subagentModelHead h3{margin:0;font-size:var(--fs-12)}
+.subagentModelHead small{color:var(--faint);font-size:var(--fs-11)}
+.subagentModelRows{display:grid;gap:6px}
+.subagentModelRow{display:grid;grid-template-columns:minmax(150px,1fr) minmax(90px,2fr) 52px 90px;align-items:center;gap:12px;color:var(--dim);font-size:var(--fs-11)}
+.subagentModelIdentity{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentModelIdentity strong{color:var(--fg)}
+.subagentModelTrack{height:7px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.07)}
+.subagentModelTrack i{display:block;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi))}
+.subagentModelNumber{text-align:right;font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.subagentModelCost{text-align:right;font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.subagentModelCost small{display:block;margin-top:4px;color:var(--faint);font:var(--fw-medium) var(--fs-11)/1.2 var(--font-sans)}
+.subagentSessionGroup{border-bottom:1px solid var(--line);background:rgb(var(--bg-rgb)/.12)}
+.subagentSessionGroup:last-child{border-bottom:0}
+.subagentSessionGroup>summary{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:center;gap:16px;min-height:70px;padding:10px 14px;list-style:none;cursor:pointer}
+.subagentSessionGroup>summary::-webkit-details-marker{display:none}
+.subagentSessionGroup>summary:hover,.subagentSessionGroup>summary:focus-visible{background:rgb(var(--signal-rgb)/.035);outline:none}
+.subagentSessionGroup[open]>summary{background:linear-gradient(90deg,rgb(var(--signal-rgb)/.065),transparent 72%);box-shadow:inset 2px 0 var(--accent)}
+.subagentSessionGroup.hasAttention>summary{box-shadow:inset 2px 0 var(--warn)}
+.subagentSessionIdentity{min-width:0}
+.subagentSessionIdentity strong{display:flex;align-items:center;gap:6px;color:var(--fg);font-size:var(--fs-12)}
+.subagentSessionIdentity strong span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentSessionIdentity small{display:block;margin-top:3px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentSessionBadge{padding:2px 6px;font-weight:var(--fw-heavy);text-transform:uppercase;white-space:nowrap}
+.subagentSessionMetrics{display:grid;grid-template-columns:repeat(3,minmax(58px,auto));gap:8px;text-align:right}
+.subagentSessionMetric span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
+.subagentSessionMetric b{display:block;margin-top:2px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
+.subagentSessionGroup>summary:after{content:"›";position:absolute;right:9px;color:var(--faint);transform:rotate(90deg)}
+.subagentSessionGroup[open]>summary:after{transform:rotate(-90deg)}
+.subagentChildHeader,.subagentChildRow{display:grid;grid-template-columns:minmax(150px,1.2fr) minmax(92px,.75fr) minmax(72px,.5fr) minmax(68px,.48fr);align-items:center;gap:8px}
+.subagentChildHeader{padding:6px 14px;border-top:1px solid var(--line);background:rgb(var(--shade-rgb)/.12);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.subagentChildHeader span:not(:first-child){text-align:right}
+.subagentChildRow{width:100%;min-height:58px;padding:8px 14px;border:0;border-top:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;text-align:left;cursor:pointer}
+.subagentChildRow:hover,.subagentChildRow:focus-visible{background:rgb(var(--signal-rgb)/.04);outline:none}
+.subagentChildRow.selected{background:rgb(var(--signal-rgb)/.08);box-shadow:inset 3px 0 var(--accent)}
+.subagentChildRow.attention{box-shadow:inset 2px 0 var(--warn)}
+.subagentChildRow.attention.selected{box-shadow:inset 2px 0 var(--warn),inset 5px 0 rgb(var(--signal-rgb)/.36)}
+.subagentChildIdentity{min-width:0}
+.subagentChildIdentity strong{display:flex;align-items:center;gap:6px;min-width:0;color:var(--fg);font-size:var(--fs-11)}
+.subagentChildIdentity strong>span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagentChildIdentity small{display:block;margin-top:2px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentChildMetric{text-align:right;font:var(--fw-semibold) var(--fs-11)/1.25 var(--font-mono)}
+.subagentSiblingLink{width:100%;border:0;border-top:1px solid var(--line);background:rgb(var(--signal-rgb)/.025);padding:10px 14px;color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);text-align:left;cursor:pointer}
+.subagentSiblingLink:hover,.subagentSiblingLink:focus-visible{background:rgb(var(--signal-rgb)/.07);color:var(--fg);outline:none}
+.subagentInspector{position:sticky;top:76px;min-height:310px;overflow:hidden;padding:14px;box-shadow:var(--shadow-soft)}
+.subagentInspector:before{content:"";position:absolute;inset:0 0 auto;height:2px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent)}
+.subagentInspectorEmpty{min-height:278px}
+.subagentInspectorEmpty svg{width:34px;height:34px;margin:auto;fill:none;stroke:var(--faint);stroke-width:1.5}
+.subagentInspectorEmpty strong{display:block;margin-top:10px;color:var(--fg);font-size:var(--fs-12)}
+.subagentInspectorEmpty p{max-width:235px;margin:4px auto 0;color:var(--faint);font-size:var(--fs-11);line-height:1.45}
+.subagentInspectorHead{display:flex;align-items:flex-start;justify-content:space-between;gap:10px}
+.subagentInspectorHead h3{margin:0;color:var(--fg);font-size:var(--fs-14);overflow-wrap:anywhere}
+.subagentInspectorHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11)}
+.subagentInspectorClose{flex:none;width:28px;height:28px;border:1px solid var(--line);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-16);cursor:pointer}
+.subagentInspectorClose:hover,.subagentInspectorClose:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
+.subagentInspectorParent{margin-top:12px;padding:8px 10px;border:1px solid rgb(var(--signal-rgb)/.2);border-radius:var(--radius-sm);background:rgb(var(--signal-rgb)/.045)}
+.subagentInspectorParent span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.subagentInspectorParent strong{display:block;margin-top:3px;overflow:hidden;color:var(--fg);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentInspectorParent small{display:block;margin-top:2px;color:var(--dim);font-size:var(--fs-11)}
+.subagentInspectorTags{display:flex;gap:4px;margin-top:8px;flex-wrap:wrap}
+.subagentInspectorTags span{border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.025);padding:3px 6px;color:var(--dim);font-size:var(--fs-11)}
+.subagentInspectorGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;margin-top:10px}
+.subagentInspectorMetric{min-width:0;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.02);padding:8px 8px}
+.subagentInspectorMetric span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.subagentInspectorMetric b{display:block;margin-top:3px;overflow:hidden;color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono);text-overflow:ellipsis;white-space:nowrap}
+.subagentInspectorSignals{margin-top:10px;padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.28);color:var(--dim);font-size:var(--fs-11);line-height:1.45}
+.subagentInspectorSignals>strong{color:var(--fg)}
+.subagentInspectorSignals ul{margin:4px 0 0;padding-left:16px}
+.subagentInspectorSignals p{margin:4px 0 0}
+.subagentInspectorAction{width:100%;margin-top:10px}
+.subagentRoleTable{overflow-x:auto}
+.subagentRoleHeader,.subagentRoleRow{display:grid;grid-template-columns:minmax(170px,1.15fr) repeat(5,minmax(72px,.55fr));align-items:center;gap:10px;min-width:690px}
+.subagentRoleHeader{padding:8px 14px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.subagentRoleHeader span:not(:first-child){text-align:right}
+.subagentRoleRow{min-height:68px;padding:8px 14px;border-top:1px solid var(--line)}
+.subagentRoleIdentity{min-width:0}
+.subagentRoleIdentity strong{display:block;overflow:hidden;color:var(--fg);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentRoleIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.subagentRoleMetric{text-align:right}
+.subagentRoleMetric span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
+.subagentRoleMetric b{display:block;margin-top:2px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
+.subagentRoleMetric.warn b{color:var(--warn)}
+.subagentSessionMetrics{grid-template-columns:repeat(4,minmax(58px,auto))}
+.subagentRoleHeader,.subagentRoleRow{grid-template-columns:minmax(170px,1.15fr) repeat(6,minmax(72px,.55fr));min-width:780px}
+.subagentRoleEconomics{padding:12px}
+.subagentRoleKpis{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}
+.subagentRoleKpi{min-width:0;padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--tint-rgb)/.03),rgb(var(--bg-rgb)/.18))}
+.subagentRoleKpi span{font-size:var(--fs-11)}
+.subagentRoleKpi strong{margin-top:4px;overflow:hidden;font-size:var(--fs-18);line-height:1.15;text-overflow:ellipsis;white-space:nowrap}
+.subagentRoleKpi small{margin-top:3px;overflow:hidden;font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentRoleKpi.good strong{color:var(--good)}
+.subagentRoleKpi.warn strong{color:var(--warn)}
+.subagentRoleTrendHead{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:14px 2px 6px}
+.subagentRoleTrendHead h4{margin:0;color:var(--fg);font-size:var(--fs-12)}
+.subagentRoleTrendHead p{margin:2px 0 0;color:var(--faint);font-size:var(--fs-11)}
+.subagentRoleChartModes{flex:none}
+.subagentRoleChartModes button{padding:4px 8px;font-size:var(--fs-11)}
+.subagentRoleTrendList{overflow:hidden;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.2)}
+.subagentRoleTrendRow{display:grid;grid-template-columns:minmax(175px,1.05fr) minmax(88px,.5fr) minmax(180px,1fr) minmax(150px,.8fr) auto;align-items:center;gap:14px;min-height:82px;padding:10px 12px;border-top:1px solid var(--line)}
+.subagentRoleTrendRow:first-child{border-top:0}
+.subagentRoleIdentity{min-width:0}
+.subagentRoleIdentity strong{display:block;overflow:hidden;color:var(--fg);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.subagentRoleIdentity small{display:block;margin-top:3px;color:var(--faint);font-size:var(--fs-11);line-height:1.35}
+.subagentRolePrimary span,.subagentRoleMeta span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.subagentRolePrimary b{display:block;margin-top:3px;color:var(--fg);font:var(--fw-bold) var(--fs-13)/1.2 var(--font-mono)}
+.subagentRolePrimary small{display:block;margin-top:3px;color:var(--dim);font-size:var(--fs-11)}
+.subagentRolePrimary.good small{color:var(--good)}
+.subagentRolePrimary.warn small{color:var(--warn)}
+.subagentRoleSpark{min-width:0;height:48px}
+.subagentRoleSpark svg{display:block;width:100%;height:48px;overflow:visible}
+.subagentRoleSparkEmpty{display:flex;height:48px;align-items:center;color:var(--faint);font-size:var(--fs-11)}
+.subagentRoleMeta{display:flex;align-items:center;gap:6px;flex-wrap:wrap}
+.subagentRoleMeta>span:first-child{margin-right:3px}
+.subagentRoleMeta b{color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
+.subagentRoleSignal{border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.025);padding:3px 6px;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-bold)}
+.subagentRoleSignal.warn{border-color:rgb(var(--orange-rgb)/.34);background:rgb(var(--orange-rgb)/.065);color:var(--warn)}
+.subagentRoleInspect{justify-self:end;border:1px solid rgb(var(--signal-rgb)/.34);border-radius:var(--radius-sm);background:rgb(var(--signal-rgb)/.065);padding:6px 8px;color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer;white-space:nowrap}
+.subagentRoleInspect:hover,.subagentRoleInspect:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.68);background:rgb(var(--signal-rgb)/.12);color:var(--fg);outline:none}
+.subagentRoleEconomicsFoot{margin:8px 2px 0;color:var(--faint);font-size:var(--fs-11)}
+.subagentRoleAnalyticsEmpty{margin:12px;border:1px solid rgb(var(--orange-rgb)/.28);border-radius:var(--radius-md);background:rgb(var(--orange-rgb)/.05);padding:12px;color:var(--dim)}
+.subagentRoleAnalyticsEmpty strong{display:block;color:var(--fg);font-size:var(--fs-11)}
+.subagentRoleAnalyticsEmpty p{margin:4px 0 0;font-size:var(--fs-11)}
+.subagentRoleAnalyticsEmpty+.subagentRoleTable{border-top:1px solid var(--line)}
+.subagentSessionGroup>summary{position:relative;padding-right:24px}
+@media(max-width:1180px){.subagentWorkspace{grid-template-columns:minmax(0,1fr) 300px}.subagentSessionMetrics{gap:8px}.subagentChildHeader,.subagentChildRow{grid-template-columns:minmax(130px,1fr) minmax(82px,.7fr) minmax(68px,.48fr) minmax(62px,.44fr)}}
+@media(max-width:1100px){.subagentCommand .subagentFilterPrimary .filterControl:nth-child(4){grid-column:1/3}.subagentRoleTrendRow{grid-template-columns:minmax(160px,1fr) minmax(82px,.5fr) minmax(150px,.9fr) auto}.subagentRoleMeta{grid-column:1/4}.subagentRoleInspect{grid-column:4;grid-row:1/3}}
+@media(max-width:900px){.subagentWorkspace{grid-template-columns:1fr}.subagentInspector{position:relative;top:auto}.subagentFilterPrimary{grid-template-columns:repeat(2,minmax(0,1fr))}.subagentFilterPrimary .filterControl:first-child{grid-column:1/-1}.subagentFilterPrimary .filterControl:nth-child(4),.subagentFilterMore{grid-column:auto}.subagentSessionGroup>summary{grid-template-columns:1fr}.subagentSessionMetrics{text-align:left}.subagentSessionMetric{display:inline-flex;align-items:baseline;gap:4px}.subagentSessionMetric span,.subagentSessionMetric b{display:inline}.subagentChildHeader,.subagentChildRow{grid-template-columns:minmax(140px,1fr) minmax(80px,.7fr) minmax(66px,.45fr) minmax(62px,.42fr)}}
+.subagentCostHeat{position:relative;display:block;min-width:0;padding-bottom:8px;color:var(--cost-heat);font-weight:var(--fw-bold)}
+.subagentCostHeat:after{content:"";position:absolute;right:0;bottom:1px;width:var(--cost-fill);height:3px;max-width:100%;border-radius:var(--radius-xs);background:linear-gradient(90deg,var(--session-signal),var(--cost-heat))}
+.subagentCostHeat[style=""]{color:inherit}
+.subagentRoleKpi span{font-size:var(--fs-11)}
+.subagentRoleKpi strong{font-size:var(--fs-22)}
+.subagentRoleKpi small{font-size:var(--fs-11);line-height:1.35}
+.subagentRoleTrendHead h4{font-size:var(--fs-16)}
+.subagentRoleTrendHead p{font-size:var(--fs-11)}
+.subagentRoleChartModes button{font-size:var(--fs-11)}
+.subagentRoleTrendRow{min-height:116px}
+.subagentRoleIdentity strong{font-size:var(--fs-12)}
+.subagentRoleIdentity small{font-size:var(--fs-11);line-height:1.4}
+.subagentRolePrimary span,.subagentRoleMeta span{font-size:var(--fs-11)}
+.subagentRolePrimary b{font-size:var(--fs-16)}
+.subagentRolePrimary small{font-size:var(--fs-11)}
+.subagentRoleMeta b{font-size:var(--fs-11)}
+.subagentRoleSignal{font-size:var(--fs-11)}
+.subagentRoleInspect{font-size:var(--fs-11)}
+.subagentRoleEconomicsFoot{font-size:var(--fs-11);line-height:1.4}
+.subagentRoleSpark{display:flex;height:83px;flex-direction:column;justify-content:center}
+.subagentRoleSpark svg{height:62px;flex:none}
+.subagentRoleSparkDates{display:flex;justify-content:space-between;gap:8px;margin-top:3px;color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.subagentRoleSparkDates span:last-child{text-align:right}
+.subagentRoleHeader,.subagentRoleRow{grid-template-columns:minmax(170px,1.2fr) repeat(5,minmax(82px,.56fr));min-width:750px}
+.subagentResultsHead h3{font-size:var(--fs-16)}
+.subagentResultsHead p{font-size:var(--fs-11);line-height:1.4}
+.subagentSessionIdentity strong{font-size:var(--fs-13)}
+.subagentSessionIdentity small{font-size:var(--fs-11)}
+.subagentSessionMetric span{font-size:var(--fs-11)}
+.subagentSessionMetric b{font-size:var(--fs-12)}
+.subagentChildHeader{font-size:var(--fs-11)}
+.subagentChildIdentity strong{font-size:var(--fs-12)}
+.subagentChildIdentity small{font-size:var(--fs-11)}
+.subagentChildMetric{font-size:var(--fs-11)}
+.subagentInspectorHead h3{font-size:var(--fs-16)}
+.subagentInspectorMetric span{font-size:var(--fs-11)}
+.subagentInspectorMetric b{font-size:var(--fs-12)}
+.subagentInspectorEmpty p{font-size:var(--fs-11)}
+#view-subagents .subagentExplorerMeta{font-size:var(--fs-12);font-weight:var(--fw-semibold);color:var(--dim)}
+#view-subagents .subagentWorkspace.roleView .subagentResultsHead{display:none}
+#view-subagents .subagentRoleEconomics{padding:18px}
+#view-subagents .subagentRoleKpis{gap:0;overflow:hidden;border:1px solid var(--line2);border-radius:var(--radius-lg);background:linear-gradient(105deg,rgb(var(--signal-rgb)/.055),rgb(var(--tint-rgb)/.015) 52%,rgb(var(--signal-hi-rgb)/.03))}
+#view-subagents .subagentRoleKpi{border:0;border-left:1px solid var(--line);border-radius:0;background:none;padding:14px 18px}
+#view-subagents .subagentRoleKpi:first-child{border-left:0}
+#view-subagents .subagentRoleKpi strong{font-size:var(--fs-24)}
+#view-subagents .subagentRoleTrendHead{margin-top:20px;margin-bottom:10px}
+#view-subagents .subagentRoleTrendRow{min-height:108px}
+#view-subagents .subagentRoleIdentity strong{font-size:var(--fs-13)}
+#view-subagents .subagentRoleEconomicsFoot{margin-top:10px}
+#view-subagents .subagentCompactSummary{margin-top:8px}
+#view-subagents .subagentWorkspace{margin-top:10px}
+#view-subagents .subagentCommand .subagentFilterPrimary{padding-bottom:12px}
+#view-subagents .subagentCommand .subagentFilterFooter{margin-top:0}
+@media(max-width:1100px){#view-subagents .subagentRoleKpi{padding:12px}#view-subagents .subagentRoleKpi strong{font-size:var(--fs-20)}}
diff --git a/dashboard/styles/shell.css b/dashboard/styles/shell.css
new file mode 100644
index 00000000..7a3ffe8d
--- /dev/null
+++ b/dashboard/styles/shell.css
@@ -0,0 +1,318 @@
+/* shared-spectrum-system-v1 */
+/* spectrum-professional-finish-v2 */
+@font-face{font-family:"Tektur Local";src:url("/assets/fonts/Tektur-Variable.ttf") format("truetype");font-style:normal;font-weight:400 900;font-stretch:75% 100%;font-display:swap}
+body.spectrumApp{background:var(--spectrum-page)}
+body.spectrumApp:after{content:"";position:fixed;inset:-18%;z-index:-2;pointer-events:none;background:radial-gradient(34% 28% at 28% 22%,rgb(var(--signal-rgb)/calc(.13*var(--glow))),transparent 70%),radial-gradient(30% 26% at 78% 68%,rgb(var(--aura-rgb)/calc(.1*var(--glow))),transparent 70%),radial-gradient(26% 22% at 52% 96%,rgb(var(--signal-hi-rgb)/calc(.07*var(--glow))),transparent 70%);animation:atmosphereDrift 46s ease-in-out infinite alternate}
+@keyframes atmosphereDrift{0%{transform:translate3d(-3%,-2%,0) scale(1)}100%{transform:translate3d(3%,2%,0) scale(1.06)}}
+@keyframes foilDrift{0%{background-position:0 0}100%{background-position:200% 0}}
+@keyframes ionSheen{0%{transform:translateX(-120%)}100%{transform:translateX(220%)}}
+/* vertical-navigation-rail-v1 */
+body.spectrumApp .wrap{--navigation-rail-width:184px;display:grid;grid-template-columns:var(--navigation-rail-width) minmax(0,1320px);column-gap:20px;align-items:start;width:100%;max-width:1532px}
+body.spectrumApp .wrap>:not(.top){grid-column:2;min-width:0}
+body.spectrumApp .top{grid-column:1;grid-row:1;position:sticky;top:18px;z-index:20;display:flex;height:calc(100vh - 36px);min-height:520px;align-items:stretch;flex-direction:column;gap:12px;margin:0;padding:12px;border:1px solid var(--spectrum-border);border-radius:var(--radius-lg);background:radial-gradient(ellipse 120% 38% at 18% -4%,rgb(var(--signal-rgb)/.22),transparent 62%),radial-gradient(ellipse 110% 42% at 118% 84%,rgb(var(--aura-rgb)/.11),transparent 62%),linear-gradient(165deg,rgb(var(--panel-rgb)/.86),rgb(var(--bg-lift-rgb)/.84) 52%,rgb(var(--bg-rgb)/.9));box-shadow:var(--spectrum-depth-focus);backdrop-filter:blur(22px) saturate(1.25)}
+body.spectrumApp .top:before{content:"";position:absolute;inset:0 12px auto;height:1px;background:var(--spectrum-foil);background-size:200% 100%;opacity:.8;animation:foilDrift 14s linear infinite}
+body.spectrumApp .top .brand{flex:0 0 auto;min-width:0;padding:3px 2px 0}
+.brandCopy{display:grid;min-width:0;line-height:1.1}
+.brandName{overflow:hidden;text-overflow:ellipsis}
+body.spectrumApp .top .tabs{display:flex;min-width:0;max-width:100%;overflow:visible;flex:1;flex-direction:column;gap:4px;padding:10px 0 0;border:0;border-top:1px solid var(--line);border-radius:0;background:transparent;box-shadow:none;scrollbar-width:none}
+body.spectrumApp .top .tabs::-webkit-scrollbar{display:none}
+.navPrimary,.navSecondary{display:flex;flex-direction:column;gap:4px}
+.navSecondary{margin-top:auto;padding-top:10px;border-top:1px solid var(--line)}
+body.spectrumApp .top .tab{display:grid;width:100%;min-height:42px;grid-template-columns:18px minmax(0,1fr);align-items:center;gap:10px;padding:8px 10px;text-align:left}
+.tabIcon{width:18px;height:18px;fill:none;stroke:currentColor;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round}
+.tabLabel{min-width:0;overflow:hidden;text-overflow:ellipsis}
+body.spectrumApp .top>.spacer{display:none}
+@media(max-width:1180px){body.spectrumApp .wrap{--navigation-rail-width:68px;column-gap:16px;padding-right:18px;padding-left:18px}body.spectrumApp .top{padding:10px 8px}body.spectrumApp .top .brand{justify-content:center;padding-right:0;padding-left:0}.logo,.logo img{width:50px}body.spectrumApp .top .brandCopy,body.spectrumApp .top .tabLabel{display:none}body.spectrumApp .top .tab{display:grid;grid-template-columns:1fr;place-items:center;padding:8px}}
+@media(max-width:760px){body.spectrumApp .wrap{display:block;max-width:1320px;padding:12px 14px 64px}body.spectrumApp .wrap>:not(.top){min-width:0}body.spectrumApp .top{position:sticky;top:0;display:grid;height:auto;min-height:0;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:8px;margin:0 0 14px;padding:8px 0 10px;border:0;border-bottom:1px solid var(--spectrum-border);border-radius:0;background:radial-gradient(ellipse 62% 90% at 5% 0,rgb(var(--signal-rgb)/.16),transparent 70%),linear-gradient(180deg,var(--bg),var(--bg-lift));box-shadow:0 10px 26px rgb(var(--shade-rgb)/.28)}body.spectrumApp .top:before{inset:auto 0 0}body.spectrumApp .top .brand{grid-column:1;grid-row:1;justify-content:flex-start;padding:0}.logo,.logo img{width:58px}body.spectrumApp .top .brandCopy{display:grid}body.spectrumApp .top .tabs{grid-column:1/-1;grid-row:2;min-width:0;width:100%;overflow-x:auto;flex:none;flex-direction:row;gap:3px;padding:8px 0 0;border-top:1px solid var(--line)}.navPrimary,.navSecondary{display:contents}body.spectrumApp .top .tab{display:flex;width:auto;min-height:38px;grid-template-columns:none;gap:6px;padding:8px 10px;white-space:nowrap}body.spectrumApp .top .tabLabel{display:inline}}
+@media(max-width:760px){#view-models{overflow-x:clip}}
+@media(max-width:520px){.brandName{font-size:var(--fs-14)}}
+body.spectrumApp .seg{border-color:var(--spectrum-border);background:var(--spectrum-control);box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.055),0 6px 18px rgb(var(--shade-rgb)/.1)}
+body.spectrumApp .tab.on,body.spectrumApp .seg button.on{background:var(--spectrum-active);color:var(--on-accent);box-shadow:var(--spectrum-glow)}
+body.spectrumApp .top .tab{position:relative;overflow:hidden}
+body.spectrumApp .top .tab.on:after{content:"";position:absolute;inset:0 auto 0 0;width:40%;pointer-events:none;background:linear-gradient(100deg,transparent,rgb(var(--tint-rgb)/.42),transparent);transform:translateX(-120%);animation:ionSheen .9s var(--spectrum-ease) .08s 1 both}
+body.spectrumApp .tab.on:hover,body.spectrumApp .seg button.on:hover{background:var(--spectrum-active-hover)}
+body.spectrumApp .tab:hover:not(.on),body.spectrumApp .seg button:hover:not(.on){background:linear-gradient(135deg,rgb(var(--signal-rgb)/.105),rgb(var(--aura-rgb)/.055));color:var(--fg)}
+body.spectrumApp .card{border-color:var(--spectrum-border);background:var(--spectrum-card);box-shadow:var(--spectrum-shadow)}
+body.spectrumApp .card:hover{border-color:var(--spectrum-edge-hover);box-shadow:var(--spectrum-depth-focus),0 0 0 1px rgb(var(--signal-rgb)/.1),0 0 32px rgb(var(--signal-rgb)/calc(.1*var(--glow)))}
+body.spectrumApp .tbtn{border-color:rgb(var(--signal-rgb)/.3);background:radial-gradient(circle at 88% 0,rgb(var(--signal-hi-rgb)/.12),transparent 52%),linear-gradient(145deg,rgb(var(--signal-rgb)/.18),rgb(var(--signal-mid-rgb)/.075));box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.075),0 6px 16px rgb(var(--shade-rgb)/.12);transition:border-color .16s,background .16s,box-shadow .16s,color .16s}
+body.spectrumApp .tbtn:hover:not(:disabled){border-color:var(--spectrum-edge-hover);background:radial-gradient(circle at 88% 0,rgb(var(--signal-hi-rgb)/.17),transparent 52%),linear-gradient(145deg,rgb(var(--signal-rgb)/.25),rgb(var(--signal-mid-rgb)/.11));box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.1),0 8px 20px rgb(var(--signal-rgb)/.12)}
+/* After the spectrum button rules: the turn-on button must win their signal fill (see DESIGN.md Buttons). */
+:is(body,body.spectrumApp) .tbtn.go{padding:10px 18px;border-color:rgb(var(--green-rgb)/.7);background:var(--good);box-shadow:none;color:var(--on-accent-deep);font-size:var(--fs-14);font-weight:var(--fw-heavy)}
+:is(body,body.spectrumApp) .tbtn.go:hover:not(:disabled){border-color:var(--good);background:rgb(var(--green-rgb)/.86);box-shadow:none}
+:is(body,body.spectrumApp) .tbtn.go:focus-visible{outline:2px solid var(--good);outline-offset:2px}
+body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary){border-color:var(--spectrum-border);background:var(--spectrum-control);box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.035),0 5px 14px rgb(var(--shade-rgb)/.1)}
+body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary):hover{border-color:var(--spectrum-border-strong)}
+body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary):focus{outline:none;border-color:var(--signal-hi);box-shadow:0 0 0 3px rgb(var(--signal-rgb)/.16),0 9px 22px rgb(var(--signal-rgb)/.12)}
+body.spectrumApp :is(button,input,select,textarea,summary):focus-visible{outline:2px solid var(--signal-hi);outline-offset:2px}
+body.spectrumApp .meter{background:none;color:var(--signal-hi);-webkit-background-clip:initial;background-clip:initial}
+body.spectrumApp .tbl th,body.spectrumApp .modelTableWrap .tbl th,body.spectrumApp .capTableWrap .tbl th{background:linear-gradient(180deg,rgb(var(--panel-rgb)/.99),rgb(var(--bg-lift-rgb)/.99));box-shadow:inset 0 -1px 0 var(--spectrum-border)}
+body.spectrumApp .tbl tr:hover td{background:linear-gradient(90deg,rgb(var(--signal-rgb)/.055),rgb(var(--aura-rgb)/.025))}
+.spectrumPageHeadFrame{position:relative;width:100%;margin:0 0 16px}
+@property --ring-angle{syntax:"<angle>";inherits:false;initial-value:0deg}
+@keyframes ringSpin{to{--ring-angle:360deg}}
+@keyframes titleShimmer{0%{background-position:0 0}100%{background-position:100% 0}}
+body.spectrumApp .spectrumPageHeadFrame:before,body.spectrumApp .spectrumPageHeadFrame:after{content:"";position:absolute;inset:-1px;pointer-events:none;border-radius:var(--radius-md);background:conic-gradient(from var(--ring-angle),var(--ring));animation:ringSpin var(--ring-speed) linear infinite}
+body.spectrumApp .spectrumPageHeadFrame:before{z-index:1;padding:1px;-webkit-mask:linear-gradient(var(--black) 0 0) content-box,linear-gradient(var(--black) 0 0);-webkit-mask-composite:xor;mask:linear-gradient(var(--black) 0 0) content-box exclude,linear-gradient(var(--black) 0 0)}
+body.spectrumApp .spectrumPageHeadFrame:after{z-index:-1;opacity:calc(.32*var(--glow));filter:blur(16px)}
+.spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;height:138px;align-items:flex-start;justify-content:space-between;gap:24px;flex-direction:row;margin:0;padding:24px 28px;overflow:hidden;border:1px solid var(--spectrum-border-strong);border-radius:var(--radius-md);background:linear-gradient(116deg,rgb(var(--panel-rgb)/.995),rgb(var(--bg-lift-rgb)/.995) 52%,rgb(var(--bg-lift-rgb)/.99));box-shadow:var(--spectrum-depth-focus)}
+.spectrumPageHead:before{content:none}
+body.spectrumApp .spectrumPageHead:after{content:"";position:absolute;right:0;bottom:0;left:0;height:1px;background:var(--spectrum-foil);background-size:200% 100%;opacity:.9;box-shadow:0 0 14px rgb(var(--signal-hi-rgb)/calc(.5*var(--glow)));animation:foilDrift 9s linear infinite}
+body.spectrumApp .spectrumPageHead h1{background:linear-gradient(100deg,var(--fg) 0%,var(--fg) 30%,var(--signal-hi) 50%,var(--aura) 62%,var(--fg) 80%,var(--fg) 100%);background-size:250% 100%;-webkit-background-clip:text;background-clip:text;color:transparent;filter:drop-shadow(var(--title-glow));animation:titleShimmer 11s ease-in-out infinite alternate}
+.spectrumPageHeadCopy{position:relative;z-index:3;max-width:min(760px,72%);min-width:0}
+.hasPageActions .spectrumPageHeadCopy{max-width:min(560px,48%)}
+.spectrumPageHead h1{max-width:22ch;margin:0;color:var(--fg);font-family:var(--font-display);font-size:var(--fs-hero-fluid);font-stretch:88%;font-weight:var(--fw-semibold);line-height:.98;letter-spacing:-.035em;text-wrap:balance}
+.spectrumPageSubtitle{max-width:52ch;margin:6px 0 0;color:var(--dim);font-size:var(--fs-12);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.spectrumPageActions{position:absolute;z-index:5;right:30px;bottom:24px;display:flex;max-width:62%;align-items:flex-end;justify-content:flex-end}
+.pageSignalField{position:absolute;z-index:1;top:-46%;right:-8%;bottom:-48%;width:76%;overflow:hidden;pointer-events:none;opacity:.88;-webkit-mask-image:linear-gradient(90deg,transparent 0,var(--black) 23%,var(--black) 94%,transparent 100%);mask-image:linear-gradient(90deg,transparent 0,var(--black) 23%,var(--black) 94%,transparent 100%);transition:opacity .35s ease}
+.pageDither,.pageSignalFallback{position:absolute;inset:0}
+.pageDither{z-index:1;transform:scale(1.02)}
+.pageDither canvas{z-index:0!important;opacity:.94;filter:saturate(.92) contrast(1.05)}
+.pageSignalFallback{z-index:0;background:radial-gradient(circle,rgb(var(--fx-front-rgb)/.32) 0 1px,transparent 1.4px) 0 0/7px 7px,linear-gradient(118deg,transparent 16%,rgb(var(--fx-edge-a-rgb)/.14) 56%,rgb(var(--fx-back-rgb)/.16));opacity:.82;transition:opacity .35s ease}
+.pageDither[data-page-effect=ready]+.pageSignalFallback{opacity:.08}
+.pageHeroBorder{position:absolute;z-index:4;inset:0;overflow:hidden;pointer-events:none;border-radius:inherit;opacity:.88}
+.pageHeroBorder canvas{z-index:0!important;opacity:.9}
+.workTags{display:inline-flex;flex-wrap:wrap;gap:6px;min-width:0}
+.workTag{padding:3px 8px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--signal-mid-rgb)/.1);color:var(--dim);font-size:var(--fs-11);white-space:nowrap}
+.workTag.pushback{border-color:rgb(var(--orange-rgb)/.45);color:var(--warn)}
+.workSrOnly{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}
+.workStatus{display:flex;align-items:center;justify-content:space-between;gap:14px;margin-bottom:10px;padding:12px 14px}
+.workStatusMain{display:flex;align-items:center;gap:12px;min-width:0}
+.workStatusText{display:grid;gap:2px;min-width:0}
+.workStatusText strong{font-size:var(--fs-13)}
+.currentSessionHints{display:grid;gap:6px;margin-top:14px}
+.currentSessionHint{display:-webkit-box;min-width:0;overflow:hidden;padding:6px 10px 6px 10px;border-left:2px solid var(--warn);border-radius:0 var(--radius-sm) var(--radius-sm) 0;background:rgb(var(--orange-rgb)/.07);color:var(--dim);font-size:var(--fs-12);line-height:1.45;-webkit-box-orient:vertical;-webkit-line-clamp:2}
+.currentSessionHint b{margin-right:6px;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.currentSessionHint small{font-size:inherit}
+.currentSessionHint[data-kind=premium_routine],.currentSessionHint[data-kind=effort_routine],.currentSessionHint[data-kind=long_thread]{border-left-color:var(--signal);background:rgb(var(--signal-rgb)/.07)}
+.workEnableCta{display:flex;align-items:center;gap:12px;margin:12px 0}
+.workEnableCta[hidden]{display:none}
+.workSetupSteps{display:flex;flex-wrap:wrap;gap:6px 16px;margin:8px 0 0;padding:0;list-style:none;color:var(--faint);font-size:var(--fs-12)}
+.workSetupSteps[hidden]{display:none}
+.workSetupSteps li::before{content:"○";margin-right:6px}
+.workSetupSteps li[data-state=done]{color:var(--dim)}
+.workSetupSteps li[data-state=done]::before{content:"✓";color:var(--good)}
+.workSetupSteps li[data-state=current]{color:var(--fg);font-weight:var(--fw-bold)}
+.workSetupSteps li[data-state=current]::before{content:"●";color:var(--accent)}
+.workSetupSteps li[data-state=failed]{color:var(--warn);font-weight:var(--fw-bold)}
+.workSetupSteps li[data-state=failed]::before{content:"!";color:var(--warn)}
+.workSetupBar{width:min(100%,420px);height:6px;margin-top:8px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.08);overflow:hidden}
+.workSetupBar[hidden]{display:none}
+.workSetupBar i{display:block;height:100%;width:0;border-radius:inherit;background:var(--accent);transition:width .4s}
+.workEnableCta small{color:var(--dim);font-size:var(--fs-12)}
+.workStatusText span{color:var(--dim);font-size:var(--fs-11)}
+.workStatusActions{display:flex;align-items:center;gap:8px;flex:0 0 auto}
+.workStatusActions .filterSelect{min-width:170px}
+.workStatusPill{flex:0 0 auto;padding:4px 10px;border:1px solid var(--line2);border-radius:var(--radius-pill);color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase}
+.workStatusPill::before{content:"";display:inline-block;width:7px;height:7px;margin-right:6px;border-radius:var(--radius-round);background:currentColor;vertical-align:1px}
+.workStatusPill[data-state=running]{color:var(--good);border-color:rgb(var(--green-rgb)/.45)}
+.workStatusPill[data-state=idle]{color:var(--signal-hi);border-color:rgb(var(--signal-rgb)/.4)}
+.workStatusPill:is([data-state=paused],[data-state=throttled],[data-state=backoff]){color:var(--warn);border-color:rgb(var(--orange-rgb)/.45)}
+.workStatusPill:is([data-state=setup_needed],[data-state=storage_error]){color:var(--bad);border-color:rgb(var(--red-rgb)/.45)}
+.workCardHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;margin-bottom:12px}
+.workCardHead h2{margin:0;font-size:var(--fs-14)}
+.workCardHead .filterControl{min-width:160px}
+.workCardHead .filterControl>span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase}
+.workRework,.workSizing{position:relative;padding:16px 16px}
+.workMixSplit{margin-top:16px}
+.workSuggestion{display:grid;gap:2px;text-align:left}
+.workSuggestion b{font-weight:var(--fw-semibold)}
+.workSuggestion small{color:var(--faint);font-size:var(--fs-11);line-height:1.4;white-space:normal}
+.workSizing{margin-top:10px}
+.workSwatch{display:inline-block;flex:0 0 auto;width:10px;height:10px;border-radius:var(--radius-xs);background:var(--swatch)}
+.workTableToggle{margin-top:12px;color:var(--dim);font-size:var(--fs-11)}
+.workTableToggle summary{cursor:pointer}
+.workTableWrap{overflow:auto;max-height:460px}
+.workTableWrap .tbl th{position:sticky;top:0;z-index:1;background:var(--panel);white-space:nowrap}
+.workTableWrap .tbl td{vertical-align:middle}
+.workMuted{color:var(--faint)}
+.workProgressNote{margin:0}
+.workProgressNote strong[hidden]{display:none}
+.workEmpty{padding:18px 4px;color:var(--faint);font-size:var(--fs-12);text-align:center}
+.workSizingGrid{display:grid;grid-template-columns:110px repeat(3,minmax(0,1fr));gap:6px}
+.workSizingHead{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase;align-self:end;padding:0 4px 2px}
+.workSizingCell{min-height:78px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025)}
+.workSizingCell strong{display:block;font-size:var(--fs-16)}
+.workSizingCell span{display:block;color:var(--dim);font-size:var(--fs-11);margin-top:2px}
+.workSizingCell[data-flag]:not([data-flag=""]){border-color:rgb(var(--orange-rgb)/.5);background:rgb(var(--orange-rgb)/.07)}
+.workFlag{display:inline-flex;align-items:center;gap:4px;margin-top:6px;color:var(--warn);font-size:var(--fs-11);font-weight:var(--fw-bold)}
+.workSizingRowHead{display:flex;align-items:center;padding:0 4px;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-bold)}
+@media(max-width:1180px){.workStatus{flex-wrap:wrap}}
+.workSettingsGrid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}
+.workSettingsGrid input,.workAreaRow input{width:100%;min-width:0;padding:8px 10px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.035);color:var(--fg);font:inherit;font-size:var(--fs-12)}
+.workSettingsGrid .settingsField>span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase}
+.workSetupHint{margin-top:10px;color:var(--dim);font-size:var(--fs-11)}
+.workSetupHint code{padding:2px 6px;border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.06);color:var(--fg)}
+.workSettingsActions{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:12px;margin-top:12px}
+.workActionGroup{display:flex;flex-wrap:wrap;align-items:center;gap:8px}
+.workSettingsActions .settingsStatus{width:auto;min-width:0;text-align:right}
+.workSettingsActions .tbtn,.workSettingsManage .tbtn,.workSettingsManage .filterSelect{height:32px;padding-top:0;padding-bottom:0}
+.workSettingsActions .tbtn:disabled{opacity:.45;cursor:not-allowed}
+.workSettingsManage{margin-top:16px;padding-top:12px;border-top:1px solid var(--line)}
+.workAreasHead{display:flex;align-items:baseline;gap:10px;margin-top:16px}
+.workAreasHead h3{margin:0;font-size:var(--fs-13)}
+.workAreas{display:grid;gap:6px;margin-top:8px}
+.workAreaRow{display:grid;grid-template-columns:14px minmax(140px,220px) minmax(0,1fr) auto;align-items:center;gap:8px}
+.workAreaRow .tbtn{padding:6px 8px}
+@media(max-width:1180px){.workSettingsGrid{grid-template-columns:repeat(2,minmax(0,1fr))}}
+.workFit{position:relative;padding:16px 16px;margin-top:10px}
+.workOutcomeBar{display:flex;gap:2px;height:14px;margin-bottom:12px;border-radius:var(--radius-xs);overflow:hidden;background:rgb(var(--tint-rgb)/.03)}
+.workOutcomeBar i{display:block;height:100%;min-width:2px;background:var(--swatch)}
+.workFit .workTableWrap,.workBreakdown .workTableWrap{max-height:none}
+.workFitBest{display:inline-block;margin-left:6px;padding:1px 6px;border:1px solid rgb(var(--green-rgb)/.5);border-radius:var(--radius-pill);color:var(--good);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
+.workFitCell small{display:block;color:var(--faint);font-size:var(--fs-11)}
+[data-drill]{cursor:pointer}
+tr[data-drill]:hover td,td:has(>.workDrillBtn):hover,.workSizingCell:has(>.workDrillBtn):hover{background:rgb(var(--tint-rgb)/.035)}
+.workDrillBtn{display:block;width:100%;height:100%;margin:0;padding:0;border:0;border-radius:var(--radius-xs);background:none;color:inherit;font:inherit;text-align:inherit;cursor:pointer}
+.workDrillBtn:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.workSizingCell:has(>.workDrillBtn){padding:0}
+.workSizingBtn{min-height:78px;padding:10px 10px;border-radius:var(--radius-md)}
+.workSizingBtn:focus-visible{outline-offset:-2px}
+
+.workAxisText{fill:var(--faint);font:var(--fs-11) var(--font-sans)}
+.workTrendWrap{flex:1;display:flex;align-items:center;margin:2px 0 4px}
+.workTrend{display:block;width:100%;height:auto;overflow:visible}
+.workGridLine{stroke:rgb(var(--tint-rgb)/.07)}
+.workLine{fill:none;stroke:var(--signal);stroke-width:2;stroke-linejoin:round;stroke-linecap:round}
+.workPoint{fill:var(--signal);stroke:var(--panel);stroke-width:2}
+.workPoint.few{fill:var(--panel);stroke:var(--signal)}
+.workTrendAvg{stroke:var(--aura);stroke-width:1;stroke-dasharray:4 4;opacity:.8}
+.workTrendAvgText{fill:var(--aura);font:var(--fw-semibold) var(--fs-11) var(--font-sans);paint-order:stroke;stroke:var(--panel);stroke-width:4px;stroke-linejoin:round}
+.workSplit{display:grid;grid-template-columns:minmax(0,1.2fr) minmax(0,1fr);gap:24px;align-items:start}
+.workSplit>div{min-width:0}
+.workSubhead{display:flex;align-items:baseline;justify-content:space-between;gap:10px;margin:0 0 8px}
+.workSubhead h3{margin:0;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.workSubhead span{color:var(--faint);font-size:var(--fs-11)}
+.workScore{width:100%;border-collapse:collapse;font-size:var(--fs-12)}
+.workScore th{padding:0 8px 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase;text-align:right;white-space:nowrap}
+.workScore th:first-child{text-align:left;padding-left:0}
+.workScore td{padding:0;border-top:1px solid var(--line);text-align:right;white-space:nowrap}
+.workScore td:first-child{text-align:left}
+.workScore tr:hover td{background:rgb(var(--tint-rgb)/.03)}
+.workScore .workDrillBtn{display:flex;align-items:center;gap:8px;padding:8px 8px 8px 0}
+.workScore td>span{display:block;padding:8px}
+.workLowest{margin-left:6px;padding:1px 6px;border:1px solid rgb(var(--green-rgb)/.45);border-radius:var(--radius-pill);color:var(--good);font:var(--fw-heavy) var(--fs-11) var(--font-sans);font-style:normal;letter-spacing:.04em;text-transform:uppercase;vertical-align:1px}
+.workScoreDot{flex:0 0 auto;width:8px;height:8px;border-radius:var(--radius-round);background:var(--swatch)}
+.workScoreName{display:grid;min-width:0;text-align:left}
+.workScoreName b{overflow:hidden;text-overflow:ellipsis;font-weight:var(--fw-bold)}
+.workScoreName small{color:var(--faint);font-size:var(--fs-11)}
+.workScoreKinds{display:flex;flex-wrap:wrap;align-items:center;justify-content:flex-end;gap:4px;padding:4px 8px;white-space:normal}
+.workScoreKinds .chip{white-space:nowrap}
+.workScoreKinds small{color:var(--faint);font-size:var(--fs-11)}
+.workMeter{display:inline-grid;grid-template-columns:64px 34px;align-items:center;gap:6px}
+.workMeter i{display:block;height:6px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.06);overflow:hidden}
+.workMeter i b{display:block;height:100%;border-radius:var(--radius-xs);background:var(--meter,var(--signal))}
+.workMeter[data-few=true]{opacity:.5}
+.workMix{display:grid;gap:10px}
+.workMixRow{display:grid;grid-template-columns:96px minmax(0,1fr) 78px;align-items:center;gap:10px}
+.workMixLabel{color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.workMixTotal{text-align:right;font:var(--fw-semibold) var(--fs-12) var(--font-sans);color:var(--fg)}
+.workStack{display:flex;gap:2px;height:22px;border-radius:var(--radius-sm);overflow:hidden;background:rgb(var(--tint-rgb)/.03)}
+.workStack button{position:relative;min-width:3px;height:100%;padding:0;border:0;background:var(--seg);cursor:pointer}
+.workStack button:hover,.workStack button:focus-visible{filter:brightness(1.25);outline:none}
+.workStack button[data-flag=true]{background:repeating-linear-gradient(135deg,var(--seg) 0 6px,rgb(var(--bg-rgb)/.5) 6px 9px);box-shadow:inset 0 0 0 1.5px var(--warn)}
+.workStack button[data-flag=true] span{inset:auto;left:50%;top:50%;padding:1px 6px;border-radius:var(--radius-xs);background:rgb(var(--bg-rgb)/.86);color:var(--fg);transform:translate(-50%,-50%)}
+.workStack button span{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;color:var(--on-accent-deep);font:var(--fw-bold) var(--fs-11) var(--font-sans);pointer-events:none}
+.workMixLegend{display:flex;flex-wrap:wrap;gap:4px 14px;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.workMixLegend span{display:inline-flex;align-items:center;gap:6px}
+.workMixLegend i{display:inline-block;width:10px;height:10px;border-radius:var(--radius-xs);background:var(--swatch)}
+.workMixLegend i.flag{background:repeating-linear-gradient(135deg,var(--w-tier-premium) 0 4px,rgb(var(--bg-rgb)/.55) 4px 6px);box-shadow:inset 0 0 0 1px var(--warn)}
+.workMixLegend small{color:var(--faint);font-size:var(--fs-11);margin-left:2px}
+.workMixLegend i.flag.effort{background:repeating-linear-gradient(135deg,var(--w-tier-premium) 0 4px,rgb(var(--bg-rgb)/.55) 4px 6px)}
+.workSuggestCards{display:grid;grid-template-columns:1.3fr 1fr 1fr;gap:14px;margin:16px 0 12px}
+.workEffortModels{margin:4px 0 14px;padding-top:12px;border-top:1px solid var(--line)}
+.workEffortModels .workSubhead{align-items:center;margin-bottom:10px}
+.workEffortGrid{display:grid;gap:6px;overflow-x:auto}
+.workEffortHead{display:grid;gap:2px}
+.workEffortHead small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium);letter-spacing:0;text-transform:none}
+.workEffortCell{display:flex;align-items:center;justify-content:center;min-width:0;min-height:40px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--red-rgb)/var(--heat,0));font-size:var(--fs-16);font-weight:var(--fw-heavy);font-variant-numeric:tabular-nums}
+.workEffortCell[data-few],.workEffortCell[data-empty]{border-color:transparent;background:rgb(var(--tint-rgb)/.025);color:var(--faint);font-size:var(--fs-12);font-weight:var(--fw-medium)}
+.workEffortVerdicts{display:grid;gap:6px;margin:10px 0 0;padding:0;list-style:none;font-size:var(--fs-12)}
+.workEffortVerdicts li{padding:6px 10px;border-left:2px solid var(--line2);border-radius:0 var(--radius-sm) var(--radius-sm) 0;color:var(--dim)}
+.workEffortVerdicts li b{color:var(--fg)}
+.workEffortVerdicts li[data-kind=lower]{border-left-color:var(--good);background:rgb(var(--green-rgb)/.06)}
+.workEffortVerdicts li[data-kind=raise]{border-left-color:var(--warn);background:rgb(var(--orange-rgb)/.06)}
+.workEffortNote{margin:8px 0 0;color:var(--faint);font-size:var(--fs-11)}
+.workEffortDetail{min-height:18px;margin:8px 0 0;color:var(--dim);font-size:var(--fs-12);font-variant-numeric:tabular-nums}
+.workEffortCell[tabindex]:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.workSuggestCard{display:flex;flex-direction:column;min-width:0;min-height:236px;padding:18px 18px 14px;border:1px solid var(--line);border-radius:var(--radius-lg);background:rgb(var(--tint-rgb)/.022)}
+.workSuggestEyebrow{display:flex;align-items:center;gap:8px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.workSuggestEyebrow i{width:8px;height:8px;border-radius:var(--radius-2xs);display:inline-block}
+.workSuggestHero{margin-top:12px;font:var(--fw-heavy) var(--fs-44)/1 var(--font-sans);letter-spacing:-.02em}
+.workSuggestHero small{display:block;margin-top:6px;color:var(--dim);font-size:var(--fs-13);font-weight:var(--fw-semibold);letter-spacing:0}
+.workSuggestRows{display:flex;flex-direction:column;gap:8px;margin-top:14px}
+.workSuggestRows .workDrillBtn{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:center;gap:10px;padding:8px 10px;border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.03)}
+.workSuggestRows .workDrillBtn:hover,.workSuggestRows .workDrillBtn:focus-visible{background:rgb(var(--signal-rgb)/.08)}
+.workSwap{min-width:0;font-size:var(--fs-13);font-weight:var(--fw-semibold);font-variant-numeric:tabular-nums;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.workSwap b{margin:0 6px;color:var(--faint);font-weight:var(--fw-medium)}
+.workSwap em{display:block;margin-top:2px;color:var(--faint);font:var(--fs-11) var(--font-sans);font-style:normal;overflow:hidden;text-overflow:ellipsis}
+.workSwapSave{color:var(--good);font-size:var(--fs-13);font-weight:var(--fw-bold);font-variant-numeric:tabular-nums}
+.workSuggestFoot{display:flex;justify-content:space-between;gap:10px;margin-top:auto;padding-top:12px;color:var(--faint);font-size:var(--fs-12)}
+.workSuggestFoot button{flex:none;padding:0;border:0;background:none;color:var(--accent);font:inherit;white-space:nowrap;cursor:pointer}
+.workSuggestBar{display:flex;gap:2px;height:10px;margin-top:16px;border-radius:var(--radius-sm);overflow:hidden}
+.workSuggestLegend{display:flex;flex-wrap:wrap;gap:6px 12px;margin-top:8px;color:var(--dim);font-size:var(--fs-11)}
+.workSuggestLegend i{display:inline-block;width:8px;height:8px;margin-right:6px;border-radius:var(--radius-2xs)}
+.workSuggestSpark{display:block;width:100%;height:54px;margin-top:14px}
+.workSuggestChips{display:flex;gap:8px;margin-top:12px}
+.workSuggestChips div{flex:1;min-width:0;padding:8px 10px;border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.03)}
+.workSuggestChips span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.workSuggestChips b{display:block;margin-top:3px;font-size:var(--fs-13);font-weight:var(--fw-semibold);font-variant-numeric:tabular-nums;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.workSuggestChips b s{color:var(--dim);font-weight:var(--fw-medium);text-decoration:none}
+.workSuggestEmpty{margin-top:14px;color:var(--faint);font-size:var(--fs-13)}
+.workIssues{width:100%;border-collapse:collapse;font-size:var(--fs-12)}
+.workIssues th{padding:0 8px 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase;text-align:right}
+.workIssues th:first-child{text-align:left;padding-left:0}
+.workIssues td{border-top:1px solid var(--line);padding:0;text-align:right;white-space:nowrap}
+.workIssues td:first-child{text-align:left}
+.workIssues td>span{display:block;padding:8px}
+.workIssues .workDrillBtn{display:flex;align-items:center;gap:8px;padding:8px 8px 8px 0}
+.workIssues tr:hover td{background:rgb(var(--tint-rgb)/.03)}
+.workIssueKind{color:var(--warn);font-size:var(--fs-11)}
+@media(max-width:1180px){.workSplit{grid-template-columns:1fr}.workSuggestCards{grid-template-columns:1.2fr 1fr 1fr}}
+#view-work .mono,#view-work .num{font-family:inherit;font-variant-numeric:tabular-nums}
+#view-work em.mono{font-style:normal}
+.workTagsCard,.workRhythm,.workBreakdown{padding:16px 16px;margin-top:10px}
+.workTrendPair{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;margin-top:10px;align-items:stretch}
+.workTrendPair>.card{display:flex;flex-direction:column;margin:0}
+.workBreakdownTable small{color:var(--faint);font-size:var(--fs-11)}
+.workCellNote,.workOutcomeCell small{display:block;margin-top:2px}
+.workTableWrap .workBreakdownTable th{white-space:normal;vertical-align:bottom}
+.workBreakdownTable .efficiencySort{text-align:right}
+.workBreakdownTable th:first-child .efficiencySort{text-align:left}
+.workBreakdownTable td.num{white-space:nowrap}
+.workCellBar{display:block;height:4px;margin-top:4px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.05);overflow:hidden}
+.workCellBar i{display:block;height:100%;border-radius:var(--radius-xs);background:linear-gradient(90deg,var(--signal-mid),var(--signal))}
+.workBreakdownTable .workMuted .workCellBar i{background:var(--w-unclear)}
+.workBreakdownTable .workOutcomeBar{height:8px;min-width:80px;margin:0}
+.workBreakdownTotal td{background:rgb(var(--tint-rgb)/.02)}
+
+.workTagGrid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}
+.workTagTile{display:grid;align-content:start;gap:4px;min-width:0;padding:12px 14px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02);color:var(--fg);font:inherit;text-align:left;cursor:pointer}
+.workTagTile:hover,.workTagTile:focus-visible{border-color:var(--tone);background:rgb(var(--tint-rgb)/.045);outline:none}
+.workTagName{display:flex;align-items:center;gap:8px;font-size:var(--fs-13);font-weight:var(--fw-bold)}
+.workTagName i{flex:0 0 auto;width:8px;height:8px;border-radius:var(--radius-round);background:var(--tone)}
+.workTagTile strong{font-size:var(--fs-18);font-weight:var(--fw-bold)}
+.workTagStats{color:var(--dim);font-size:var(--fs-12)}
+.workTagTile small{color:var(--faint);font-size:var(--fs-11);line-height:1.4}
+.workRhythm .workSplit{grid-template-columns:minmax(0,1.6fr) minmax(0,1fr);gap:32px}
+.workHeat{display:grid;grid-template-columns:30px repeat(24,minmax(0,1fr));gap:3px;align-items:center}
+.workHeat>span{color:var(--dim);font-size:var(--fs-11)}
+.workHeat>span.h{grid-column:span 6;color:var(--faint);font-size:var(--fs-11)}
+.workHeat>i{display:block;height:16px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.035)}
+.workHeat>i[data-v]{background:color-mix(in oklab,var(--signal) calc(var(--v) * 100%),rgb(var(--tint-rgb)/.035))}
+.workBandList{display:grid;gap:2px}
+.workBand{display:grid;grid-template-columns:118px minmax(0,1fr) 52px;grid-template-areas:"label bar value" ". note note";align-items:center;column-gap:10px;row-gap:3px;padding:8px 6px}
+.workBand>span:first-child{grid-area:label;font-size:var(--fs-13)}
+.workBand>span small{display:block;color:var(--faint);font-size:var(--fs-11)}
+.workBand .workBarTrack{grid-area:bar;height:10px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.04);overflow:hidden}
+.workBand .workBarTrack i{display:block;height:100%;border-radius:var(--radius-xs);background:var(--signal)}
+.workBand b{grid-area:value;text-align:right;font-size:var(--fs-12)}
+.workBand>small{grid-area:note;color:var(--faint);font-size:var(--fs-11)}
+.workBand[data-few=true] .workBarTrack i{opacity:.45}
+@media(max-width:1180px){.workRhythm .workSplit{grid-template-columns:1fr}}
+.workFootnote{margin-top:10px;color:var(--faint);font-size:var(--fs-11)}
+body.spectrumApp .settingsMap{grid-template-columns:repeat(6,minmax(0,1fr));background:var(--spectrum-card)}
+body.spectrumApp .settingsMap button{grid-template-columns:1fr;border-left:1px solid var(--line);border-radius:0}
+body.spectrumApp :is(.sessionStart,.toast,.capReview,.agentDiscovery,.previewStartStrip,.modelScopeStatus){border-left-width:1px}
+@media(max-width:900px){.spectrumPageHead{height:126px;align-items:flex-start;padding:20px 24px}.spectrumPageHeadCopy,.hasPageActions .spectrumPageHeadCopy{max-width:72%}.spectrumPageActions{position:static;display:flex;width:100%;max-width:none;min-height:46px;align-items:center;justify-content:flex-start;margin-top:8px;padding:6px 8px;border:1px solid var(--spectrum-border);border-radius:var(--radius-md);background:var(--spectrum-control);box-shadow:var(--shadow-soft)}.spectrumPageActions>*{width:100%}.pageSignalField{right:-18%;width:88%}body.spectrumApp .settingsMap{grid-template-columns:repeat(2,minmax(0,1fr))}}
+@media(max-width:520px){.spectrumPageHead{height:116px;padding:18px 18px}.spectrumPageHeadCopy,.hasPageActions .spectrumPageHeadCopy{max-width:62%}.spectrumPageHead h1{font-size:var(--fs-28);line-height:1.02}.spectrumPageSubtitle{max-width:34ch;font-size:var(--fs-11)}.spectrumPageActions{padding:6px}.pageSignalField{top:-36%;right:-43%;bottom:-42%;width:112%;opacity:.78}body.spectrumApp .settingsMap{grid-template-columns:1fr}}
+@media(prefers-reduced-motion:reduce){.pageSignalField{transition:none}body.spectrumApp .tbtn{transition:none}body.spectrumApp:after,body.spectrumApp .top:before,body.spectrumApp .spectrumPageHead:after,body.spectrumApp .top .tab.on:after,.themeOption,body.spectrumApp .spectrumPageHeadFrame:before,body.spectrumApp .spectrumPageHeadFrame:after,body.spectrumApp .spectrumPageHead h1{animation:none;transition:none}}
diff --git a/dashboard/styles/themes.css b/dashboard/styles/themes.css
new file mode 100644
index 00000000..2eb25b61
--- /dev/null
+++ b/dashboard/styles/themes.css
@@ -0,0 +1,789 @@
+/* == Themes: each block declares the same tokens; html[data-theme] selects one == */
+:root,[data-theme=classic]{
+ --signal:#00bceb; --signal-rgb:0 188 235; --signal-mid:#1ba0e1; --signal-mid-rgb:27 160 225;
+ --signal-hi:#7fdbf2; --signal-hi-rgb:127 219 242; --signal-pale:#dff8ff; --signal-pale-rgb:223 248 255; --signal-deep-rgb:14 54 67;
+ --aura:#c7a7ff; --aura-rgb:199 167 255; --aura-pale:#d4c0ff; --aura-deep:#9d72f1; --aura-glow-rgb:183 140 255;
+ --flare:#6d7bff; --flare-rgb:109 123 255;
+ --bg-deep:#05070a; --bg-deep-rgb:5 7 10; --bg:#07090c; --bg-rgb:7 9 12; --bg-lift:#071824; --bg-lift-rgb:7 24 36;
+ --bg2:#0d1117; --bg2-rgb:13 17 23; --panel:#111820; --panel-rgb:17 24 32; --panel2:#17212b; --panel2-rgb:23 33 43; --panel3:#202b36;
+ --line-rgb:177 228 241;
+ --fg:#f6f8fb; --soft:#cbd9e4; --soft-rgb:203 217 228; --dim:#a8b3c1; --faint:#8693a6;
+ --on-accent:#062430; --on-accent-deep:#061018;
+ --reason:#4ec6ee; --output:#7fdbf2; --retrieval:#19b3e6; --toolcall:#0aa4d4;
+ --c-input:#00bceb; --c-output:#64d8ff; --c-cost:#c7a7ff; --c-cost-rgb:199 167 255;
+ --chart-axis:#636d7b; --chart-label:#a8b3c1;
+ --glow:.8;
+ --page-texture:linear-gradient(rgb(var(--tint-rgb)/.03) 1px,transparent 1px),linear-gradient(90deg,rgb(var(--tint-rgb)/.022) 1px,transparent 1px);
+ --page-texture-size:44px 44px;
+ --radius-2xs:2px; --radius-xs:4px; --radius-sm:6px; --radius-md:8px; --radius-lg:12px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
+ --ring-speed:60s;
+ --title-glow:0 0 18px rgb(var(--signal-rgb)/.28);
+ --grain-opacity:.05;
+ --fx-front-rgb:53 202 238; --fx-back-rgb:103 74 180; --fx-edge-a-rgb:0 188 235; --fx-edge-b-rgb:77 139 214;
+}
+[data-theme=nebula]{
+ --signal:#9d8bff; --signal-rgb:157 139 255; --signal-mid:#c77dff; --signal-mid-rgb:199 125 255;
+ --signal-hi:#7ef3ff; --signal-hi-rgb:126 243 255; --signal-pale:#e6e0ff; --signal-pale-rgb:230 224 255; --signal-deep-rgb:38 26 92;
+ --aura:#ff7ad9; --aura-rgb:255 122 217; --aura-pale:#ffc2ee; --aura-deep:#d24fb0; --aura-glow-rgb:214 92 255;
+ --flare:#64ffda; --flare-rgb:100 255 218;
+ --bg-deep:#040310; --bg-deep-rgb:4 3 16; --bg:#07061a; --bg-rgb:7 6 26; --bg-lift:#110c2e; --bg-lift-rgb:17 12 46;
+ --bg2:#0c0a22; --bg2-rgb:12 10 34; --panel:#13102c; --panel-rgb:19 16 44; --panel2:#1b1739; --panel2-rgb:27 23 57; --panel3:#252046;
+ --line-rgb:190 180 255;
+ --fg:#f4f2ff; --soft:#d3cdf2; --soft-rgb:211 205 242; --dim:#afa9d4; --faint:#9089bd;
+ --on-accent:#0d0726; --on-accent-deep:#07031a;
+ --reason:#8fd8ff; --output:#c9bcff; --retrieval:#6fb6ff; --toolcall:#8a7dff;
+ --c-input:#7ef3ff; --c-output:#b6a6ff; --c-cost:#ff8ad8; --c-cost-rgb:255 138 216;
+ --chart-axis:#6c6890; --chart-label:#afa9d4;
+ --glow:1;
+ --page-texture:radial-gradient(circle at 20% 30%,rgb(var(--tint-rgb)/.07) 0 1px,transparent 1.6px),radial-gradient(circle at 70% 80%,rgb(var(--signal-hi-rgb)/.06) 0 1px,transparent 1.6px);
+ --page-texture-size:97px 89px,61px 53px;
+ --radius-2xs:2px; --radius-xs:4px; --radius-sm:6px; --radius-md:10px; --radius-lg:14px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
+ --ring-speed:48s;
+ --title-glow:0 0 22px rgb(var(--signal-mid-rgb)/.42);
+ --grain-opacity:.06;
+ --fx-front-rgb:255 122 217; --fx-back-rgb:157 139 255; --fx-edge-a-rgb:199 125 255; --fx-edge-b-rgb:255 122 217;
+}
+[data-theme=monolith]{
+ --signal:#e4e7ee; --signal-rgb:228 231 238; --signal-mid:#a7aebd; --signal-mid-rgb:167 174 189;
+ --signal-hi:#ffffff; --signal-hi-rgb:255 255 255; --signal-pale:#f4f5f8; --signal-pale-rgb:244 245 248; --signal-deep-rgb:44 46 54;
+ --aura:#a9b8ff; --aura-rgb:169 184 255; --aura-pale:#d3dbff; --aura-deep:#7d8de0; --aura-glow-rgb:150 165 240;
+ --flare:#ff6a3d; --flare-rgb:255 106 61;
+ --bg-deep:#050506; --bg-deep-rgb:5 5 6; --bg:#09090a; --bg-rgb:9 9 10; --bg-lift:#121214; --bg-lift-rgb:18 18 20;
+ --bg2:#0f0f11; --bg2-rgb:15 15 17; --panel:#151517; --panel-rgb:21 21 23; --panel2:#1c1c1f; --panel2-rgb:28 28 31; --panel3:#26262a;
+ --line-rgb:232 234 240;
+ --fg:#f5f5f7; --soft:#d5d6db; --soft-rgb:213 214 219; --dim:#abadb5; --faint:#909299;
+ --on-accent:#0a0a0c; --on-accent-deep:#050506;
+ --reason:#c3cad8; --output:#a9b8ff; --retrieval:#dfe3ec; --toolcall:#8e95a6;
+ --c-input:#e4e7ee; --c-output:#a9b8ff; --c-cost:#c7a7ff; --c-cost-rgb:199 167 255;
+ --chart-axis:#5f6068; --chart-label:#abadb5;
+ --glow:.3;
+ --page-texture:radial-gradient(circle,rgb(var(--tint-rgb)/.055) 0 .8px,transparent 1.2px);
+ --page-texture-size:6px 6px;
+ --radius-2xs:1px; --radius-xs:2px; --radius-sm:3px; --radius-md:4px; --radius-lg:6px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
+ --ring-speed:24s;
+ --title-glow:0 0 0 transparent;
+ --grain-opacity:.07;
+ --fx-front-rgb:244 245 248; --fx-back-rgb:169 184 255; --fx-edge-a-rgb:228 231 238; --fx-edge-b-rgb:167 174 189;
+}
+[data-theme=voltage]{
+ --signal:#f5e63d; --signal-rgb:245 230 61; --signal-mid:#ffd23f; --signal-mid-rgb:255 210 63;
+ --signal-hi:#fff27d; --signal-hi-rgb:255 242 125; --signal-pale:#fffbd6; --signal-pale-rgb:255 251 214; --signal-deep-rgb:64 58 8;
+ --aura:#2ee6ff; --aura-rgb:46 230 255; --aura-pale:#a8f5ff; --aura-deep:#12b5cc; --aura-glow-rgb:46 200 255;
+ --flare:#ff3df2; --flare-rgb:255 61 242;
+ --bg-deep:#050504; --bg-deep-rgb:5 5 4; --bg:#0a0907; --bg-rgb:10 9 7; --bg-lift:#15130b; --bg-lift-rgb:21 19 11;
+ --bg2:#100f0b; --bg2-rgb:16 15 11; --panel:#16150f; --panel-rgb:22 21 15; --panel2:#1e1c14; --panel2-rgb:30 28 20; --panel3:#28261b;
+ --line-rgb:255 244 150;
+ --fg:#f8f6ea; --soft:#ddd9c4; --soft-rgb:221 217 196; --dim:#b6b19a; --faint:#99947d;
+ --on-accent:#141200; --on-accent-deep:#0a0900;
+ --reason:#fff27d; --output:#2ee6ff; --retrieval:#ffe68a; --toolcall:#c8bb2a;
+ --c-input:#f5e63d; --c-output:#2ee6ff; --c-cost:#ff6fd8; --c-cost-rgb:255 111 216;
+ --chart-axis:#6c6956; --chart-label:#b6b19a;
+ --glow:.85;
+ --page-texture:repeating-linear-gradient(0deg,rgb(var(--tint-rgb)/.026) 0 1px,transparent 1px 3px);
+ --page-texture-size:auto;
+ --radius-2xs:0; --radius-xs:1px; --radius-sm:2px; --radius-md:2px; --radius-lg:3px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
+ --ring-speed:18s;
+ --title-glow:0 0 20px rgb(var(--signal-rgb)/.5);
+ --grain-opacity:.05;
+ --fx-front-rgb:245 230 61; --fx-back-rgb:46 230 255; --fx-edge-a-rgb:245 230 61; --fx-edge-b-rgb:46 230 255;
+}
+[data-theme=phosphor]{
+ --signal:#3dfc8f; --signal-rgb:61 252 143; --signal-mid:#19d97a; --signal-mid-rgb:25 217 122;
+ --signal-hi:#b8ffd2; --signal-hi-rgb:184 255 210; --signal-pale:#e3fff0; --signal-pale-rgb:227 255 240; --signal-deep-rgb:6 60 32;
+ --aura:#c6ff4d; --aura-rgb:198 255 77; --aura-pale:#e6ffb0; --aura-deep:#8fd11f; --aura-glow-rgb:120 255 160;
+ --flare:#4dd2ff; --flare-rgb:77 210 255;
+ --bg-deep:#020604; --bg-deep-rgb:2 6 4; --bg:#040a06; --bg-rgb:4 10 6; --bg-lift:#08160e; --bg-lift-rgb:8 22 14;
+ --bg2:#07100a; --bg2-rgb:7 16 10; --panel:#0b170f; --panel-rgb:11 23 15; --panel2:#102016; --panel2-rgb:16 32 22; --panel3:#172b1e;
+ --line-rgb:140 255 190;
+ --fg:#effff4; --soft:#c9e8d4; --soft-rgb:201 232 212; --dim:#a2c4ae; --faint:#86aa93;
+ --on-accent:#021a0c; --on-accent-deep:#010d06;
+ --reason:#b8ffd2; --output:#c6ff4d; --retrieval:#7dffb6; --toolcall:#19d97a;
+ --c-input:#3dfc8f; --c-output:#c6ff4d; --c-cost:#c7a7ff; --c-cost-rgb:199 167 255;
+ --chart-axis:#4f6b59; --chart-label:#a2c4ae;
+ --glow:.9;
+ --page-texture:repeating-linear-gradient(90deg,rgb(var(--signal-rgb)/.026) 0 1px,transparent 1px 14px);
+ --page-texture-size:auto;
+ --radius-2xs:1px; --radius-xs:2px; --radius-sm:4px; --radius-md:4px; --radius-lg:6px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
+ --ring-speed:30s;
+ --title-glow:0 0 22px rgb(var(--signal-rgb)/.45);
+ --grain-opacity:.06;
+ --fx-front-rgb:61 252 143; --fx-back-rgb:25 120 70; --fx-edge-a-rgb:61 252 143; --fx-edge-b-rgb:198 255 77;
+}
+[data-theme=omarchy]{
+ --signal:#7aa2f7; --signal-rgb:122 162 247; --signal-mid:#7dcfff; --signal-mid-rgb:125 207 255;
+ --signal-hi:#bb9af7; --signal-hi-rgb:187 154 247; --signal-pale:#d6dbff; --signal-pale-rgb:214 219 255; --signal-deep-rgb:30 44 92;
+ --aura:#ff9e64; --aura-rgb:255 158 100; --aura-pale:#ffc9a3; --aura-deep:#d96f3f; --aura-glow-rgb:255 158 100;
+ --flare:#f7768e; --flare-rgb:247 118 142;
+ --bg-deep:#0d0e14; --bg-deep-rgb:13 14 20; --bg:#14151d; --bg-rgb:20 21 29; --bg-lift:#1a1b26; --bg-lift-rgb:26 27 38;
+ --bg2:#1a1b26; --bg2-rgb:26 27 38; --panel:#1b1e2b; --panel-rgb:27 30 43; --panel2:#202334; --panel2-rgb:32 35 52; --panel3:#24283b;
+ --line-rgb:187 154 247;
+ --fg:#c0caf5; --soft:#b4bee6; --soft-rgb:180 190 230; --dim:#a9b1d6; --faint:#9099c0;
+ --on-accent:#10121c; --on-accent-deep:#07080f;
+ --reason:#7aa2f7; --output:#7dcfff; --retrieval:#bb9af7; --toolcall:#2ac3de;
+ --c-input:#7aa2f7; --c-output:#7dcfff; --c-cost:#bb9af7; --c-cost-rgb:187 154 247;
+ --chart-axis:#565f89; --chart-label:#a9b1d6;
+ --glow:.9;
+ --page-texture:linear-gradient(rgb(var(--tint-rgb)/.022) 1px,transparent 1px),linear-gradient(90deg,rgb(var(--tint-rgb)/.018) 1px,transparent 1px);
+ --page-texture-size:34px 34px;
+ --radius-2xs:2px; --radius-xs:4px; --radius-sm:8px; --radius-md:10px; --radius-lg:14px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
+ --ring-speed:40s;
+ --title-glow:0 0 20px rgb(var(--signal-rgb)/.4);
+ --grain-opacity:.05;
+ --fx-front-rgb:122 162 247; --fx-back-rgb:187 154 247; --fx-edge-a-rgb:122 162 247; --fx-edge-b-rgb:125 207 255;
+}
+[data-theme=jadehorse]{
+ --signal:#8bcbb1; --signal-rgb:139 203 177; --signal-mid:#86c7c5; --signal-mid-rgb:134 199 197;
+ --signal-hi:#a7dfc5; --signal-hi-rgb:167 223 197; --signal-pale:#dff3ea; --signal-pale-rgb:223 243 234; --signal-deep-rgb:23 52 43;
+ --aura:#96b7d0; --aura-rgb:150 183 208; --aura-pale:#c9dcea; --aura-deep:#6b93b3; --aura-glow-rgb:150 183 208;
+ --flare:#c5cc91; --flare-rgb:197 204 145;
+ --bg-deep:#08120f; --bg-deep-rgb:8 18 15; --bg:#0c1a16; --bg-rgb:12 26 22; --bg-lift:#152e27; --bg-lift-rgb:21 46 39;
+ --bg2:#10211c; --bg2-rgb:16 33 28; --panel:#132720; --panel-rgb:19 39 32; --panel2:#162b24; --panel2-rgb:22 43 36; --panel3:#182f28;
+ --line-rgb:186 214 199;
+ --fg:#dfede5; --soft:#c3d8cc; --soft-rgb:195 216 204; --dim:#a9c3b5; --faint:#93b0a2;
+ --on-accent:#081712; --on-accent-deep:#030b08;
+ --reason:#86c7c5; --output:#a7dfc5; --retrieval:#b7a1c8; --toolcall:#96b7d0;
+ --c-input:#8bcbb1; --c-output:#86c7c5; --c-cost:#b7a1c8; --c-cost-rgb:183 161 200;
+ --chart-axis:#5b7a6c; --chart-label:#a9c3b5;
+ --glow:.85;
+ --page-texture:linear-gradient(rgb(var(--tint-rgb)/.024) 1px,transparent 1px),linear-gradient(90deg,rgb(var(--tint-rgb)/.018) 1px,transparent 1px);
+ --page-texture-size:36px 36px;
+ --radius-2xs:2px; --radius-xs:4px; --radius-sm:8px; --radius-md:10px; --radius-lg:14px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,var(--aura) 75%,var(--signal);
+ --ring-speed:44s;
+ --title-glow:0 0 20px rgb(var(--signal-rgb)/.4);
+ --grain-opacity:.05;
+ --fx-front-rgb:139 203 177; --fx-back-rgb:43 92 76; --fx-edge-a-rgb:139 203 177; --fx-edge-b-rgb:197 204 145;
+}
+[data-theme=ferrous]{
+ --signal:#ff5a36; --signal-rgb:255 90 54; --signal-mid:#e8481f; --signal-mid-rgb:232 72 31;
+ --signal-hi:#ffa27a; --signal-hi-rgb:255 162 122; --signal-pale:#ffe0d2; --signal-pale-rgb:255 224 210; --signal-deep-rgb:74 22 10;
+ --aura:#ffb36b; --aura-rgb:255 179 107; --aura-pale:#ffd9ad; --aura-deep:#d9822b; --aura-glow-rgb:255 150 70;
+ --flare:#5ee6d8; --flare-rgb:94 230 216;
+ --bg-deep:#080403; --bg-deep-rgb:8 4 3; --bg:#0f0705; --bg-rgb:15 7 5; --bg-lift:#2a110a; --bg-lift-rgb:42 17 10;
+ --bg2:#150b08; --bg2-rgb:21 11 8; --panel:#1c100c; --panel-rgb:28 16 12; --panel2:#271713; --panel2-rgb:39 23 19; --panel3:#33201a;
+ --line-rgb:255 150 110;
+ --fg:#fff3ee; --soft:#efd3c6; --soft-rgb:239 211 198; --dim:#c9aa9d; --faint:#ae8f83;
+ --on-accent:#1c0602; --on-accent-deep:#0d0301;
+ --reason:#ffa27a; --output:#ffb36b; --retrieval:#5ee6d8; --toolcall:#e8481f;
+ --c-input:#ff5a36; --c-output:#ffb36b; --c-cost:#5ee6d8; --c-cost-rgb:94 230 216;
+ --chart-axis:#7a5e54; --chart-label:#c9aa9d;
+ --glow:1;
+ --page-texture:repeating-linear-gradient(135deg,rgb(var(--signal-rgb)/.035) 0 1px,transparent 1px 10px);
+ --page-texture-size:auto;
+ --radius-2xs:1px; --radius-xs:2px; --radius-sm:3px; --radius-md:4px; --radius-lg:6px;
+ --ring:var(--signal),rgb(var(--signal-rgb)/.35) 20%,var(--aura) 40%,rgb(var(--signal-rgb)/.35) 60%,var(--flare) 80%,var(--signal);
+ --ring-speed:28s;
+ --title-glow:0 0 22px rgb(var(--signal-rgb)/.5);
+ --grain-opacity:.07;
+ --fx-front-rgb:255 90 54; --fx-back-rgb:150 40 20; --fx-edge-a-rgb:255 90 54; --fx-edge-b-rgb:255 179 107;
+}
+[data-theme=afterglow]{
+ --signal:#ff5fa2; --signal-rgb:255 95 162; --signal-mid:#ff8a5c; --signal-mid-rgb:255 138 92;
+ --signal-hi:#ffc775; --signal-hi-rgb:255 199 117; --signal-pale:#ffe3f0; --signal-pale-rgb:255 227 240; --signal-deep-rgb:72 14 46;
+ --aura:#8f7bff; --aura-rgb:143 123 255; --aura-pale:#c9bfff; --aura-deep:#6a55e0; --aura-glow-rgb:143 110 255;
+ --flare:#3fe3ff; --flare-rgb:63 227 255;
+ --bg-deep:#06020a; --bg-deep-rgb:6 2 10; --bg:#0b0510; --bg-rgb:11 5 16; --bg-lift:#240a26; --bg-lift-rgb:36 10 38;
+ --bg2:#12081a; --bg2-rgb:18 8 26; --panel:#190d22; --panel-rgb:25 13 34; --panel2:#22122e; --panel2-rgb:34 18 46; --panel3:#2e1a3b;
+ --line-rgb:255 160 210;
+ --fg:#fff1f8; --soft:#efd0e2; --soft-rgb:239 208 226; --dim:#cbabc2; --faint:#b08fa8;
+ --on-accent:#240418; --on-accent-deep:#12020c;
+ --reason:#ffc775; --output:#ff8a5c; --retrieval:#c9bfff; --toolcall:#ff5fa2;
+ --c-input:#ff5fa2; --c-output:#ffc775; --c-cost:#8f7bff; --c-cost-rgb:143 123 255;
+ --chart-axis:#7a5f78; --chart-label:#cbabc2;
+ --glow:1;
+ --page-texture:linear-gradient(rgb(var(--signal-rgb)/.045) 1px,transparent 1px);
+ --page-texture-size:100% 28px;
+ --radius-2xs:3px; --radius-xs:6px; --radius-sm:8px; --radius-md:12px; --radius-lg:18px;
+ --ring:var(--signal),var(--signal-mid) 25%,var(--signal-hi) 45%,var(--aura) 70%,var(--flare) 85%,var(--signal);
+ --ring-speed:32s;
+ --title-glow:0 0 22px rgb(var(--signal-rgb)/.45);
+ --grain-opacity:.05;
+ --fx-front-rgb:255 95 162; --fx-back-rgb:143 123 255; --fx-edge-a-rgb:255 95 162; --fx-edge-b-rgb:255 199 117;
+}
+*{box-sizing:border-box}
+html,body{margin:0}
+body{min-height:100vh;background:
+ linear-gradient(180deg,var(--bg-deep) 0%,var(--bg2) 42%,var(--bg) 100%);
+ color:var(--fg);font:var(--fs-14)/1.5 var(--font-sans);-webkit-font-smoothing:antialiased}
+body:before{content:"";position:fixed;inset:0;z-index:-1;pointer-events:none;background-image:var(--page-texture);background-size:var(--page-texture-size);mask-image:linear-gradient(180deg,rgb(var(--shade-rgb)/.9),rgb(var(--shade-rgb)/.28) 52%,transparent)}
+html{scrollbar-color:rgb(var(--signal-rgb)/.32) transparent}
+::selection{background:rgb(var(--signal-rgb)/.34);color:var(--fg)}
+::view-transition-old(root),::view-transition-new(root){animation-duration:.42s;animation-timing-function:var(--spectrum-ease)}
+.mono{font-family:var(--font-mono);font-variant-numeric:tabular-nums}
+.wrap{max-width:1320px;margin:0 auto;padding:18px 24px 64px}
+.top{position:sticky;top:0;z-index:20;display:flex;align-items:center;gap:14px;margin:0 0 18px;padding:10px 0 12px;background:linear-gradient(180deg,rgb(var(--bg-rgb)/.98),rgb(var(--bg-rgb)/.82));backdrop-filter:blur(18px);border-bottom:1px solid var(--line)}
+.brand{display:flex;align-items:center;gap:8px;font-weight:var(--fw-heavy);font-size:var(--fs-14);white-space:nowrap}
+.logo{width:50px;height:30px;display:flex;flex:0 0 auto;align-items:center;justify-content:flex-start}
+.logo img{display:block;width:50px;height:auto;max-height:30px;object-fit:contain}
+.tabs,.seg{display:flex;gap:3px;background:rgb(var(--tint-rgb)/.045);border:1px solid var(--line);border-radius:var(--radius-md);padding:3px;box-shadow:var(--inset)}
+.tab,.seg button{border:0;background:transparent;color:var(--dim);border-radius:var(--radius-sm);padding:6px 12px;font:inherit;font-size:var(--fs-13);font-weight:var(--fw-bold);text-decoration:none;cursor:pointer;transition:background .16s,border-color .16s,color .16s,transform .16s}
+.tab:hover,.seg button:hover{background:rgb(var(--tint-rgb)/.045);color:var(--fg)}
+.tab.on,.seg button.on{background:linear-gradient(180deg,rgb(var(--tint-rgb)/.11),rgb(var(--tint-rgb)/.055));color:var(--fg);box-shadow:0 1px 2px rgb(var(--shade-rgb)/.22),var(--inset)}
+.top .tabs{min-width:0;overflow-x:auto;scrollbar-width:none}
+.top .tabs::-webkit-scrollbar{display:none}
+.spacer{flex:1}
+.notify,.pill{display:inline-flex;align-items:center;gap:6px;border:1px solid var(--line);background:rgb(var(--panel-rgb)/.86);border-radius:var(--radius-pill);padding:6px 10px;font-size:var(--fs-12);color:var(--dim);white-space:nowrap;box-shadow:var(--inset)}
+.notify{cursor:pointer;user-select:none}
+.sw{width:32px;height:18px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.13);position:relative;box-shadow:inset 0 0 0 1px rgb(var(--tint-rgb)/.08)}
+.sw:after{content:"";position:absolute;top:2px;left:2px;width:14px;height:14px;border-radius:var(--radius-round);background:var(--white);transition:left .16s;box-shadow:0 2px 6px rgb(var(--shade-rgb)/.32)}
+.notify.on .sw{background:var(--good)}
+.notify.on .sw:after{left:16px}
+.notify.hasnew{border-color:rgb(var(--signal-rgb)/.52);box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.12),var(--inset)}
+.view{display:none}
+.view.on{display:block}
+.session-panel{display:none}
+.session-panel.on{display:block}
+.card{background:linear-gradient(180deg,rgb(var(--panel-rgb)/.95),rgb(var(--bg2-rgb)/.96));border:1px solid var(--line);border-radius:var(--radius-md);box-shadow:var(--shadow);position:relative;min-width:0}
+.card:hover{border-color:rgb(var(--tint-rgb)/.12)}
+.pad{padding:18px}
+.label{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.section-h{display:flex;align-items:center;gap:10px;margin:24px 0 10px}
+.section-h h2{font-size:var(--fs-14);margin:0;font-weight:var(--fw-heavy)}
+.section-h .hint{font-size:var(--fs-12);color:var(--faint)}
+.sessionhead{display:flex;align-items:center;gap:8px;margin-bottom:10px;min-width:0}
+.sessionStart{display:grid;grid-template-columns:max-content minmax(0,1fr);gap:8px;align-items:baseline;margin-bottom:12px;padding:8px 10px;border:1px solid var(--line);border-left:3px solid var(--accent);border-radius:var(--radius-md);background:rgb(var(--signal-rgb)/.055);min-width:0}
+.sessionStart[hidden]{display:none}
+.sessionStart span{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;white-space:nowrap}
+.sessionStart strong{font-size:var(--fs-13);font-weight:var(--fw-semibold);line-height:1.4;overflow-wrap:anywhere}
+.repo,.sessid{border:1px solid var(--line);background:rgb(var(--panel-rgb)/.76);border-radius:var(--radius-md);padding:6px 10px;font-size:var(--fs-12);min-width:0;box-shadow:var(--inset)}
+.repo{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.sessid{color:var(--dim);max-width:360px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.sessionDesktopLink{display:inline-flex;align-items:center;justify-content:center;text-decoration:none;white-space:nowrap}
+.sessionDesktopLink[hidden]{display:none}
+.currentSessionSlot{position:relative;display:flex;min-width:0}
+.currentSessionSlot>.currentSessionCard{flex:1 1 auto}
+.currentSessionSlot[data-desktop] .currentSessionTop{padding-right:36px}
+.currentSessionDesktop{position:absolute;top:14px;right:14px;z-index:2;display:inline-flex;align-items:center;justify-content:center;width:26px;height:26px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.62);color:var(--dim);transition:color .16s,border-color .16s,background .16s}
+.currentSessionDesktop:hover{color:var(--fg);border-color:var(--line3);background:rgb(var(--tint-rgb)/.07)}
+.currentSessionDesktop:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.currentSessionDesktop svg{width:13px;height:13px;fill:none;stroke:currentColor;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round}
+.sessionDelete{border:1px solid rgb(var(--red-rgb)/.36);background:rgb(var(--red-rgb)/.07);border-radius:var(--radius-md);color:var(--bad-text);font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);padding:6px 10px;cursor:pointer;box-shadow:var(--inset);white-space:nowrap}
+.sessionDelete:hover:not(:disabled){border-color:rgb(var(--red-rgb)/.68);background:rgb(var(--red-rgb)/.13);color:var(--bad-text-strong)}
+.sessionDelete:disabled{opacity:.42;cursor:not-allowed}
+.sessionDelete[hidden]{display:none}
+.sessionDeleteIcon{display:inline-grid;place-items:center;width:28px;height:28px;padding:0}
+.sessionDeleteIcon svg{width:15px;height:15px;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
+.smetrics .sessionDelete{font-size:var(--fs-11);padding:4px 6px;margin-top:4px}
+.sessionModelAssign{border:1px solid rgb(var(--signal-rgb)/.42);background:rgb(var(--signal-rgb)/.08);border-radius:var(--radius-md);color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);padding:4px 6px;cursor:pointer;box-shadow:var(--inset);white-space:nowrap;margin-top:4px}
+.sessionModelAssign:hover:not(:disabled){border-color:rgb(var(--signal-rgb)/.7);background:rgb(var(--signal-rgb)/.15);color:var(--fg)}
+.sessionModelAssign:disabled{opacity:.42;cursor:not-allowed}
+.previewRunMeta>.sessionModelAssign{font-size:var(--fs-12);padding:6px 10px;margin-top:0}
+.hero{display:grid;grid-template-columns:minmax(410px,.86fr) minmax(620px,1.14fr);gap:12px;align-items:start}
+.costcard{overflow:hidden;align-self:start;min-height:238px;padding:16px;display:flex;flex-direction:column;justify-content:flex-start;background:
+ linear-gradient(180deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98)),
+ linear-gradient(90deg,rgb(var(--signal-rgb)/.16),rgb(var(--signal-mid-rgb)/.06));}
+.costcard:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--signal),var(--signal-mid),rgb(var(--signal-hi-rgb)/.72),transparent)}
+.costcard:after{content:"";position:absolute;inset:auto 18px 18px auto;width:32%;height:1px;background:linear-gradient(90deg,transparent,rgb(var(--tint-rgb)/.24));opacity:.55}
+.meter{font-size:var(--fs-56);font-weight:var(--fw-heavy);line-height:1.02;margin-top:8px;background:linear-gradient(90deg,var(--white),var(--signal-hi) 70%,var(--signal-pale));-webkit-background-clip:text;background-clip:text;color:transparent}
+.costcard .meter{font-size:var(--fs-56);margin-top:4px}
+.costcard .subline{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.costtip{display:none;position:absolute;z-index:8;right:14px;top:78px;width:min(390px,calc(100% - 28px));border:1px solid rgb(var(--signal-rgb)/.48);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--bg-deep-rgb)/.98),rgb(var(--panel-rgb)/.98));box-shadow:0 18px 44px rgb(var(--shade-rgb)/.48);padding:10px 10px;color:var(--dim);font-size:var(--fs-12);line-height:1.35}
+.costcard:hover .costtip,.costcard:focus-within .costtip{display:block}
+.costtip .h{font-weight:var(--fw-heavy);color:var(--fg);margin-bottom:6px}
+.costtip .r{display:grid;grid-template-columns:90px minmax(0,1fr) auto;gap:8px;align-items:baseline;padding:3px 0;border-top:1px solid rgb(var(--tint-rgb)/.06)}
+.costtip .r:first-of-type{border-top:0}
+.costtip .name{color:var(--fg);font-weight:var(--fw-bold)}
+.costtip .formula{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.costtip .amt{color:var(--fg);font-weight:var(--fw-heavy)}
+.costtip .total{margin-top:6px;padding-top:6px;border-top:1px solid var(--line2);display:flex;justify-content:space-between;gap:10px;color:var(--fg);font-weight:var(--fw-heavy)}
+.costtip .note{margin-top:4px;color:var(--faint);font-size:var(--fs-11)}
+.costmeta{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;margin-top:14px}
+.costmeta>div{border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.035);padding:8px 10px;box-shadow:var(--inset);min-width:0}
+.costmeta .v{font-size:var(--fs-13);font-weight:var(--fw-heavy);margin-top:3px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.costmeta .sm{font-size:var(--fs-12);color:var(--faint)}
+.costsplit{margin-top:14px;padding-top:12px;border-top:1px solid var(--line);min-width:0}
+.costsplit .splithead{display:flex;align-items:baseline;gap:8px;margin-bottom:8px}
+.costsplit .splithead .hint{font-size:var(--fs-12);color:var(--faint)}
+.costsplit .bar{height:26px}
+.costsplit .legend{gap:10px;margin-top:8px}
+.meter.alert{background:none;color:var(--bad)}
+.subline{margin-top:10px;color:var(--dim);font-size:var(--fs-13)}
+.subline b{color:var(--fg)}
+.frozen{display:none;margin-top:10px;font-size:var(--fs-12);color:var(--warn);font-weight:var(--fw-bold)}
+.frozen.on{display:block}
+.statgrid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}
+.hero>.statgrid{grid-template-columns:repeat(2,minmax(0,1fr))}
+.usageDetails{margin-top:12px;border:1px solid var(--line2);border-radius:var(--radius-lg);background:rgb(var(--tint-rgb)/.018);box-shadow:var(--shadow-soft);overflow:hidden}
+.usageDetails>summary{display:flex;align-items:baseline;gap:10px;padding:12px 14px;cursor:pointer;font-weight:var(--fw-heavy);list-style-position:inside}
+.usageDetails>summary:hover{background:rgb(var(--tint-rgb)/.025)}
+.usageDetailsBody{padding:0 14px 16px;border-top:1px solid var(--line)}
+.usageSplit{margin-top:14px}
+.usageSplit .splithead{display:flex;align-items:baseline;gap:8px;margin-bottom:8px}
+.usageSplit .bar{height:26px}
+.usageSplit .legend{gap:10px;margin-top:8px}
+.usageDetailGrid{margin-top:10px}
+.stat{background:linear-gradient(180deg,rgb(var(--tint-rgb)/.055),rgb(var(--tint-rgb)/.025));border:1px solid var(--line);border-radius:var(--radius-md);padding:12px 14px;box-shadow:var(--shadow-soft);min-width:0}
+.stat .v{font-size:var(--fs-24);font-weight:var(--fw-heavy);margin-top:4px;overflow:hidden;text-overflow:ellipsis}
+.stat .sm{font-size:var(--fs-12);color:var(--faint)}
+.overview{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px;position:relative;z-index:2}
+.ov{padding:14px 14px;overflow:visible;min-height:92px;min-width:0}
+.ov:hover,.ov:focus-within{z-index:24}
+.ov:before{content:"";position:absolute;left:14px;right:14px;top:0;height:2px;background:linear-gradient(90deg,var(--signal),transparent);opacity:.78}
+.ov .v{font-size:var(--fs-22);font-weight:var(--fw-heavy);margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.ov.time .v{font-size:var(--fs-13);line-height:1.35;letter-spacing:0;white-space:normal}
+.ov .sm{font-size:var(--fs-12);color:var(--dim);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.banner{display:none;background:linear-gradient(180deg,rgb(var(--bad-deep-rgb)/.72),rgb(var(--bad-ink-rgb)/.86));border:1px solid rgb(var(--red-rgb)/.38);color:var(--bad-text-strong);padding:10px 14px;border-radius:var(--radius-md);margin:0 0 14px;font-size:var(--fs-13);font-weight:var(--fw-bold);box-shadow:var(--shadow-soft);align-items:center;gap:12px;flex-wrap:wrap}
+.banner.on{display:flex}
+.banner .msg{flex:1 1 280px;min-width:0}
+.budgetadd{display:none;align-items:center;gap:8px;flex-wrap:wrap;color:var(--dim);font-weight:var(--fw-semibold)}
+.banner.budget .budgetadd{display:inline-flex}
+.budgetadd label{display:flex;align-items:center;gap:6px}
+.budgetadd input{width:78px;background:rgb(var(--tint-rgb)/.07);border:1px solid rgb(var(--tint-rgb)/.2);color:var(--fg);border-radius:var(--radius-md);padding:6px 8px;font:inherit}
+.budgetadd input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.bar{display:flex;height:32px;border-radius:var(--radius-md);overflow:hidden;background:rgb(var(--tint-rgb)/.04);border:1px solid var(--line);box-shadow:inset 0 1px 10px rgb(var(--shade-rgb)/.22)}
+.bar span{display:flex;align-items:center;justify-content:center;font-size:var(--fs-11);color:var(--white);font-weight:var(--fw-heavy);min-width:0;transition:width .35s ease;white-space:nowrap}
+#sembar span{color:var(--bg)}
+.legend{display:flex;gap:14px;margin-top:10px;flex-wrap:wrap;font-size:var(--fs-12);color:var(--dim)}
+.dot{width:9px;height:9px;border-radius:var(--radius-xs);display:inline-block;margin-right:6px;vertical-align:middle}
+.fieldtip{position:relative;display:inline-flex;align-items:center;cursor:help;outline:none}
+.currentSessionCard.fieldtip{display:grid}
+.fieldtip:focus-visible{color:var(--fg)}
+#fieldtip-popup{position:fixed;left:0;top:0;z-index:1000;box-sizing:border-box;width:min(320px,calc(100vw - 24px));pointer-events:none;border:1px solid rgb(var(--signal-rgb)/.42);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--bg-deep-rgb)/.98),rgb(var(--panel-rgb)/.98));box-shadow:0 14px 32px rgb(var(--shade-rgb)/.46);padding:8px 10px;color:var(--dim);font-size:var(--fs-12);line-height:1.35;font-weight:var(--fw-medium);overflow-wrap:anywhere}
+#fieldtip-popup[hidden]{display:none}
+@keyframes enter{from{opacity:.3;transform:translateY(3px)}to{opacity:1;transform:none}}
+.chartbar{display:flex;align-items:center;gap:12px;margin-bottom:10px;flex-wrap:wrap}
+.chartbar .label{margin-right:auto}
+.chartbar .seg{flex-wrap:wrap}
+.chartwrap{position:relative}
+.chart{height:252px;width:100%;display:block;background:rgb(var(--tint-rgb)/.025);border:1px solid var(--line);border-radius:var(--radius-md)}
+.chart text{user-select:none}
+.charttip{z-index:4;display:none;min-width:238px;overflow:hidden;font:var(--fs-12)/1.35 var(--font-mono)}
+.charttip .h{padding:6px 10px;background:rgb(var(--signal-rgb)/.16);font-weight:var(--fw-heavy);color:var(--fg)}
+.charttip .r{display:flex;justify-content:space-between;gap:16px;padding:3px 10px}
+.charttip .prompt{display:block;padding:6px 10px;border-top:1px solid rgb(var(--tint-rgb)/.08);max-width:360px}
+.charttip .prompt span{display:block;color:var(--chart-label);margin-bottom:2px}
+.charttip .prompt b{display:block;color:var(--fg);font-weight:var(--fw-semibold);white-space:normal}
+.charttip .in,.charttip .fresh{color:var(--c-input)}
+.charttip .out{color:var(--c-output)}
+.charttip .cacheRead{color:var(--c-cache-read)}
+.charttip .cacheWrite{color:var(--c-cache-write)}
+.charttip .cost{color:var(--c-cost)}
+.charttip .context{color:var(--c-context)}
+.charttip .tools{color:var(--toolcall)}
+.mini{height:8px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.045);overflow:hidden;margin:10px 0 4px;border:1px solid var(--line)}
+.mini>i{display:block;height:100%;border-radius:var(--radius-xs);transition:width .35s ease}
+.tbl{width:100%;border-collapse:collapse;font-size:var(--fs-13)}
+.tbl th{text-align:left;color:var(--faint);font-weight:var(--fw-heavy);font-size:var(--fs-11);text-transform:uppercase;padding:8px;border-bottom:1px solid var(--line);background:rgb(var(--tint-rgb)/.02)}
+.tbl td{padding:8px 8px;border-bottom:1px solid rgb(var(--tint-rgb)/.055);vertical-align:top}
+.tbl tr:hover td{background:rgb(var(--tint-rgb)/.025)}
+.tbl tr:last-child td{border-bottom:0}
+.tbl .num{text-align:right;color:var(--dim)}
+.tbl .nm{font-weight:var(--fw-bold)}
+.chips{display:flex;gap:6px;flex-wrap:wrap}
+.chip{font-size:var(--fs-11);border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);border-radius:var(--radius-pill);padding:3px 6px;color:var(--dim);box-shadow:var(--inset)}
+.chip.tone-warn{border-color:rgb(var(--orange-rgb)/.4);background:rgb(var(--orange-rgb)/.08);color:var(--warn)}
+.chip.mcp{color:var(--aura-pale);border-color:rgb(var(--aura-glow-rgb)/.42);background:rgb(var(--aura-glow-rgb)/.12)}
+.tbtn{border:1px solid var(--line2);background:linear-gradient(180deg,rgb(var(--signal-rgb)/.18),rgb(var(--signal-rgb)/.08));color:var(--fg);border-radius:var(--radius-md);padding:6px 10px;font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);cursor:pointer}
+.tbtn:hover{border-color:rgb(var(--signal-rgb)/.56);background:linear-gradient(180deg,rgb(var(--signal-rgb)/.24),rgb(var(--signal-rgb)/.1))}
+#e-builder-recap{display:inline-flex;align-items:center;text-decoration:none}
+.sessionEfficiency{display:grid;grid-template-columns:minmax(112px,.55fr) repeat(2,minmax(0,1fr));align-items:stretch;margin-top:12px;padding:10px 14px;box-shadow:var(--shadow-soft)}
+.sessionEfficiencyIntro{display:flex;flex-direction:column;justify-content:center;padding-right:14px}
+.sessionEfficiencyIntro .sm{margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.sessionEfficiencyMetric{min-width:0;padding:2px 16px;border-left:1px solid var(--line)}
+.sessionEfficiencyMetric strong{margin-top:2px;font-size:var(--fs-22);line-height:1.15;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.sessionEfficiencyMetric span{display:block;color:var(--dim);margin-top:2px;font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.sessionEfficiencyMetric .label{letter-spacing:0}
+.previewStatus .previewRunEfficiencySlot{margin-top:14px;padding-top:10px;border-top:1px solid rgb(var(--signal-rgb)/.14)}
+.previewStatus .previewRunEfficiencySlot .sessionEfficiency{grid-template-columns:repeat(2,minmax(0,1fr));margin:0;padding:0;border:0;border-radius:0;background:transparent;box-shadow:none}
+.previewStatus .previewRunEfficiencySlot .sessionEfficiencyIntro{grid-column:1/-1;flex-direction:row;align-items:baseline;justify-content:space-between;padding:0 0 8px}
+.previewStatus .previewRunEfficiencySlot .sessionEfficiencyIntro .sm{display:none}
+.previewStatus .previewRunEfficiencySlot .sessionEfficiencyMetric{padding:0 10px 0 0;border-left:0}
+.previewStatus .previewRunEfficiencySlot .sessionEfficiencyMetric+.sessionEfficiencyMetric{padding:0 0 0 10px;border-left:1px solid var(--line)}
+.previewStatus .previewRunEfficiencySlot .sessionEfficiencyMetric strong{font-size:var(--fs-18)}
+.sessionBudget{margin-top:12px;padding:12px 14px;display:grid;gap:8px;overflow:visible}
+.sessionBudgetHead,.sessionBudgetMeta{display:flex;align-items:center;justify-content:space-between;gap:14px}
+.sessionBudgetHead>div:first-child{min-width:0}
+.sessionBudgetExact{display:flex;align-items:center;gap:6px;color:var(--dim);font-size:var(--fs-12);white-space:nowrap}
+.sessionBudgetExact input{width:86px;background:rgb(var(--tint-rgb)/.05);border:1px solid var(--line2);border-radius:var(--radius-md);color:var(--fg);padding:6px 8px;font:var(--fw-bold) var(--fs-13) var(--font-mono)}
+.sessionBudgetExact input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.sessionBudgetTrack{display:grid;grid-template-columns:52px minmax(120px,1fr) 60px;align-items:center;gap:10px}
+.sessionBudgetTrack>span{font-size:var(--fs-11);color:var(--faint)}
+.sessionBudgetTrack>span:last-child{text-align:right}
+.sessionBudgetTrack input[type=range]{--budget-fill:0%;appearance:none;-webkit-appearance:none;width:100%;height:22px;margin:0;background:transparent;cursor:pointer}
+.sessionBudgetTrack input[type=range]::-webkit-slider-runnable-track{height:7px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:linear-gradient(90deg,var(--accent) 0 var(--budget-fill),rgb(var(--tint-rgb)/.075) var(--budget-fill) 100%);box-shadow:var(--inset)}
+.sessionBudgetTrack input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;margin-top:-6px;border:2px solid var(--signal-pale);border-radius:var(--radius-round);background:var(--accent);box-shadow:0 0 0 4px rgb(var(--signal-rgb)/.15),0 3px 10px rgb(var(--shade-rgb)/.45)}
+.sessionBudgetTrack input[type=range]:focus-visible{outline:none}
+.sessionBudgetTrack input[type=range]:focus-visible::-webkit-slider-thumb{box-shadow:0 0 0 5px rgb(var(--signal-rgb)/.28),0 3px 10px rgb(var(--shade-rgb)/.45)}
+.sessionBudgetTrack input[type=range]::-moz-range-track{height:7px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.075)}
+.sessionBudgetTrack input[type=range]::-moz-range-progress{height:7px;border-radius:var(--radius-pill);background:var(--accent)}
+.sessionBudgetTrack input[type=range]::-moz-range-thumb{width:16px;height:16px;border:2px solid var(--signal-pale);border-radius:var(--radius-round);background:var(--accent);box-shadow:0 0 0 4px rgb(var(--signal-rgb)/.15)}
+.sessionBudgetMeta{font-size:var(--fs-12);color:var(--faint)}
+.sessionBudgetMeta span:first-child{color:var(--dim);font-weight:var(--fw-semibold)}
+.toastbox{position:fixed;right:18px;bottom:18px;z-index:80;display:flex;flex-direction:column;gap:8px;width:min(360px,calc(100vw - 28px));pointer-events:none;transition:bottom .18s ease}
+.updateReady .toastbox{bottom:70px}
+.toast{pointer-events:auto;border:1px solid rgb(var(--signal-rgb)/.38);border-left:4px solid var(--signal);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98));box-shadow:0 16px 42px rgb(var(--shade-rgb)/.42);padding:10px 12px;animation:enter .18s ease}
+.toast.warn{border-left-color:var(--warn);border-color:rgb(var(--orange-rgb)/.42)}
+.toast.bad{border-left-color:var(--bad);border-color:rgb(var(--red-rgb)/.42)}
+.toast .th{display:flex;align-items:flex-start;justify-content:space-between;gap:10px;font-size:var(--fs-13);font-weight:var(--fw-heavy)}
+.toast .tb{font-size:var(--fs-12);color:var(--dim);margin-top:2px}
+.toast button{border:0;background:transparent;color:var(--faint);font:inherit;font-size:var(--fs-16);line-height:1;cursor:pointer;padding:0}
+.toast button:hover{color:var(--fg)}
+.updateNotice{position:fixed;right:18px;bottom:18px;z-index:79;border:1px solid rgb(var(--signal-rgb)/.58);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--signal-deep-rgb)/.98),rgb(var(--bg2-rgb)/.98));color:var(--fg);box-shadow:0 16px 42px rgb(var(--shade-rgb)/.48),0 0 26px rgb(var(--signal-rgb)/.12);padding:8px 12px;font:var(--fw-bold) var(--fs-12)/1.2 var(--font-sans);cursor:pointer;animation:enter .18s ease}
+.updateNotice:hover{border-color:var(--accent);background:linear-gradient(180deg,rgb(var(--signal-rgb)/.2),transparent),linear-gradient(180deg,rgb(var(--signal-deep-rgb)/.98),rgb(var(--bg2-rgb)/.98))}
+.updateNotice:disabled{cursor:wait;color:var(--dim);opacity:.84}
+.updateNotice[hidden]{display:none}
+.foot{margin-top:16px;font-size:var(--fs-11);color:var(--faint);text-align:center}
+.spark{display:flex;align-items:flex-end;gap:4px;height:84px;margin-top:8px;padding:0 2px}
+.spark .b{flex:1;background:linear-gradient(180deg,var(--signal),rgb(var(--signal-rgb)/.55));border-radius:var(--radius-xs) var(--radius-xs) 0 0;min-height:3px;position:relative;box-shadow:0 -8px 18px rgb(var(--signal-rgb)/.08)}
+.spark .b.anom{background:linear-gradient(180deg,var(--bad),rgb(var(--red-rgb)/.58))}
+.spark .b:hover:after{content:attr(data-l);position:absolute;bottom:100%;left:50%;transform:translateX(-50%);background:var(--panel);color:var(--fg);border:1px solid var(--line2);font-size:var(--fs-11);padding:3px 6px;border-radius:var(--radius-xs);white-space:nowrap;margin-bottom:4px;z-index:5;box-shadow:var(--shadow-soft)}
+.reco{display:inline-flex;border:1px solid var(--line);border-radius:var(--radius-pill);padding:3px 6px;font-size:var(--fs-11);color:var(--dim);white-space:nowrap}
+.reco.disable,.reco.fix_or_disable{color:var(--warn);border-color:rgb(var(--orange-rgb)/.36);background:rgb(var(--orange-rgb)/.08)}
+.reco.narrow_results,.reco.reduce_repeats{color:var(--signal-hi);border-color:rgb(var(--signal-rgb)/.3);background:rgb(var(--signal-rgb)/.08)}
+.mcpDialog{width:min(560px,calc(100vw - 28px));border:1px solid var(--line2);border-radius:var(--radius-lg);background:linear-gradient(180deg,var(--panel2),var(--bg2));color:var(--fg);padding:0;box-shadow:0 30px 90px rgb(var(--shade-rgb)/.7)}
+.mcpDialog::backdrop{background:rgb(var(--shade-rgb)/.68);backdrop-filter:blur(4px)}
+.mcpDialog .inner{padding:20px}
+.mcpDialog h3{margin:0 0 8px;font-size:var(--fs-20)}
+.mcpDialog .evidence{display:grid;gap:6px;margin:14px 0;padding:12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.03);color:var(--dim);font-size:var(--fs-12)}
+.mcpDialog code{display:block;margin:12px 0;padding:10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:var(--bg);color:var(--signal-hi);overflow:auto}
+.mcpDialog .actions{display:flex;justify-content:flex-end;gap:8px;margin-top:16px}
+.mcpDialog .danger{border-color:rgb(var(--orange-rgb)/.45);background:rgb(var(--orange-rgb)/.12);color:var(--warn)}
+.commandPalette{width:min(660px,calc(100vw - 28px));max-height:min(680px,calc(100vh - 40px));border:1px solid rgb(var(--signal-hi-rgb)/.34);border-radius:var(--radius-lg);background:radial-gradient(ellipse 70% 40% at 12% 0,rgb(var(--signal-rgb)/calc(.16*var(--glow))),transparent 70%),linear-gradient(180deg,rgb(var(--panel2-rgb)/.9),rgb(var(--bg2-rgb)/.94));color:var(--fg);padding:0;overflow:hidden;box-shadow:0 34px 100px rgb(var(--shade-rgb)/.76),0 0 70px rgb(var(--signal-rgb)/calc(.16*var(--glow)));backdrop-filter:blur(24px) saturate(1.3)}
+.commandPalette::backdrop{background:rgb(var(--shade-rgb)/.7);backdrop-filter:blur(6px)}
+.commandShell{display:flex;max-height:min(680px,calc(100vh - 40px));flex-direction:column}
+.commandSearch{display:grid;grid-template-columns:20px minmax(0,1fr) auto;align-items:center;gap:10px;padding:14px 16px;border-bottom:1px solid var(--line2);background:rgb(var(--tint-rgb)/.025)}
+.commandSearch svg{width:19px;height:19px;stroke:var(--faint)}
+.commandSearch input{min-width:0;border:0;outline:0;background:transparent;color:var(--fg);font:var(--fw-semibold) var(--fs-16)/1.4 var(--font-sans)}
+.commandSearch input::placeholder{color:var(--faint)}
+.commandSearch kbd,.commandFooter kbd{border:1px solid var(--line2);border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.05);color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.35 var(--font-mono);box-shadow:0 1px 0 rgb(var(--tint-rgb)/.07)}
+.commandSearch kbd{padding:2px 6px}
+.commandList{min-height:100px;overflow:auto;padding:8px;scrollbar-color:var(--line2) transparent}
+.commandGroup{padding:8px 10px 4px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.06em}
+.commandItem{width:100%;display:grid;grid-template-columns:30px minmax(0,1fr) auto;align-items:center;gap:10px;border:1px solid transparent;border-radius:var(--radius-md);background:transparent;color:var(--fg);padding:8px 10px;text-align:left;font:inherit;cursor:pointer}
+.commandItem:hover,.commandItem.selected{border-color:rgb(var(--signal-rgb)/.3);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.16),rgb(var(--aura-rgb)/.04));box-shadow:inset 2px 0 0 var(--signal-hi)}
+.commandGlyph{width:28px;height:28px;display:grid;place-items:center;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.04);color:var(--signal-hi);font:var(--fw-heavy) var(--fs-11) var(--font-mono)}
+.commandCopy{min-width:0}
+.commandLabel,.commandDescription{display:block}
+.commandLabel{font-size:var(--fs-13);font-weight:var(--fw-heavy);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.commandDescription{font-size:var(--fs-12);color:var(--faint);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.commandEmpty{min-height:120px}
+.commandFooter{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:8px 14px;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11)}
+.commandFooter span{display:flex;align-items:center;gap:4px}
+.commandFooter kbd{padding:1px 4px;color:var(--fg)}
+.globalControls{display:grid;grid-template-columns:minmax(220px,1fr) minmax(190px,.78fr) minmax(150px,.52fr) auto auto;gap:10px;align-items:end;margin:12px 0}
+.filterControl{display:grid;gap:4px;min-width:0}
+.filterControl>span{font-size:var(--fs-11);line-height:1;text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
+.searchbox,.filterSelect{width:100%;min-width:0;height:38px;border:1px solid var(--line2);background:var(--panel);color:var(--fg);border-radius:var(--radius-md);padding:8px 10px;font:inherit;font-size:var(--fs-13);font-weight:var(--fw-bold);box-shadow:var(--inset);color-scheme:dark}
+.searchbox{background:rgb(var(--tint-rgb)/.045);font-weight:inherit}
+.filterSelect{appearance:auto;padding-right:28px}
+select{color-scheme:dark;font-weight:var(--fw-bold)}
+select option{color:var(--fg);background-color:var(--panel2)}
+select option:checked{background-color:var(--panel3)}
+.searchbox:focus,.filterSelect:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.filterSort .seg{min-height:38px;align-items:center}
+.filterClear{display:grid;gap:4px;justify-items:stretch;min-width:148px}
+.clearFilters{height:38px;background:rgb(var(--tint-rgb)/.045);color:var(--dim)}
+.clearFilters:hover:not(:disabled){color:var(--fg)}
+.clearFilters:disabled{opacity:.42;cursor:not-allowed}
+.filterCount{text-align:right}
+.globalMeta{font-size:var(--fs-12);color:var(--faint);white-space:nowrap}
+.logsSummary{display:grid;grid-template-columns:minmax(380px,.78fr) minmax(440px,1.22fr);gap:10px;margin:0 0 12px;align-items:stretch}
+.logKpis{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}
+.logStat{padding:12px 14px;min-height:82px;overflow:hidden}
+.logStat .v{font-size:var(--fs-24);line-height:1.1;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.logStat .subline{font-size:var(--fs-11);margin-top:4px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.logModelCount{font-size:var(--fs-11);color:var(--faint);white-space:nowrap}
+.logModelList{display:grid;margin-top:6px}
+.logModelRow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:14px;align-items:center;padding:6px 0;border-top:1px solid var(--line);min-width:0}
+.logModelRow:first-child{border-top:0}
+.logModelName{font-size:var(--fs-13);font-weight:var(--fw-heavy);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.logModelMeta{font-size:var(--fs-11);color:var(--faint);margin-top:1px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.logModelValue{text-align:right}
+.logModelValue b{display:block;font-size:var(--fs-13)}
+.logModelValue span{display:block;font-size:var(--fs-11);color:var(--faint);margin-top:1px}
+.logModelEmpty{font-size:var(--fs-12);color:var(--faint);padding:16px 0 6px}
+.logsSummary{display:grid;grid-template-columns:minmax(380px,.78fr) minmax(440px,1.22fr);gap:10px;margin:0 0 12px;align-items:stretch}
+.logKpis{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}
+.logStat{padding:12px 14px;min-height:82px;overflow:hidden}
+.logStat.waitStat{grid-column:1/-1;min-height:72px}
+.logStat .v{font-size:var(--fs-24);line-height:1.1;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.logStat .subline{font-size:var(--fs-11);margin-top:4px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.logModelCount{font-size:var(--fs-11);color:var(--faint);white-space:nowrap}
+.logModelList{display:grid;margin-top:6px}
+.logModelRow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:14px;align-items:center;padding:6px 0;border-top:1px solid var(--line);min-width:0}
+.logModelRow:first-child{border-top:0}
+.logModelName{font-size:var(--fs-13);font-weight:var(--fw-heavy);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.logModelMeta{font-size:var(--fs-11);color:var(--faint);margin-top:1px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.logModelValue{text-align:right}
+.logModelValue b{display:block;font-size:var(--fs-13)}
+.logModelValue span{display:block;font-size:var(--fs-11);color:var(--faint);margin-top:1px}
+.logModelEmpty{font-size:var(--fs-12);color:var(--faint);padding:16px 0 6px}
+.outputPair{display:flex;align-items:flex-end;justify-content:space-between;gap:10px;min-width:0}
+.outputPair .v{min-width:0}
+.outputRate{display:grid;justify-items:end;line-height:1;padding-bottom:2px;white-space:nowrap}
+.outputRate strong{font-size:var(--fs-16);color:var(--signal-hi);font-weight:var(--fw-heavy)}
+.outputRate span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-bold);text-transform:uppercase;margin-top:3px}
+.modelHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:14px}
+.modelHead h1,.modelHead h2{font-size:var(--fs-24);line-height:1.2;margin:0}
+.modelHead p{color:var(--dim);margin:4px 0 0;font-size:var(--fs-13);max-width:760px}
+.modelControls{display:grid;grid-template-columns:minmax(220px,290px) minmax(150px,190px);gap:8px;align-items:end}
+.modelPicker{position:relative;min-width:0}
+.modelPicker>summary{list-style:none;display:flex;align-items:center;justify-content:space-between;gap:10px;width:100%;min-width:0;height:38px;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-md);padding:8px 10px;font-size:var(--fs-13);box-shadow:var(--inset);cursor:pointer}
+.modelPicker>summary::-webkit-details-marker{display:none}
+.modelPicker>summary:after{content:"\25be";color:var(--faint);font-size:var(--fs-11);flex:0 0 auto}
+.modelPicker>summary span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.modelPicker[open]>summary,.modelPicker>summary:focus-visible{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
+.modelPickerMenu{position:absolute;right:0;top:calc(100% + 6px);z-index:60;width:max(100%,290px);max-height:min(360px,55vh);overflow:auto;border:1px solid var(--line2);border-radius:var(--radius-md);background:linear-gradient(180deg,var(--panel2),var(--bg2));box-shadow:0 18px 46px rgb(var(--shade-rgb)/.58);padding:6px}
+.modelOption{display:grid;grid-template-columns:18px minmax(0,1fr);align-items:center;gap:8px;padding:8px 8px;border-radius:var(--radius-sm);color:var(--dim);font-size:var(--fs-13);cursor:pointer}
+.modelOption:hover{background:rgb(var(--tint-rgb)/.055);color:var(--fg)}
+.modelOption input{width:15px;height:15px;margin:0;accent-color:var(--accent)}
+.modelOption span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.modelOption.all{border-bottom:1px solid var(--line);border-radius:var(--radius-sm) var(--radius-sm) 0 0;margin-bottom:4px;padding-bottom:10px;font-weight:var(--fw-heavy);color:var(--fg)}
+.modelHero{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:10px}
+.modelKpi{padding:14px;min-height:110px;overflow:visible}
+.modelKpi .v{font-size:var(--fs-28);line-height:1.08;margin-top:6px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.modelKpi .subline{font-size:var(--fs-12);margin-top:4px}
+.modelDelta{display:inline-flex;align-items:center;gap:6px;color:var(--dim)}
+.modelDelta:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:var(--faint)}
+.modelDelta.up{color:var(--good)}
+.modelDelta.up:before{background:var(--good)}
+.modelDelta.down{color:var(--warn)}
+.modelDelta.down:before{background:var(--warn)}
+.modelCoverage{height:7px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045);overflow:hidden;margin-top:8px}
+.modelCoverage i{display:block;height:100%;width:0;background:linear-gradient(90deg,var(--accent),var(--signal-hi));border-radius:var(--radius-pill)}
+.modelTrendCard{margin-top:12px;padding:16px 16px}
+.modelTrendHead{display:flex;justify-content:space-between;align-items:flex-start;gap:14px}
+.modelTrendHead h2{font-size:var(--fs-14);margin:0}
+.modelTrendHead p{font-size:var(--fs-12);color:var(--faint);margin:2px 0 0}
+.modelTrendControls{display:flex;gap:12px;align-items:center;justify-content:flex-end;flex-wrap:wrap}
+.modelSwatch{display:inline-block;width:9px;height:9px;border-radius:var(--radius-xs);margin-right:4px;flex:0 0 auto}
+.modelChartWrap{position:relative;margin-top:10px}
+.modelChart{display:block;width:100%;height:270px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.022)}
+.modelChartTip{z-index:5;display:none;min-width:300px;max-width:min(440px,calc(100% - 16px));max-height:260px;overflow:auto;font:var(--fs-12)/1.35 var(--font-mono)}
+.modelChartTip .h{padding:6px 10px;background:rgb(var(--signal-rgb)/.14);font-weight:var(--fw-heavy);color:var(--fg)}
+.modelChartTip .r{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:18px;padding:4px 10px}
+.modelChartTip .r span{display:flex;align-items:center;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.modelChartTip .r b{color:var(--fg);white-space:nowrap}
+.modelChartTip .cols{color:var(--faint);font-size:var(--fs-11);border-bottom:1px solid var(--line);text-transform:uppercase}
+.modelTipSeries{padding:6px 10px;border-top:1px solid var(--line)}
+.modelTipSeries:first-of-type{border-top:0}
+.modelTipName{display:flex;align-items:center;min-width:0;color:var(--fg);font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.modelTipMetrics{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:8px;margin-top:4px}
+.modelTipMetrics span{display:grid;gap:1px;min-width:0}
+.modelTipMetrics small{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
+.modelTipMetrics b{color:var(--fg);font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.modelTableWrap{margin-top:12px;overflow:auto;max-height:620px}
+.modelTableWrap .tbl th{position:sticky;top:0;z-index:2;background:var(--panel);white-space:nowrap}
+.modelTableWrap .tbl th .fieldtip:after{bottom:auto;top:calc(100% + 7px);left:auto;right:0;z-index:4}
+.modelTableWrap .tbl td{vertical-align:middle}
+.modelNameLine{display:flex;align-items:center;min-width:0}
+.modelName{font-weight:var(--fw-heavy);max-width:260px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.modelRuntime{font-size:var(--fs-11);color:var(--faint);margin-top:2px}
+.modelEmpty{padding:36px 16px}
+.efficiencyHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px}
+.efficiencyRange{display:grid;gap:6px;min-width:260px}
+.efficiencyRange>span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase}
+.efficiencyHero{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}
+.efficiencyHeadline{position:relative;min-height:184px;padding:14px 16px 12px;overflow:hidden}
+.efficiencyHeadline:after{content:"";position:absolute;right:-54px;bottom:-88px;width:210px;height:210px;border-radius:var(--radius-round);background:radial-gradient(circle,rgb(var(--signal-rgb)/.15),transparent 68%);pointer-events:none}
+.efficiencyEyebrow{color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
+.efficiencyValueRow,.efficiencySupportValueRow{min-width:0}
+.efficiencyValueRow{margin-top:6px}
+.efficiencyHeadline .v{min-width:0;font-size:var(--fs-36);font-weight:var(--fw-heavy);line-height:1.02;letter-spacing:-.04em}
+.efficiencyCoverage{position:relative;z-index:1;margin-top:4px;color:var(--faint);font-size:var(--fs-11)}
+.efficiencyChartWrap{position:relative;z-index:2;margin-top:8px}
+.efficiencyChart{display:block;width:100%;height:64px;margin:0;color:var(--signal-hi);overflow:visible;cursor:crosshair}
+.efficiencyChartGrid{stroke:rgb(var(--tint-rgb)/.07);stroke-width:1}
+.efficiencyChartLine{fill:none;stroke:currentColor;stroke-width:2.25;stroke-linecap:round;stroke-linejoin:round}
+.efficiencyChartArea{fill:currentColor;opacity:.08}
+.efficiencyChartDot,.efficiencyChartInspectDot{fill:var(--panel);stroke:currentColor;stroke-width:2}
+.efficiencyChartInspect{pointer-events:none}
+.efficiencyChartInspectLine{stroke:currentColor;stroke-width:1;stroke-dasharray:3 3;opacity:.48}
+.efficiencyChartLabel{fill:var(--faint);font:var(--fs-11) var(--font-mono)}
+.efficiencyChartEmpty{fill:var(--faint);font:var(--fs-11) var(--font-sans)}
+.efficiencyChartTip{z-index:4;top:3px;transform:translateX(-50%);padding:4px 8px;color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono);white-space:nowrap}
+.efficiencyChartTip[hidden]{display:none}
+.efficiencySupport{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;margin-top:10px}
+.efficiencySupportItem{min-height:184px;padding:14px 16px 12px;overflow:hidden}
+.efficiencySupportValueRow{margin-top:6px}
+.efficiencySupportValueRow .v{margin-top:0}
+.efficiencySupportItem .v{font-size:var(--fs-28);font-weight:var(--fw-heavy);line-height:1.1;margin-top:6px}
+.efficiencySupportItem .subline{font-size:var(--fs-11);line-height:1.35;margin-top:4px}
+.efficiencySupportItem .efficiencyChart{height:64px}
+.efficiencyModelCard{margin-top:12px;padding:0;overflow:hidden}
+.efficiencyModelHead{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:14px 16px 10px;border-bottom:1px solid var(--line)}
+.efficiencyModelHead h2{font-size:var(--fs-14);margin:0}
+.efficiencyModelMeta{font-size:var(--fs-11);color:var(--faint);white-space:nowrap}
+.efficiencyTableWrap{overflow:auto;max-height:580px}
+.efficiencyTableWrap .tbl th{position:sticky;top:0;z-index:2;background:var(--panel);white-space:nowrap}
+.efficiencyTableWrap .tbl td{vertical-align:middle}
+.efficiencySort{display:inline-flex;align-items:center;justify-content:flex-end;gap:4px;width:100%;padding:0;border:0;background:none;color:inherit;font:inherit;font-weight:inherit;text-transform:inherit;letter-spacing:inherit;cursor:pointer}
+.efficiencyTableWrap .tbl th:first-child .efficiencySort,.workBreakdownTable th:first-child .efficiencySort,.workScore th:first-child .efficiencySort{justify-content:flex-start}
+.efficiencySort:hover,.efficiencySort:focus-visible{color:var(--fg)}
+.efficiencySort:focus-visible{outline:1px solid var(--signal);outline-offset:3px;border-radius:var(--radius-2xs)}
+.efficiencySortMark{width:9px;color:var(--signal-hi);font-size:var(--fs-11);text-align:center}
+.efficiencyMetric strong{display:block;color:var(--fg);font-size:var(--fs-13)}
+.efficiencyMetric span{display:block;color:var(--faint);font-size:var(--fs-11);margin-top:2px}
+.efficiencyEvidence{padding:8px 16px;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11);line-height:1.35}
+.efficiencyTableWrap .tbl th,.efficiencyTableWrap .tbl td{padding-left:6px;padding-right:6px}
+.efficiencyChart{border-radius:var(--radius-xs)}
+.efficiencyChart:focus-visible{outline:1px solid currentColor;outline-offset:3px}
+.efficiencyChartStatus{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
+.capHero{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}
+.currentCapHero{grid-template-columns:repeat(3,minmax(0,1fr));margin-top:10px}
+.capHero .pad{padding:12px 14px;overflow:visible}
+.capHero .card:hover,.capHero .card:focus-within{z-index:50}
+.capHero .fieldtip:after{bottom:auto;top:calc(100% + 8px);z-index:40}
+.capHero .card:last-child .fieldtip:after{left:auto;right:0}
+.capHero .meter{font-size:var(--fs-28);margin-top:4px}
+.capHero .subline{font-size:var(--fs-12);margin-top:4px}
+.capStatBar{height:8px;margin-top:8px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.055);overflow:hidden;box-shadow:inset 0 1px 3px rgb(var(--shade-rgb)/.42)}
+.capStatBar i{display:block;width:0;height:100%;border-radius:var(--radius-pill);transition:width .35s ease;background:linear-gradient(90deg,var(--good),var(--accent));box-shadow:0 0 14px rgb(var(--green-rgb)/.3)}
+.capStatBar.mcp i{background:linear-gradient(90deg,var(--aura-deep),var(--aura));box-shadow:0 0 14px rgb(var(--aura-glow-rgb)/.3)}
+.capStatBar.skill i{background:linear-gradient(90deg,var(--accent),var(--signal-hi));box-shadow:0 0 14px rgb(var(--signal-rgb)/.3)}
+.capStatBar.warn i{background:linear-gradient(90deg,var(--warn),var(--signal));box-shadow:0 0 14px rgb(var(--orange-rgb)/.3)}
+.defBar{height:12px;margin-top:10px;background:rgb(var(--tint-rgb)/.05);border:1px solid var(--line);border-radius:var(--radius-pill);overflow:hidden;display:flex}
+.defBar i{display:block;height:100%}
+.defBar .used{background:var(--good)}
+.defBar .unused{background:var(--warn)}
+.defBar .deferred{background:rgb(var(--signal-hi-rgb)/.42)}
+.capFilters{display:grid;grid-template-columns:minmax(220px,1fr) auto auto;gap:10px;align-items:center;margin:10px 0}
+.capTableWrap{overflow:auto;max-height:620px}
+.capTableWrap .tbl th{position:sticky;top:0;z-index:2;background:var(--panel)}
+.capTableWrap .tbl th.sortable{cursor:pointer;user-select:none;white-space:nowrap}
+.capTableWrap .tbl th.sortable:after{content:"\2195";display:inline-block;margin-left:6px;color:var(--faint);font-size:var(--fs-11)}
+.capTableWrap .tbl th.sortable.sort-asc:after{content:"\2191";color:var(--accent)}
+.capTableWrap .tbl th.sortable.sort-desc:after{content:"\2193";color:var(--accent)}
+.capTableWrap .tbl th.sortable:focus-visible{outline:1px solid var(--accent);outline-offset:-2px}
+.stateDot{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
+.stateDot:before{content:"";width:8px;height:8px;border-radius:var(--radius-round);background:var(--faint)}
+.stateDot.on:before{background:var(--good)}
+.stateDot.off:before{background:var(--bad)}
+.stateDot.lazy:before{background:var(--signal-hi)}
+.stateDot.prompt:before{background:var(--accent)}
+.capAction{border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:4px 8px;font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer;white-space:nowrap}
+.capAction:hover{border-color:var(--accent)}
+.capAction.disable{color:var(--warn);border-color:rgb(var(--orange-rgb)/.4);background:rgb(var(--orange-rgb)/.08)}
+.capAction:disabled{opacity:.45;cursor:not-allowed}
+.capPath{max-width:330px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--faint);font-size:var(--fs-11)}
+.tbtn.danger{border-color:rgb(var(--orange-rgb)/.45);background:rgb(var(--orange-rgb)/.12);color:var(--warn)}
+.tbtn.danger:hover{background:rgb(var(--orange-rgb)/.19)}
+.dailyHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:16px}
+.dailyHead h1,.learnHead h1{font-size:var(--fs-24);line-height:1.2;margin:0}
+.dailyHead p,.learnHead p{color:var(--dim);margin:4px 0 0;font-size:var(--fs-13)}
+.iconBtn:hover:not(:disabled){border-color:var(--accent);background:rgb(var(--signal-rgb)/.09)}
+.learnHead{max-width:760px;margin-bottom:20px}
+.bulkControls{max-height:220px;white-space:pre-wrap}
+.agentDiscovery{display:flex;align-items:center;gap:14px;margin-bottom:12px;padding:12px 14px;border:1px solid rgb(var(--signal-rgb)/.32);border-left:3px solid var(--accent);border-radius:var(--radius-md);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.11),rgb(var(--panel-rgb)/.88) 58%,rgb(var(--panel-rgb)/.94));box-shadow:var(--shadow-soft)}
+.agentDiscovery[hidden]{display:none}
+.agentDiscoveryMain{flex:1;min-width:0}
+.agentDiscoveryTitle{font-weight:var(--fw-heavy)}
+.agentDiscoveryText{color:var(--dim);font-size:var(--fs-13);margin-top:2px}
+.agentDiscoveryClose{border:0;background:transparent;color:var(--faint);font:var(--fw-bold) var(--fs-18)/1 var(--font-sans);cursor:pointer;padding:6px}
+.agentDiscoveryClose:hover{color:var(--fg)}
+.settingsPageHead{margin-bottom:14px}
+.settingsPageHead p{max-width:680px}
+.agentAccess{overflow:hidden}
+.agentAccessHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}
+.agentAccessHead h1,.agentAccessHead h2{font-size:var(--fs-22);line-height:1.15;margin:4px 0 0}
+.agentAccessHead p{color:var(--dim);font-size:var(--fs-13);margin:4px 0 0;max-width:650px}
+.agentAccessBadge{padding:4px 8px;white-space:nowrap}
+.agentAccessHead .tbtn{text-decoration:none}
+.agentClients{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;margin-top:16px}
+.agentClient{display:grid;gap:10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.035);padding:10px 10px}
+.agentClientPart{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:12px;align-items:center}
+.agentClientSkills{border-top:1px solid var(--line);padding-top:10px}
+.agentClientActions{display:flex;gap:8px}
+.agentClientName{display:flex;align-items:center;gap:6px;font-weight:var(--fw-heavy)}
+.agentClientState{font-size:var(--fs-12);color:var(--faint);margin-top:2px}
+.agentClientState.connected{color:var(--good)}
+.agentClientState.warn{color:var(--warn)}
+.agentCommand{white-space:pre-wrap;overflow-wrap:anywhere}
+.compareToggle{width:22px;height:22px;display:grid;place-items:center;padding:0;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);color:transparent;cursor:pointer;transition:border-color .16s,background .16s,color .16s}
+.compareToggle svg{width:14px;height:14px;fill:none;stroke:currentColor;stroke-width:2.2;stroke-linecap:round;stroke-linejoin:round}
+.compareToggle:hover{border-color:rgb(var(--signal-rgb)/.6);color:var(--faint)}
+.compareToggle:focus-visible{outline:0;box-shadow:0 0 0 3px rgb(var(--signal-rgb)/.22);border-color:rgb(var(--signal-rgb)/.7)}
+.compareToggle[aria-pressed=true]{background:var(--compare-color,var(--accent));border-color:var(--compare-color,var(--accent));color:var(--bg-deep)}
+.compareToggle[aria-disabled=true]{opacity:.35;cursor:not-allowed}
+.srow.compareSelected{border-color:color-mix(in srgb,var(--compare-color,var(--accent)) 55%,transparent)}
+.compareTabCount{margin-left:6px;min-width:18px;height:18px;padding:0 4px;border-radius:var(--radius-pill);background:var(--accent);color:var(--bg-deep);font-size:var(--fs-11);font-weight:var(--fw-heavy);line-height:18px;text-align:center}
+.compareTabCount[hidden]{display:none}
+.tab[aria-selected=true] .compareTabCount{background:var(--on-accent);color:var(--signal-hi)}
+.compareTray{position:sticky;bottom:14px;z-index:6;display:flex;align-items:center;justify-content:space-between;gap:14px;margin-top:12px;padding:10px 12px;border:1px solid rgb(var(--signal-rgb)/.42);border-radius:var(--radius-lg);background:linear-gradient(180deg,rgb(var(--panel-rgb)/.97),rgb(var(--bg2-rgb)/.97));box-shadow:0 14px 40px rgb(var(--shade-rgb)/.45);backdrop-filter:blur(14px)}
+.compareTray[hidden]{display:none}
+.compareTrayItems{display:flex;gap:6px;flex-wrap:wrap;min-width:0}
+.compareTrayActions{display:flex;align-items:center;gap:8px;flex:0 0 auto}
+.compareTrayNote{color:var(--faint);font-size:var(--fs-12);max-width:280px}
+.compareChip{display:inline-flex;align-items:center;gap:6px;max-width:240px;padding:3px 4px 3px 3px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.04);font-size:var(--fs-12);color:var(--dim)}
+.compareChip span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.compareChip button{border:0;background:transparent;color:var(--faint);font:inherit;font-size:var(--fs-14);line-height:1;padding:0 3px;cursor:pointer;border-radius:var(--radius-xs)}
+.compareChip button:hover{color:var(--fg)}
+.compareLetter{flex:0 0 auto;display:inline-grid;place-items:center;width:20px;height:20px;border-radius:var(--radius-xs);background:var(--compare-color,var(--accent));color:var(--bg-deep);font-size:var(--fs-11);font-weight:var(--fw-heavy)}
+.compareHeadActions{display:flex;gap:8px;align-items:center}
+.tbtn.compareClear{background:rgb(var(--tint-rgb)/.04)}
+#compare-body{display:grid;gap:14px}
+.compareEmpty{padding:28px 24px}
+.compareEmpty h3{margin:0 0 6px;font-size:var(--fs-16);color:var(--fg)}
+.compareEmpty p{margin:0 auto 14px;max-width:560px;font-size:var(--fs-13);line-height:1.55}
+.compareNote{padding:8px 12px;border:1px solid rgb(var(--orange-rgb)/.35);border-radius:var(--radius-md);background:rgb(var(--orange-rgb)/.08);color:var(--warn);font-size:var(--fs-12)}
+.compareCards{display:grid;gap:10px}
+.compareCard{padding:12px 12px;border-top:3px solid var(--compare-color);display:flex;flex-direction:column;gap:4px;min-width:0}
+.compareCardTop{display:flex;align-items:center;gap:6px;min-width:0}
+.compareBaselineTag{margin-left:auto;font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.05em;color:var(--compare-color)}
+.compareCardTitle{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.compareCardMeta{font-size:var(--fs-12);color:var(--faint);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.compareCardCost{font-size:var(--fs-22);font-weight:var(--fw-heavy);margin-top:2px}
+.compareCardActions{display:flex;gap:6px;flex-wrap:wrap;margin-top:4px}
+.compareCardActions button{border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.04);color:var(--dim);border-radius:var(--radius-sm);padding:4px 8px;font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);cursor:pointer}
+.compareCardActions button:hover:not(:disabled){color:var(--fg);border-color:rgb(var(--signal-rgb)/.5)}
+.compareCardActions button:disabled{opacity:.45;cursor:default}
+.compareSection{padding:14px 16px}
+.compareSection h3{margin:0 0 10px;font-size:var(--fs-14)}
+.compareSectionHead{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:10px}
+.compareSectionHead h3{margin:0}
+.compareWinners{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}
+.compareWinners strong{display:flex;align-items:center;gap:8px}
+.compareWinners small{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.compareTableWrap{overflow-x:auto}
+.compareTable{width:100%;border-collapse:collapse;font-size:var(--fs-13)}
+.compareTable th,.compareTable td{padding:6px 10px;text-align:right;border-bottom:1px solid var(--line);white-space:nowrap}
+.compareTable th:first-child,.compareTable td:first-child{text-align:left;color:var(--dim);font-weight:var(--fw-semibold)}
+.compareTable thead th{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
+.compareTable thead th .compareLetter{margin-right:6px;vertical-align:middle}
+.compareTable tr.compareGroup th{padding-top:14px;text-align:left;color:var(--signal-hi);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.06em;border-bottom-color:var(--line2)}
+.compareTable td.text{max-width:150px;overflow:hidden;text-overflow:ellipsis}
+.compareTable th,.compareTable td{padding-left:8px;padding-right:8px}
+.compareTable tr.differs td:first-child:after{content:"differs";margin-left:8px;font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;color:var(--warn)}
+.compareDelta{display:block;font-size:var(--fs-11);font-weight:var(--fw-bold);color:var(--faint)}
+.compareDelta.better{color:var(--good)}
+.compareDelta.worse{color:var(--bad)}
+.compareBest{margin-left:6px;padding:1px 4px;border-radius:var(--radius-xs);background:rgb(var(--green-rgb)/.14);color:var(--good);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;vertical-align:1px}
+.compareUnavailable{color:var(--faint)}
+.compareCaption{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
+.compareChart{width:100%;height:auto;display:block}
+.compareLegend{display:flex;gap:14px;flex-wrap:wrap;margin-top:8px;font-size:var(--fs-12);color:var(--dim)}
+.compareLegend span{display:inline-flex;align-items:center;gap:6px}
+.compareLegend i{width:12px;height:3px;border-radius:var(--radius-2xs);background:var(--compare-color)}
+.compareLegend i.part{width:10px;height:10px;border-radius:var(--radius-xs)}
+.compareBreakdown{display:grid;gap:8px}
+.compareBreakdownRow{display:grid;grid-template-columns:28px minmax(0,1fr) 84px;gap:10px;align-items:center}
+.compareBreakdownBar{display:flex;height:16px;border-radius:var(--radius-xs);overflow:hidden;background:rgb(var(--tint-rgb)/.04)}
+.compareBreakdownBar i{display:block;height:100%}
+.compareBreakdownRow b{text-align:right;font-size:var(--fs-13)}
+.compareMatches{display:grid;gap:6px}
+.compareMatch{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:12px;align-items:center;padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025)}
+.compareMatch .t{font-weight:var(--fw-semibold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.compareMatch .meta{font-size:var(--fs-12);color:var(--faint)}
+.compareMatchActions{display:flex;gap:6px}
+.slist{display:flex;flex-direction:column;gap:8px}
+.srow{display:grid;grid-template-columns:26px 132px minmax(0,1fr) auto auto 28px;gap:12px;align-items:center;background:linear-gradient(180deg,rgb(var(--panel-rgb)/.94),rgb(var(--bg2-rgb)/.94));border:1px solid var(--line);border-radius:var(--radius-md);padding:12px 14px;cursor:pointer;box-shadow:var(--shadow-soft);transition:border-color .16s,background .16s,transform .16s;min-width:0}
+.srow.hasChildren{align-items:start}
+.srow:hover{border-color:var(--line2);background:linear-gradient(180deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg2-rgb)/.96));transform:translateY(-1px)}
+.srow.active,.srow.live{border-color:rgb(var(--signal-rgb)/.62);box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.12),var(--shadow-soft)}
+.srow .t{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.srow .meta{font-size:var(--fs-12);color:var(--faint);margin-top:2px}
+.srow .c{font-weight:var(--fw-heavy);font-size:var(--fs-16);text-align:right}
+.sMain{min-width:0}
+.sbar{height:4px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.045);overflow:hidden;margin-top:8px}
+.sbar i{display:block;height:100%;background:linear-gradient(90deg,var(--accent),var(--signal));border-radius:var(--radius-xs)}
+.smetrics{text-align:right;min-width:88px}
+.sactions{display:flex;align-items:center;justify-content:flex-end}
+.sactions .sessionDelete{margin-top:0}
+.smetrics .meta{font-size:var(--fs-11)}
+.badge{font-size:var(--fs-11);color:var(--dim);background:rgb(var(--tint-rgb)/.045);border:1px solid var(--line);padding:3px 6px;border-radius:var(--radius-sm);box-shadow:var(--inset)}
diff --git a/dashboard/styles/tools.css b/dashboard/styles/tools.css
new file mode 100644
index 00000000..321f9e1a
--- /dev/null
+++ b/dashboard/styles/tools.css
@@ -0,0 +1,349 @@
+/* tools-review-workflow-v3 */
+.capStats{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));margin:0 0 12px;padding:0!important;overflow:hidden}
+.capStat{display:grid;min-width:0;min-height:88px;align-content:center;gap:2px;padding:12px 16px;border:0;border-left:1px solid var(--line);background:transparent;color:var(--fg);font:inherit;text-align:left;cursor:pointer}
+.capStat:first-child{border-left:0}
+.capStat:hover{background:rgb(var(--signal-rgb)/.055)}
+.capStat.on{background:linear-gradient(145deg,rgb(var(--signal-rgb)/.13),rgb(var(--signal-mid-rgb)/.045));box-shadow:inset 0 -2px 0 var(--accent)}
+.capStatLabel{color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy)}
+.capStat strong{font:var(--fw-bold) var(--fs-22)/1.15 var(--font-mono)}
+.capStatDetail{overflow-wrap:anywhere;color:var(--faint);font-size:var(--fs-11);line-height:1.35}
+.capReviewQueue{margin:0;overflow:hidden;border-color:rgb(var(--signal-rgb)/.3);background:rgb(var(--panel-rgb)/.94)}
+.capReviewQueue.good{border-color:rgb(var(--green-rgb)/.3)}
+.capReviewQueue.warn{border-color:rgb(var(--orange-rgb)/.42)}
+.capQueueHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px;padding:16px 18px 12px}
+.capQueueHead h2{margin:0;font-size:var(--fs-18)}
+.capQueueDetail{max-width:780px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
+.capQueueCount{flex:none;padding-top:2px;color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.4 var(--font-mono)}
+.capReviewList{display:grid}
+.capQueueLoading,.capQueueEmpty{padding:24px 18px;color:var(--dim);font-size:var(--fs-12)}
+.capQueueEmpty h3{margin:0;color:var(--fg);font-size:var(--fs-16)}
+.capQueueEmpty p{max-width:760px;margin:4px 0 0;line-height:1.5}
+.capQueueEmpty .tbtn{margin-top:12px}
+.capReviewHead,.capReviewItem{display:grid;grid-template-columns:minmax(0,1fr) 84px;align-items:start;gap:0 12px;padding:4px 18px;border-bottom:1px solid var(--line)}
+.capReviewHead{padding-top:8px;padding-bottom:6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
+.capReviewHead>span:last-child{text-align:right}
+.capReviewItem:last-child{border-bottom:0}
+.capReviewItem>.capSelect{justify-self:end}
+.capReviewCols{display:grid;grid-template-columns:12px minmax(0,1fr) 148px 92px 72px 124px;align-items:center;gap:12px;min-width:0}
+.capReviewHead .capReviewCols:before{content:""}
+.capReviewRow{min-width:0}
+.capReviewRow>summary{min-height:36px;border-radius:var(--radius-sm);list-style:none;cursor:pointer}
+.capReviewRow>summary::-webkit-details-marker{display:none}
+.capReviewRow>summary:before{content:"\25B8";color:var(--faint);font-size:var(--fs-11);transition:transform .15s ease}
+.capReviewRow[open]>summary:before{transform:rotate(90deg)}
+.capReviewRow>summary:hover{background:rgb(var(--signal-rgb)/.035)}
+.capReviewRow>summary:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.capReviewName{display:flex;align-items:baseline;gap:8px;min-width:0;overflow:hidden;white-space:nowrap}
+.capReviewName strong{overflow:hidden;color:var(--fg);font-size:var(--fs-14);text-overflow:ellipsis}
+.capReviewName span{flex:none;color:var(--faint);font-size:var(--fs-11)}
+.capReviewNum{overflow:hidden;color:var(--fg);font:var(--fw-semibold) var(--fs-12)/1.4 var(--font-mono);font-variant-numeric:tabular-nums;text-overflow:ellipsis;white-space:nowrap}
+.capReviewCols .stateDot{color:var(--dim);font-size:var(--fs-11)}
+.capSelect{display:inline-flex;min-height:36px;align-items:center;gap:6px;padding:0 8px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);color:var(--fg);font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer}
+.capSelect input{width:15px;height:15px;accent-color:var(--warn)}
+.capReviewFacts{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:0;margin:0;border-top:1px solid var(--line);border-bottom:1px solid var(--line)}
+.capReviewFacts>div{padding:10px 12px;border-left:1px solid var(--line)}
+.capReviewFacts>div:first-child{padding-left:0;border-left:0}
+.capReviewFacts dt{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.capReviewFacts dd{margin:4px 0 0;color:var(--fg);font-size:var(--fs-12);line-height:1.4}
+.capReviewImpact{margin:0;color:var(--dim);font-size:var(--fs-12);line-height:1.5}
+.capReviewDisclosureBody{display:grid;gap:6px;margin:4px 0 8px 24px;padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.28);color:var(--dim);font-size:var(--fs-11)}
+.capReviewDisclosureBody b{color:var(--fg)}
+.capReviewMembers{display:flex;flex-wrap:wrap;gap:4px}
+.capReviewMembers span{padding:3px 6px;border:1px solid var(--line);border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.025);color:var(--dim);font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono)}
+.capReviewControl{overflow-wrap:anywhere;color:var(--faint);font:var(--fw-semibold) var(--fs-11)/1.45 var(--font-mono)}
+.capSelectionBar{display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:10px 18px;border-top:1px solid rgb(var(--orange-rgb)/.3);background:rgb(var(--orange-rgb)/.06)}
+.capSelectionBar[hidden]{display:none}
+.capSelectionBar span{margin-right:auto;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold)}
+.capSelectionBar .tbtn{min-height:36px}
+.capInventory{margin-top:12px;padding:0!important;overflow:hidden}
+.capInventoryHead{display:flex;align-items:center;gap:16px;padding:14px 16px}
+.capInventorySummary{display:grid;gap:2px;min-width:0}
+.capInventorySummary h2{margin:0;font-size:var(--fs-14)}
+.capInventoryCount{margin-left:auto;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.4 var(--font-mono);white-space:nowrap}
+.capInventoryBody{padding:14px 16px 16px;border-top:1px solid var(--line)}
+.capCatalog{display:grid;grid-template-columns:minmax(220px,.42fr) minmax(0,1fr);align-items:center;gap:20px;margin:0 0 12px;padding:0 0 12px;border-bottom:1px solid var(--line)}
+.capCatalogHead{display:grid;gap:2px}
+.capCatalogHead b{font-size:var(--fs-12)}
+.capCatalogHead small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium)}
+.capCatalogHead .subline{margin:3px 0 0}
+.capCatalogBody{min-width:0}
+.capFilterControl{display:grid;gap:4px;min-width:0}
+.capFilterControl>span{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.capFilters{grid-template-columns:minmax(230px,1fr) auto auto minmax(130px,auto);align-items:end;padding:12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--panel-rgb)/.66)}
+.capFilters .searchbox,.capFilters select{width:100%;height:38px;background:rgb(var(--bg-rgb)/.58)}
+.capFilterStatus{display:flex;align-items:flex-start;justify-content:space-between;gap:12px;min-height:18px;margin:-3px 0 10px;padding:0 2px}
+.capFilterStatus .clearFilters{padding:4px 8px}
+.capTableWrap{overflow-x:auto;border:1px solid var(--line);border-radius:var(--radius-md)}
+.capTableWrap .tbl{min-width:940px}
+.capEvidence{display:grid;gap:2px}
+.capEvidence strong{color:var(--fg);font-size:var(--fs-12)}
+.capEvidence small{color:var(--faint);font-size:var(--fs-11);line-height:1.35}
+.stateDot.unknown:before{background:var(--faint)}
+.stateDot.observed:before{background:var(--accent)}
+.capEmpty,.capMore{padding:28px!important;text-align:center;color:var(--faint)}
+.capEmpty button{margin-left:8px}
+.capPath{max-width:280px}
+.capCatalogHead>span:first-child{display:grid;gap:2px}
+@media(max-width:1400px){.capFilters{grid-template-columns:1fr 1fr}.capFilterControl:first-child{grid-column:1/-1}}
+@media(max-width:800px){.capReviewFacts{grid-template-columns:1fr}.capReviewFacts>div,.capReviewFacts>div:first-child{padding:8px 0;border-left:0;border-top:1px solid var(--line)}.capReviewFacts>div:first-child{border-top:0}.capReviewHead{display:none}.capReviewCols{grid-template-columns:12px minmax(0,1fr)}.capReviewCols>:nth-child(n+2){grid-column:2}.capReviewDisclosureBody{margin-left:0}.capInventoryHead{align-items:flex-start}.capCatalog{grid-template-columns:1fr;gap:8px}.capCatalogHead{grid-template-columns:minmax(0,1fr) auto;align-items:start}.capCatalogHead .subline{margin:0}.capFilters{grid-template-columns:1fr;padding:10px}.capFilterControl:first-child{grid-column:1}.capFilters .seg{width:100%}.capFilters .seg button{flex:1}.capTableWrap{overflow:visible;border:0;border-radius:0}.capTableWrap .tbl{display:block;min-width:0}.capTableWrap thead{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}.capTableWrap tbody{display:grid;gap:8px}.capTableWrap tr{display:grid;padding:12px;border:1px solid var(--line);border-radius:var(--radius-md);background:var(--spectrum-card);box-shadow:var(--shadow-soft)}.capTableWrap td{display:grid;grid-template-columns:minmax(92px,.38fr) minmax(0,1fr);gap:10px;padding:6px 0;border-bottom:1px solid rgb(var(--tint-rgb)/.055);overflow-wrap:anywhere}.capTableWrap td:last-child{border-bottom:0}.capTableWrap td:before{content:attr(data-label);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.capTableWrap td.nm{display:block;padding-top:2px;font-size:var(--fs-16)}.capTableWrap td.nm:before{display:block;margin-bottom:4px}.capTableWrap .capPath{max-width:100%;white-space:normal}.capTableWrap .capEmpty{display:block}.capTableWrap .capEmpty:before{display:none}.capFilterStatus{align-items:stretch;flex-direction:column}.capFilterStatus .clearFilters{align-self:flex-start}.capCatalogBody .legend{gap:8px}}
+.capMobileSort{display:none}
+@media(max-width:800px){.capMobileSort{display:grid;grid-template-columns:auto minmax(150px,220px);align-items:center;justify-content:end;gap:8px;margin:10px 0;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.capMobileSort select{height:38px}.capTableWrap .capMore{display:block}.capTableWrap .capMore:before{display:none}}
+@media(max-width:520px){.capStat{min-height:86px;padding:10px 8px}.capStat strong{font-size:var(--fs-20)}.capStatDetail{font-size:var(--fs-11)}.capQueueHead,.capReviewItem,.capQueueEmpty{padding-left:12px;padding-right:12px}.capQueueHead{display:grid}.capQueueCount{padding:0}.capSelect{min-height:44px;justify-content:center}.capSelectionBar{align-items:stretch;flex-wrap:wrap;padding:10px 12px}.capSelectionBar span{width:100%;margin:0}.capSelectionBar .tbtn{min-height:44px;flex:1}.capInventoryHead{padding:12px}.capInventoryBody{padding:12px}.capCatalogHead .subline{display:none}}
+.modelChartTip{max-width:min(440px,calc(100% - 16px))}
+.modelTipMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}
+.spendRangeControls{display:grid;justify-items:end;gap:8px;max-width:100%}
+.spendCustom{display:flex;align-items:flex-end;justify-content:flex-end;gap:8px;flex-wrap:wrap}
+.spendCustom[hidden]{display:none}
+.spendCustom label{display:grid;gap:4px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.spendCustom input{height:36px;min-width:144px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.62);padding:0 8px;color:var(--fg);color-scheme:dark;font:var(--fw-semibold) var(--fs-11)/1 var(--font-mono)}
+.spendCustom input:focus-visible{border-color:var(--accent);outline:2px solid rgb(var(--signal-rgb)/.2);outline-offset:1px}
+.spendCustom #s-range-error{max-width:270px;padding-bottom:8px;color:var(--bad);font-size:var(--fs-11)}
+.spendKpis{display:grid;grid-template-columns:1.25fr repeat(3,minmax(0,1fr));gap:12px}
+.spendKpi{min-width:0;padding:14px 16px}
+.spendKpi .v{margin-top:4px;overflow-wrap:anywhere;font-size:var(--fs-24);letter-spacing:-.02em}
+.spendKpi:first-child .v{font-size:var(--fs-28)}
+.spendKpi .subline{min-height:16px;margin-top:4px;font-size:var(--fs-11)}
+.spendChartCard{margin-top:12px;padding:16px 18px 14px;overflow:hidden}
+.spendChartHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px}
+.spendChartHead h2,.spendPanelHead h2,.spendPlatformCard h2{margin:0;font-size:var(--fs-14)}
+.spendChartHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-12)}
+.spendChartControls{display:grid;justify-items:end;gap:8px}
+.spendChartControls .seg button{padding:4px 12px;font-size:var(--fs-12)}
+.spendChartControls .seg button[aria-disabled=true]{opacity:.42;cursor:not-allowed}
+.spendLegend{display:flex;align-items:center;justify-content:flex-end;gap:12px;flex-wrap:wrap;color:var(--dim);font-size:var(--fs-11)}
+.spendLegend span{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
+.spendLegend i{width:9px;height:9px;border-radius:var(--radius-2xs);background:var(--spend-color)}
+.spendLegend .spendEstimateKey i{border:1px solid rgb(var(--tint-rgb)/.28);background:repeating-linear-gradient(135deg,rgb(var(--tint-rgb)/.38) 0 1px,transparent 1px 4px),rgb(var(--tint-rgb)/.08)}
+.spendLegend .spendPartialKey i{border:1px solid rgb(var(--tint-rgb)/.7)}
+.spendLegend .spendIncompleteKey i{border:1px dashed rgb(var(--tint-rgb)/.5);background:rgb(var(--tint-rgb)/.14)}
+.spendChart{min-height:270px;margin-top:12px;overflow:hidden;display:grid;grid-template-columns:58px minmax(0,1fr);--spend-day-head:22px;--spend-day-foot:24px;--spend-day-gap:3px;--spend-chart-h:260px}
+.spendYAxis{height:var(--spend-chart-h);display:flex;flex-direction:column;justify-content:space-between;padding:calc(var(--spend-day-head) + var(--spend-day-gap)) 8px calc(var(--spend-day-foot) + var(--spend-day-gap)) 0;color:var(--faint);font-size:var(--fs-11);text-align:right}
+.spendPlot{position:relative;min-width:0;overflow:hidden;border-bottom:1px solid var(--line)}
+.spendYAxis span{line-height:0}
+.spendGrid{position:absolute;top:calc(var(--spend-day-head) + var(--spend-day-gap));right:0;left:0;height:calc(var(--spend-chart-h) - var(--spend-day-head) - var(--spend-day-foot) - 2*var(--spend-day-gap));background:repeating-linear-gradient(to bottom,rgb(var(--tint-rgb)/.07) 0 1px,transparent 1px 25%);pointer-events:none}
+.spendChartInner{position:relative;width:100%;height:var(--spend-chart-h);display:flex;align-items:stretch}
+.spendDay{appearance:none;position:relative;display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:var(--spend-day-head) minmax(0,1fr) var(--spend-day-foot);flex:1 1 0;min-width:0;gap:var(--spend-day-gap);border:0;border-radius:var(--radius-sm);background:transparent;padding:0;color:var(--faint);font:inherit;cursor:pointer}
+.spendDay:hover,.spendDay:focus-visible{background:rgb(var(--signal-rgb)/.055);outline:none}
+.spendDay:focus-visible{box-shadow:inset 0 0 0 1px rgb(var(--signal-rgb)/.52)}
+.spendBarValue{overflow:hidden;color:var(--dim);font-size:var(--fs-11);text-align:center;text-overflow:ellipsis;white-space:nowrap;opacity:0}
+.spendDay:hover .spendBarValue{opacity:1}
+.spendDayTrack .spendBarValue{flex:none;max-width:100%;padding-bottom:3px;line-height:1.3}
+.spendChartInner[data-values=shown] .spendBarValue{opacity:1}
+.spendDay[data-peak=true] .spendBarValue{position:relative;z-index:1;max-width:none;overflow:visible;color:var(--fg);font-weight:var(--fw-bold);opacity:1}
+.spendDay[data-peak=true][data-peak-edge=first] .spendBarValue{align-self:flex-start}
+.spendDay[data-peak=true][data-peak-edge=last] .spendBarValue{align-self:flex-end}
+.spendDayTrack{grid-row:2;display:flex;height:100%;min-height:0;flex-direction:column;align-items:center;justify-content:flex-end;border-bottom:1px solid var(--line2)}
+.spendDayStack{display:flex;flex:none;width:min(var(--spend-bar-max,24px),var(--spend-bar-share,64%));min-width:2px;height:var(--spend-height);min-height:0;flex-direction:column-reverse;overflow:hidden;transition:opacity .16s,filter .16s}
+.spendChartInner[data-granularity] .spendDay:is(:hover,:focus-visible) .spendDayStack{filter:brightness(1.18)}
+.spendChartInner[data-dense=true]{--spend-bar-share:52%}
+.spendChartInner[data-granularity=week]{--spend-bar-max:44px}
+.spendChartInner[data-granularity=month]{--spend-bar-max:64px}
+.spendChartInner[data-granularity]:hover .spendDay:not(:hover) .spendDayStack,.spendChartInner[data-granularity]:has(.spendDay:focus-visible) .spendDay:not(:focus-visible) .spendDayStack{opacity:.45}
+.spendDay[data-incomplete=true] .spendDayStack{opacity:.6;outline:1px dashed rgb(var(--tint-rgb)/.5);outline-offset:1px}
+.spendChartInner[data-granularity] .spendDay[data-incomplete=true]:is(:hover,:focus-visible) .spendDayStack{opacity:.85}
+.spendStackSegment{display:block;flex:none;height:var(--segment-share);min-height:1px;background:var(--spend-color)}
+.spendStackSegment[data-estimated=true]{background:repeating-linear-gradient(135deg,rgb(var(--tint-rgb)/.32) 0 1px,transparent 1px 4px),var(--spend-color)}
+.spendStackSegment[data-partial=true]{box-shadow:inset 0 0 0 1px rgb(var(--tint-rgb)/.32)}
+.spendChartInner[data-granularity] .spendStackSegment{opacity:.82;transition:opacity .16s}
+.spendChartInner[data-granularity] .spendStackSegment+.spendStackSegment{border-bottom:1px solid rgb(var(--bg2-rgb)/.9)}
+.spendChartInner[data-granularity] .spendDay:is(:hover,:focus-visible) .spendStackSegment{opacity:1}
+.spendDayLabel{position:absolute;bottom:0;left:50%;width:max-content;max-width:none;transform:translateX(-50%);font-size:var(--fs-11);line-height:20px;text-align:center;white-space:nowrap;pointer-events:none}
+.spendDay[data-axis-edge=first] .spendDayLabel{left:0;transform:none;text-align:left}
+.spendDay[data-axis-edge=last] .spendDayLabel{right:0;left:auto;transform:none}
+.spendAverageLine{position:absolute;z-index:2;right:0;left:0;height:1px;border-top:1px solid rgb(var(--soft-rgb)/.62);pointer-events:none}
+.spendAverageLine[hidden]{display:none}
+.spendAverageLine span{position:absolute;right:3px;bottom:4px;border-radius:var(--radius-xs);background:rgb(var(--bg2-rgb)/.88);padding:1px 4px;color:var(--soft);font-size:var(--fs-11);line-height:1.35}
+.spendChartTip{z-index:8;width:min(250px,calc(100% - 24px));padding:10px 10px;font-size:var(--fs-11);line-height:1.45}
+.spendChartTip[hidden]{display:none}
+.spendTipDate{color:var(--fg);font-weight:var(--fw-heavy)}
+.spendTipTotal{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-top:4px;padding-bottom:6px;border-bottom:1px solid var(--line)}
+.spendTipTotal b{color:var(--fg)}
+.spendTipNote{margin-top:6px;color:var(--warn);font-size:var(--fs-11)}
+.spendTipSpan{margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.spendTipRuntimes{display:grid;margin-top:4px}
+.spendTipRuntime{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:1px 8px;padding:4px 0;border-top:1px solid var(--line)}
+.spendTipRuntime:first-child{border-top:0}
+.spendTipRuntime>span{display:flex;align-items:center;gap:6px;color:var(--fg);font-weight:var(--fw-bold)}
+.spendTipRuntime i{width:8px;height:8px;border-radius:var(--radius-2xs);background:var(--spend-color)}
+.spendTipRuntime b{color:var(--fg)}
+.spendTipRuntime small{grid-column:1/-1;color:var(--faint);font-size:var(--fs-11)}
+.spendTipEmpty{padding:6px 0;color:var(--faint)}
+.spendEvidenceGrid{display:grid;grid-template-columns:minmax(0,1.3fr) minmax(300px,.7fr);align-items:stretch;gap:12px;margin-top:12px}
+.spendLogsCard,.spendPlatformCard{height:360px;display:flex;min-height:0;flex-direction:column;padding:16px 18px}
+.spendPanelHead{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}
+.spendPanelHead>div>span,.spendPanelHead>span{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.spendPanelHead>span{flex:none}
+.spendLogs{display:grid;min-height:0;flex:1;margin-top:6px;overflow-y:auto;overflow-x:hidden;scrollbar-gutter:stable;scrollbar-color:var(--line2) transparent}
+.spendLogRow{height:68px;display:grid;grid-template-columns:28px minmax(0,1fr) auto auto;align-items:center;gap:10px;padding:0;border-top:1px solid var(--line)}
+.spendLogRow:first-child{border-top:0}
+.spendLogRank{width:24px;height:24px;display:grid;place-items:center;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.spendLogMain{min-width:0}
+.spendLogName{overflow:hidden;color:var(--fg);font-weight:var(--fw-bold);text-overflow:ellipsis;white-space:nowrap}
+.spendLogMeta{margin-top:1px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
+.spendLogTrack{height:4px;margin-top:6px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045)}
+.spendLogTrack i{display:block;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi))}
+.spendLogValue{min-width:84px;text-align:right}
+.spendLogValue strong{display:block;font-size:var(--fs-13)}
+.spendLogValue span{display:block;margin-top:1px;color:var(--faint);font-size:var(--fs-11)}
+.spendLogRow .tbtn{min-height:34px}
+.spendLogEmpty,.spendEmpty{min-height:100%;padding:18px}
+.spendPlatformBody{min-height:0;flex:1;overflow-y:auto;overflow-x:hidden;scrollbar-gutter:stable;scrollbar-color:var(--line2) transparent}
+.spendPlatformRows{display:grid;margin-top:8px}
+.spendPlatformRow{display:grid;grid-template-columns:minmax(78px,.48fr) minmax(72px,1fr) minmax(82px,auto);align-items:center;gap:10px;padding:8px 0;border-top:1px solid var(--line)}
+.spendPlatformRow:first-child{border-top:0}
+.spendPlatformName{display:flex;min-width:0;align-items:center;gap:8px;font-weight:var(--fw-bold)}
+.spendPlatformName i{width:9px;height:9px;flex:none;border-radius:var(--radius-2xs);background:var(--spend-color)}
+.spendPlatformTrack{height:7px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045)}
+.spendPlatformTrack i{display:block;height:100%;border-radius:inherit;background:var(--spend-color)}
+.spendPlatformValue{min-width:82px;text-align:right;font-weight:var(--fw-heavy)}
+.spendPlatformValue span{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-semibold)}
+.spendInsightSection{margin-top:28px}
+.spendInsightHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:10px;padding-top:20px;border-top:1px solid var(--line)}
+.spendInsightHead h2{margin:0;font-size:var(--fs-18)}
+.spendInsightHead p{max-width:760px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.5}
+.spendInsightRange{flex:none;color:var(--faint);font:var(--fw-semibold) var(--fs-11)/1.4 var(--font-mono)}
+.spendInsightGrid{display:grid;grid-template-columns:minmax(290px,.72fr) minmax(0,1.28fr);gap:12px}
+.spendConcentrationCard,.spendShapeCard,.spendScatterCard{padding:16px 18px}
+.spendInsightCardHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
+.spendInsightCardHead h3{margin:0;font-size:var(--fs-14)}
+.spendInsightCardHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.45}
+.spendConcentrationValue{margin-top:18px;color:var(--fg);font:var(--fw-heavy) var(--fs-44)/1 var(--font-mono);letter-spacing:-.035em}
+.spendConcentrationNote{min-height:34px;margin-top:6px;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
+.spendConcentrationBar{height:12px;margin-top:14px;overflow:hidden;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.035)}
+.spendConcentrationBar i{display:block;height:100%;width:0;border-radius:inherit;background:linear-gradient(90deg,var(--signal-hi),var(--accent))}
+.spendConcentrationLegend{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-top:6px;color:var(--faint);font-size:var(--fs-11)}
+.spendImpactList{display:grid;margin-top:14px;border-top:1px solid var(--line)}
+.spendImpactRow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:10px;width:100%;align-items:center;border:0;border-bottom:1px solid var(--line);background:transparent;padding:8px 0;color:var(--fg);font:inherit;text-align:left;cursor:pointer}
+.spendImpactRow:last-child{border-bottom:0}
+.spendImpactRow:hover .spendImpactName,.spendImpactRow:focus-visible .spendImpactName{color:var(--accent)}
+.spendImpactRow:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:var(--radius-xs)}
+.spendImpactName{min-width:0;overflow:hidden;font-size:var(--fs-12);font-weight:var(--fw-bold);text-overflow:ellipsis;white-space:nowrap}
+.spendImpactValue{text-align:right}
+.spendImpactValue b{display:block;font-size:var(--fs-12)}
+.spendImpactValue small{display:block;margin-top:1px;color:var(--faint);font-size:var(--fs-11)}
+.spendShape{margin-top:10px}
+.spendShapeHeader,.spendShapeRow{display:grid;grid-template-columns:118px 72px minmax(150px,1fr) minmax(280px,.9fr);align-items:center;gap:12px}
+.spendShapeHeader{padding:0 0 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
+.spendShapeHeader span:last-child{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;text-align:right}
+.spendShapeRow{min-height:62px;border-top:1px solid var(--line)}
+.spendShapeIdentity b{display:block;font-size:var(--fs-12)}
+.spendShapeIdentity small,.spendShapeCoverage{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
+.spendShapeCoverage{margin:0}
+.spendShapeRail{position:relative;height:22px}
+.spendShapeRail:before{content:"";position:absolute;top:10px;right:0;left:0;height:2px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.09)}
+.spendShapeIqr{position:absolute;top:7px;left:var(--p25);width:calc(var(--p75) - var(--p25));height:8px;border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.3)}
+.spendShapeMedian,.spendShapeMean{position:absolute;top:4px;left:var(--median);width:2px;height:14px;border-radius:var(--radius-2xs);background:var(--accent);transform:translateX(-50%)}
+.spendShapeMean{top:7px;left:var(--mean);width:7px;height:7px;border:1px solid var(--panel);background:var(--signal-hi);transform:translateX(-50%) rotate(45deg)}
+.spendShapeValues{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;text-align:right}
+.spendShapeValues span{min-width:0;overflow:hidden;color:var(--dim);font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono);text-overflow:ellipsis;white-space:nowrap}
+.spendShapeEmpty{min-height:228px}
+.spendScatterCard{position:relative;margin-top:12px;overflow:hidden}
+.spendScatterControls{display:flex;align-items:center;justify-content:flex-end;gap:12px;flex-wrap:wrap}
+.spendScatterCoverage{color:var(--faint);font-size:var(--fs-11)}
+.spendScatterWrap{position:relative;margin-top:10px}
+.spendScatterSvg{display:block;width:100%;height:340px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.28)}
+.spendScatterPoint{cursor:pointer;transition:r .14s ease,stroke-width .14s ease}
+.spendScatterPoint:hover,.spendScatterPoint:focus{r:8;stroke-width:3}
+.spendScatterLink:focus{outline:none}
+.spendScatterLink:focus .spendScatterPoint{r:8;stroke:var(--white);stroke-width:3}
+.spendScatterTip{z-index:8;width:min(270px,calc(100% - 20px));padding:10px 10px;font-size:var(--fs-11);line-height:1.45}
+.spendScatterTip[hidden]{display:none}
+.spendScatterTip b{display:block;overflow:hidden;margin-bottom:4px;color:var(--fg);font-size:var(--fs-12);text-overflow:ellipsis;white-space:nowrap}
+.spendScatterTip span{display:flex;justify-content:space-between;gap:12px}
+.spendScatterTip strong{color:var(--fg);font-weight:var(--fw-bold)}
+.spendScatterLegend{display:flex;align-items:center;gap:12px;margin-top:8px;color:var(--faint);font-size:var(--fs-11)}
+.spendScatterLegend span{display:inline-flex;align-items:center;gap:4px}
+.spendScatterLegend span[hidden]{display:none}
+.spendScatterLegend i{width:8px;height:8px;border-radius:var(--radius-round);background:var(--accent)}
+.spendScatterLegend i.top{border:2px solid var(--signal-hi);background:transparent}
+.spendShapeHeader,.spendShapeRow{grid-template-columns:100px 64px minmax(104px,1fr) minmax(225px,.9fr);gap:8px}
+.spendShapeHeader span:last-child i{font-style:normal}
+.spendScatterLegend i.spendScatterTopDot{border:2px solid var(--signal-hi);background:transparent}
+@media(max-width:900px){.spendRangeControls{width:100%;justify-items:start}.spendKpis{grid-template-columns:repeat(2,minmax(0,1fr))}.spendChartHead{display:grid}.spendLegend{justify-content:flex-start}.spendCustom{justify-content:flex-start}.spendEvidenceGrid,.spendInsightGrid{grid-template-columns:1fr}.spendInsightHead{align-items:flex-start;flex-direction:column}.spendInsightRange{white-space:normal}.spendScatterControls{justify-content:flex-start}}
+@media(max-width:700px){.spendShapeHeader{display:none}.spendShapeRow{grid-template-columns:minmax(0,1fr) auto;gap:8px;padding:10px 0}.spendShapeRail,.spendShapeValues{grid-column:1/-1}.spendShapeValues span{display:grid;gap:2px;text-align:left}.spendShapeValues span:before{content:attr(data-label);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-sans);text-transform:uppercase}.spendScatterSvg{height:300px}}
+@media(max-width:520px){.spendKpis{grid-template-columns:1fr}.spendKpi .v,.spendKpi:first-child .v{font-size:var(--fs-22)}.spendCustom{display:grid;grid-template-columns:1fr 1fr;width:100%}.spendCustom label,.spendCustom input{width:100%;min-width:0}.spendCustom #s-range-error{grid-column:1/-1;padding:0}.spendPlatformRow{grid-template-columns:minmax(0,1fr) auto}.spendPlatformTrack{grid-column:1/-1;grid-row:2}.spendChartCard{padding-inline:12px}.spendChart{grid-template-columns:44px minmax(0,1fr)}.spendYAxis{padding-right:6px;font-size:var(--fs-11)}.spendLogsCard,.spendPlatformCard,.spendConcentrationCard,.spendShapeCard,.spendScatterCard{padding:14px 12px}.spendLogRow{height:86px;grid-template-columns:24px minmax(0,1fr) auto;gap:8px}.spendLogRank{width:22px;height:22px}.spendLogValue{grid-column:2/4;grid-row:2;display:flex;min-width:0;align-items:baseline;justify-content:space-between;gap:10px;text-align:left}.spendLogValue strong,.spendLogValue span{display:block;margin:0}.spendLogRow .tbtn{grid-column:3;grid-row:1;min-height:44px;padding-inline:12px}.spendConcentrationValue{font-size:var(--fs-36)}.spendInsightCardHead{display:grid}.spendScatterControls .seg{width:100%}.spendScatterControls .seg button{flex:1}.spendScatterSvg{height:270px}.spendScatterLegend{align-items:flex-start;flex-direction:column;gap:4px}}
+@media(max-width:900px){.spectrumPageActions .modelControls{display:grid;width:100%;grid-template-columns:repeat(3,minmax(0,1fr));gap:6px}.spectrumPageActions .modelControls .filterControl{min-width:0}.spectrumPageActions .spendRangeControls{display:block;width:100%;min-width:0}}
+@media(max-width:520px){.spectrumPageActions .modelControls{grid-template-columns:repeat(3,minmax(0,1fr))}}
+.currentSessionRuntime:before,.badge.app:before{content:none}
+.runtimeMark{display:block;width:16px;height:16px;flex:0 0 auto;overflow:visible;color:currentColor}
+.runtimeMark path,.runtimeMark circle,.runtimeMark polygon{vector-effect:non-scaling-stroke}
+.currentSessionRuntime .runtimeMark{width:18px;height:18px}
+.efficiencyHeadline{min-height:166px;padding:12px 14px 10px}
+.efficiencySupportItem{min-height:166px;padding:12px 14px 10px}
+.efficiencyHeadline .efficiencyChart{height:56px}
+.efficiencySupportItem .efficiencyChart{height:56px}
+.deliveryOverview{margin-top:14px;padding:0 20px;overflow:hidden;background:linear-gradient(180deg,rgb(var(--panel-rgb)/.98),rgb(var(--bg2-rgb)/.98));box-shadow:var(--shadow-soft)}
+.deliveryOverview:before{content:"";position:absolute;inset:0 0 auto;height:2px;background:linear-gradient(90deg,var(--signal),rgb(var(--signal-hi-rgb)/.58) 42%,transparent 82%)}
+.deliveryOverviewHead{min-height:68px;display:flex;align-items:center;justify-content:space-between;gap:20px;padding:14px 0 12px;border-bottom:1px solid var(--line)}
+.deliveryEyebrow{display:flex;align-items:center;gap:6px;color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono);text-transform:uppercase;letter-spacing:.045em}
+.deliveryOverview h2{display:flex;align-items:baseline;gap:8px;max-width:760px;margin:4px 0 0;color:var(--fg);font-size:var(--fs-20);font-weight:var(--fw-bold);line-height:1.24;letter-spacing:-.018em}
+.deliveryOverview h2 .good{color:var(--good)}
+.deliveryComparisonDivider{color:var(--line3);font-size:var(--fs-16)}
+.deliveryCoverageState{display:inline-flex;flex:none;align-items:center;gap:6px;border:1px solid rgb(var(--green-rgb)/.24);border-radius:var(--radius-pill);background:rgb(var(--green-rgb)/.055);padding:4px 8px;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-bold);white-space:nowrap}
+.deliveryCoverageState:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:var(--good)}
+.deliveryCoverageState.partial{border-color:rgb(var(--orange-rgb)/.24);background:rgb(var(--orange-rgb)/.055)}
+.deliveryCoverageState.partial:before{background:var(--warn)}
+.deliveryMetricGrid{display:grid;grid-template-columns:minmax(0,1.04fr) minmax(0,.94fr) minmax(0,.94fr) minmax(196px,.92fr)}
+.deliveryMetric{min-width:0;padding:14px 20px 12px 0}
+.deliveryMetric+.deliveryMetric{border-left:1px solid var(--line);padding-right:0;padding-left:20px}
+.deliveryMetricLabel{width:max-content;max-width:100%;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.045em}
+.deliveryMetricValue{margin-top:4px;overflow:hidden;color:var(--signal-hi);font:var(--fw-heavy) var(--fs-28)/1 var(--font-mono);letter-spacing:-.035em;text-overflow:ellipsis;white-space:nowrap}
+.deliveryMetric .trendDelta>span{max-width:11ch}
+@media(max-width:1360px){.deliveryMetric .deliveryMetricValue{font-size:var(--fs-24)}}
+.deliveryMetricMeta{min-height:15px;margin-top:6px;color:var(--faint);font-size:var(--fs-11);white-space:nowrap}
+.deliveryMetricMeta b{color:var(--dim);font-weight:var(--fw-bold)}
+.deliveryMetricTop{display:flex;align-items:baseline;justify-content:space-between;gap:12px}
+.deliveryMetricTop strong{color:var(--fg);font:var(--fw-heavy) var(--fs-22)/1 var(--font-mono)}
+.deliveryCoverageBar{height:7px;margin-top:12px;overflow:hidden;border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045)}
+.deliveryCoverageBar i{display:block;width:calc(var(--delivery-coverage,0)*1%);height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--signal-mid),var(--good));transition:width .28s ease}
+.deliveryCoverageBar.partial i{background:linear-gradient(90deg,var(--signal-mid),var(--warn))}
+.deliveryEvidenceStrip{display:flex;min-height:35px;align-items:center;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11)}
+.deliveryEvidenceItem{display:flex;align-items:baseline;gap:6px;padding:0 18px;border-left:1px solid var(--line)}
+.deliveryEvidenceItem:first-child{padding-left:0;border-left:0}
+.deliveryEvidenceItem strong{color:var(--dim);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
+.deliveryVisual{margin-top:12px;padding:16px 20px 14px;overflow:hidden;box-shadow:var(--shadow-soft)}
+.deliveryVisualHead,.deliveryProjectHead{display:flex;align-items:center;justify-content:space-between;gap:18px}
+.deliveryVisualHead h2,.deliveryProjectHead h2{margin:0;font-size:var(--fs-14)}
+.deliveryLegend{display:flex;align-items:center;justify-content:flex-end;gap:14px;color:var(--dim);font-size:var(--fs-11)}
+.deliveryLegend span{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
+.deliveryLegend span[hidden]{display:none}
+.deliveryLegend i{width:12px;height:5px;border-radius:var(--radius-2xs);background:var(--signal)}
+.deliveryLegend .deleted{background:var(--c-deleted)}
+.deliveryLegend .intensity{height:2px;border-radius:0;background:var(--good)}
+.deliveryLegend .typical{height:0;border-top:1px dashed var(--dim);border-radius:0;background:none}
+.deliveryLegend .quiet{width:5px;height:12px;border-radius:var(--radius-2xs);background:var(--warn)}
+.deliveryChartWrap{position:relative;height:270px;margin-top:8px}
+.deliveryChart{display:block;width:100%;height:270px}
+.deliveryChart .grid{stroke:var(--line);stroke-width:1}
+.deliveryChart .separator{stroke:var(--line2);stroke-width:1}
+.deliveryChart .axis{fill:var(--faint);font:var(--fs-11) var(--font-mono)}
+.deliveryChart .added{fill:var(--signal)}
+.deliveryChart .deleted{fill:var(--c-deleted)}
+.deliveryChart .typical{stroke:var(--dim);stroke-width:1;stroke-dasharray:4 4;opacity:.62}
+.deliveryChart .quiet{fill:var(--warn);opacity:.85}
+.deliveryHitGrid{position:absolute;display:grid;grid-template-columns:repeat(var(--delivery-days),1fr)}
+.deliveryHitGrid button{min-width:0;border:0;background:transparent;cursor:crosshair}
+.deliveryHitGrid button:focus-visible{outline:1px solid rgb(var(--signal-hi-rgb)/.52);outline-offset:-2px;border-radius:var(--radius-xs)}
+.deliveryChartTip{z-index:5;min-width:190px;padding:8px 10px;font-size:var(--fs-11);line-height:1.35;transform:translateX(-50%)}
+.deliveryChartTip[hidden]{display:none}
+.deliveryChartTip strong{display:block;margin-bottom:4px;color:var(--fg);font-weight:var(--fw-bold)}
+.deliveryTipRow{display:flex;justify-content:space-between;gap:18px;margin-top:3px}
+.deliveryTipRow b{color:var(--fg);font-family:var(--font-mono);font-weight:var(--fw-bold)}
+.deliveryProjects{margin-top:12px;overflow:hidden;box-shadow:var(--shadow-soft)}
+.deliveryProjectHead{padding:14px 18px 10px}
+.deliveryMobileSort{display:none}
+.deliveryTableWrap{overflow:auto}
+.deliveryTableWrap .tbl{min-width:720px}
+.deliveryTableWrap .tbl th,.deliveryTableWrap .tbl td{padding:10px 16px}
+.deliverySort{display:inline-flex;align-items:center;justify-content:flex-end;gap:4px;width:100%;padding:0;border:0;background:none;color:inherit;font:inherit;font-weight:inherit;text-transform:inherit;letter-spacing:inherit;cursor:pointer}
+.deliveryTableWrap .tbl th:first-child .deliverySort{justify-content:flex-start}
+.deliverySort:hover,.deliverySort:focus-visible{color:var(--fg)}
+.deliverySort:focus-visible{outline:1px solid var(--signal);outline-offset:3px;border-radius:var(--radius-2xs)}
+.deliverySortMark{width:9px;color:var(--signal-hi);font-size:var(--fs-11);text-align:center}
+.deliveryEmpty{min-height:130px;padding:20px}
+.deliveryClearStatus{color:var(--faint);font-size:var(--fs-11)}
+.deliveryVisualHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.4}
+@media(max-width:1180px){.deliveryOverview{padding-inline:18px}.deliveryMetric{padding-right:16px}.deliveryMetric+.deliveryMetric{padding-left:16px}.deliveryMetricValue{font-size:var(--fs-24)}}
+@media(max-width:900px){.deliveryMetricGrid{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryMetric:nth-child(odd){border-left:0;padding-left:0}.deliveryMetric:nth-child(n+3){border-top:1px solid var(--line)}.deliveryVisualHead{display:grid}.deliveryLegend{justify-content:flex-start}.deliveryChartWrap,.deliveryChart{height:260px}}
+@media(max-width:700px){.deliveryMobileSort{display:grid;grid-template-columns:auto minmax(132px,180px);align-items:center;gap:8px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.deliveryMobileSort select{height:32px}.deliveryTableWrap{overflow:visible;padding:0 12px 12px}.deliveryTableWrap .tbl{display:block;min-width:0}.deliveryTableWrap thead{display:none}.deliveryTableWrap tbody{display:grid;gap:8px}.deliveryTableWrap tr{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.018);box-shadow:var(--shadow-soft)}.deliveryTableWrap .tbl td{display:grid;gap:3px;min-width:0;padding:6px 0;border:0;text-align:left;overflow-wrap:anywhere}.deliveryTableWrap .tbl td:before{content:attr(data-label);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.deliveryTableWrap .tbl td:first-child{grid-column:1/-1;margin-bottom:3px;padding-bottom:8px;border-bottom:1px solid var(--line);color:var(--fg);font-weight:var(--fw-bold)}.deliveryTableWrap .tbl td:first-child:before{display:none}.deliveryTableWrap .tbl td[colspan]{display:block;grid-column:1/-1;margin:0;padding:0;border:0}.deliveryTableWrap .tbl td[colspan]:before{display:none}.deliveryTableWrap .deliveryEmpty{min-height:96px}}
+@media(max-width:520px){#view-git .spectrumPageActions .modelControls{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryOverview{padding-inline:14px}.deliveryOverviewHead{align-items:flex-start;flex-direction:column;gap:8px}.deliveryMetricGrid{grid-template-columns:1fr}.deliveryMetric+.deliveryMetric,.deliveryCoverageMetric{border-top:1px solid var(--line);border-left:0;padding-left:0}.deliveryEvidenceStrip{align-items:flex-start;flex-direction:column;padding-block:8px}.deliveryEvidenceItem,.deliveryEvidenceItem:first-child{padding:4px 0;border:0}.deliveryVisual{padding-inline:14px}.deliveryProjectHead{padding-inline:14px}}
diff --git a/dashboard/tail.html b/dashboard/tail.html
new file mode 100644
index 00000000..0cc1e1b8
--- /dev/null
+++ b/dashboard/tail.html
@@ -0,0 +1 @@
+</script></body></html>
diff --git a/page.html b/page.html
deleted file mode 100644
index 5200cdc5..00000000
--- a/page.html
+++ /dev/null
@@ -1,13233 +0,0 @@
-<!doctype html><html lang=en data-theme=classic><head><meta charset=utf-8>
-<script id=theme-boot>(function(){var ids=['classic','nebula','monolith','voltage','phosphor','omarchy','jadehorse','ferrous','afterglow'];function resolve(pref){return ids.indexOf(pref)>=0?pref:'classic';}window.tokenMeterTheme={ids:ids,resolve:resolve};try{document.documentElement.dataset.theme=resolve(localStorage.getItem('tm_theme'));}catch(e){}})();</script>
-<meta name=viewport content="width=device-width,initial-scale=1">
-<title>Token Meter</title>
-<link rel=icon type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='14' fill='%2307090c'/%3E%3Cpath fill='%23fff' d='M47.03 36.16v-7.58L10 10v8.32l28.7 13.97L10 46.44v8.14l37.03-18.4z'/%3E%3C/svg%3E">
-<meta name=theme-color content="#07090c">
-<style>
-:root{
- color-scheme:dark;
- /* == Fixed palette: identical in every theme; hue hex plus rgb channels for rgb(var(--x-rgb)/alpha) tints == */
- --white:#fff; --black:#000; --tint-rgb:255 255 255; --shade-rgb:0 0 0;
- --pink:#f08cae; --pink-rgb:240 140 174;
- --orange:#ffb457; --orange-rgb:255 180 87;
- --green:#66d990; --green-rgb:102 217 144;
- --red:#ff6f6f; --red-rgb:255 111 111;
- /* == Lines: tinted by the theme line hue == */
- --line:rgb(var(--line-rgb)/.09); --line2:rgb(var(--line-rgb)/.17); --line3:rgb(var(--line-rgb)/.24);
- /* == Semantic states: never themed == */
- --accent:var(--signal); --good:var(--green); --warn:var(--orange); --bad:var(--red);
- --bad-text:#ffaaaa; --bad-text-strong:#ffd0d0; --bad-deep-rgb:91 30 35; --bad-ink-rgb:42 23 24;
- /* == Data series that keep their meaning across themes == */
- --coord:var(--signal-mid); --c-cache-read:#66d990; --c-cache-write:#ffb457; --c-context:var(--fg); --c-deleted:#5c7d92;
- --chart-cost-fill:rgb(var(--c-cost-rgb)/.24); --chart-grid:rgb(var(--signal-rgb)/.16);
- --chart-tip:var(--bg-deep); --chart-tip-head:rgb(var(--signal-rgb)/.16); --chart-tip-line:rgb(var(--tint-rgb)/.42);
- /* == Ordered (Bayer 4x4) dither masks: 50% coverage in 2px cells; color comes from the masked fill == */
- --dither-50:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='4' height='4'%3E%3Crect width='2' height='2'/%3E%3Crect x='2' y='2' width='2' height='2'/%3E%3C/svg%3E");
- /* == Provider identity: one color per runtime for cards, Spend, badges, budgets, and model families == */
- --provider-claude:#e3825c; --provider-claude-rgb:227 130 92;
- --provider-codex:#6f9cff; --provider-codex-rgb:111 156 255;
- --provider-cursor:#3cc6c0; --provider-cursor-rgb:60 198 192;
- --provider-opencode:#ff8fb8; --provider-opencode-rgb:255 143 184;
- --provider-kiro:#e3cc5c; --provider-kiro-rgb:227 204 92; --provider-other:#8b96a3;
- --badge-neutral:#d5dce5; --badge-neutral-rgb:213 220 229;
- /* == Theme swatches for the Appearance picker == */
- --swatch-classic:linear-gradient(132deg,#00bceb,#7fdbf2 38%,#6d7bff 68%,#c7a7ff); --swatch-classic-bg:#07090c;
- --swatch-nebula:linear-gradient(132deg,#9d8bff,#ff7ad9 38%,#7ef3ff 68%,#64ffda); --swatch-nebula-bg:#07061a;
- --swatch-monolith:linear-gradient(132deg,#e4e7ee,#a7aebd 48%,#fff 82%,#ff6a3d); --swatch-monolith-bg:#09090a;
- --swatch-voltage:linear-gradient(132deg,#f5e63d,#ffd23f 34%,#ff3df2 66%,#2ee6ff); --swatch-voltage-bg:#0a0907;
- --swatch-phosphor:linear-gradient(132deg,#3dfc8f,#19d97a 40%,#c6ff4d 72%,#4dd2ff); --swatch-phosphor-bg:#040a06;
- --swatch-omarchy:linear-gradient(132deg,#7aa2f7,#bb9af7 40%,#7dcfff 72%,#ff9e64); --swatch-omarchy-bg:#14151d;
- --swatch-jadehorse:linear-gradient(132deg,#8bcbb1,#a7dfc5 40%,#96b7d0 72%,#c5cc91); --swatch-jadehorse-bg:#0c1a16;
- --swatch-ferrous:linear-gradient(132deg,#ff5a36,#ffa27a 38%,#ffb36b 66%,#5ee6d8); --swatch-ferrous-bg:#0f0705;
- --swatch-afterglow:linear-gradient(132deg,#ff5fa2,#ff8a5c 40%,#ffc775 70%,#8f7bff); --swatch-afterglow-bg:#0b0510;
- /* == Type: families, size scale (11px floor), weights == */
- --font-sans:-apple-system,BlinkMacSystemFont,"Segoe UI",Inter,system-ui,sans-serif; --font-mono:ui-monospace,"SF Mono",SFMono-Regular,Menlo,monospace;
- --font-display:"Tektur Local","Avenir Next Condensed",-apple-system,BlinkMacSystemFont,sans-serif;
- --fs-11:11px; --fs-12:12px; --fs-13:13px; --fs-14:14px; --fs-16:16px; --fs-18:18px; --fs-20:20px; --fs-22:22px; --fs-24:24px; --fs-28:28px; --fs-36:36px; --fs-44:44px; --fs-56:56px;
- --fs-hero-fluid:clamp(36px,4.2vw,54px); --fs-readout-xl:clamp(32px,3.4vw,44px); --fs-readout-lg:clamp(28px,3.2vw,40px);
- --fs-readout-md:clamp(18px,1.6vw,23px); --fs-readout-sm:clamp(16px,1.2vw,19px);
- --fw-medium:500; --fw-semibold:600; --fw-bold:700; --fw-heavy:800;
- /* == Shape: the corner scale itself is themed; pill and round stay fixed == */
- --radius-pill:999px; --radius-round:50%;
- --focus-ring:0 0 0 3px rgb(var(--signal-rgb)/.14);
- /* == Depth == */
- --tip-bg:linear-gradient(180deg,rgb(var(--bg-deep-rgb)/.98),rgb(var(--bg2-rgb)/.98)); --shadow-tip:0 16px 36px rgb(var(--shade-rgb)/.5);
- --shadow:0 1px 0 rgb(var(--tint-rgb)/.055),0 18px 48px rgb(var(--shade-rgb)/.36);
- --shadow-soft:0 1px 0 rgb(var(--tint-rgb)/.045),0 10px 28px rgb(var(--shade-rgb)/.22);
- --inset:inset 0 1px 0 rgb(var(--tint-rgb)/.045);
- /* == Spectrum system: shared atmosphere, cards, controls, active state; built only from theme tokens == */
- --spectrum-border:rgb(var(--signal-rgb)/.2);--spectrum-border-strong:rgb(var(--signal-hi-rgb)/.38);
- --spectrum-edge-light:rgb(var(--signal-pale-rgb)/.2);--spectrum-edge-hover:rgb(var(--signal-hi-rgb)/.52);
- --spectrum-page:radial-gradient(ellipse 72% 48% at 13% -9%,rgb(var(--signal-rgb)/calc(.26*var(--glow))),transparent 62%),radial-gradient(ellipse 56% 42% at 96% 2%,rgb(var(--aura-rgb)/calc(.17*var(--glow))),transparent 60%),radial-gradient(ellipse 44% 34% at 58% 38%,rgb(var(--flare-rgb)/calc(.07*var(--glow))),transparent 70%),radial-gradient(ellipse 56% 38% at 68% 105%,rgb(var(--signal-mid-rgb)/calc(.13*var(--glow))),transparent 68%),linear-gradient(155deg,var(--bg-deep) 0%,var(--bg-lift) 42%,var(--bg2) 68%,var(--bg) 100%);
- --spectrum-card:radial-gradient(ellipse 82% 90% at 102% -8%,rgb(var(--signal-hi-rgb)/calc(.1*var(--glow))),transparent 58%),radial-gradient(ellipse 74% 74% at -8% 108%,rgb(var(--aura-rgb)/calc(.08*var(--glow))),transparent 62%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.97),rgb(var(--panel-rgb)/.97) 55%,rgb(var(--bg2-rgb)/.98));
- --spectrum-control:radial-gradient(circle at 88% 0,rgb(var(--signal-hi-rgb)/calc(.08*var(--glow))),transparent 46%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg2-rgb)/.98));
- --spectrum-active:linear-gradient(132deg,var(--signal) 0%,var(--signal-mid) 48%,var(--signal-hi) 100%);
- --spectrum-active-hover:linear-gradient(132deg,color-mix(in srgb,var(--signal) 86%,var(--white)) 0%,color-mix(in srgb,var(--signal-mid) 86%,var(--white)) 46%,color-mix(in srgb,var(--signal-hi) 86%,var(--white)) 100%);
- --spectrum-foil:linear-gradient(90deg,transparent,var(--signal) 18%,var(--signal-hi) 40%,var(--flare) 60%,var(--aura) 80%,transparent);
- --spectrum-glow:0 0 0 1px rgb(var(--signal-hi-rgb)/.34),0 8px 26px rgb(var(--signal-rgb)/calc(.34*var(--glow))),inset 0 1px 0 rgb(var(--tint-rgb)/.38);
- --spectrum-ease:cubic-bezier(.16,1,.3,1);
- /* == Motion: strong curves; UI stays under 300ms, data explanation may run longer == */
- --ease-out:cubic-bezier(.23,1,.32,1); --ease-in-out:cubic-bezier(.77,0,.175,1);
- --dur-press:160ms; --dur-enter:320ms; --dur-data:480ms;
- --grain:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='180' height='180'%3E%3Cfilter id='g'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='.85' numOctaves='2' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 .6 0'/%3E%3C/filter%3E%3Crect width='180' height='180' filter='url(%23g)'/%3E%3C/svg%3E");
- --spectrum-shadow:0 1px 0 var(--spectrum-edge-light),0 16px 38px rgb(var(--shade-rgb)/.32),0 5px 16px rgb(var(--signal-rgb)/calc(.06*var(--glow)));
- --spectrum-depth-focus:0 1px 0 rgb(var(--signal-pale-rgb)/.22),0 20px 46px rgb(var(--shade-rgb)/.38),0 8px 28px rgb(var(--signal-rgb)/calc(.13*var(--glow)));
-  /* == Work insights: work-type, tier, effort, and outcome hues == */
-  --w1:#079bc2; --w2:#c17a01; --w3:#c36b95; --w4:#af851e; --w5:#9979cd; --w6:#d66555; --w7:#5f8adf; --w8:#05a386; --w-unclear:#56606d; --w-routine-2:#2a8fb4; --w-routine-3:#1d5f7a; --w-routine-4:#334050; --w-pending:#2c3541; --w-tier-light:#05a386; --w-tier-standard:#5f8adf; --w-tier-premium:#c17a01; --w-e1:#644493; --w-e2:#7858a9; --w-e3:#8d6dc0; --w-e4:#a282d7; --w-e5:#b798ee; --w-e6:#ccb0ff; --w-accepted:var(--good); --w-recovered:var(--warn); --w-ended:var(--bad); --w-single:var(--w-unclear);
-}
-/* == Themes: each block declares the same tokens; html[data-theme] selects one == */
-:root,[data-theme=classic]{
- --signal:#00bceb; --signal-rgb:0 188 235; --signal-mid:#1ba0e1; --signal-mid-rgb:27 160 225;
- --signal-hi:#7fdbf2; --signal-hi-rgb:127 219 242; --signal-pale:#dff8ff; --signal-pale-rgb:223 248 255; --signal-deep-rgb:14 54 67;
- --aura:#c7a7ff; --aura-rgb:199 167 255; --aura-pale:#d4c0ff; --aura-deep:#9d72f1; --aura-glow-rgb:183 140 255;
- --flare:#6d7bff; --flare-rgb:109 123 255;
- --bg-deep:#05070a; --bg-deep-rgb:5 7 10; --bg:#07090c; --bg-rgb:7 9 12; --bg-lift:#071824; --bg-lift-rgb:7 24 36;
- --bg2:#0d1117; --bg2-rgb:13 17 23; --panel:#111820; --panel-rgb:17 24 32; --panel2:#17212b; --panel2-rgb:23 33 43; --panel3:#202b36;
- --line-rgb:177 228 241;
- --fg:#f6f8fb; --soft:#cbd9e4; --soft-rgb:203 217 228; --dim:#a8b3c1; --faint:#8693a6;
- --on-accent:#062430; --on-accent-deep:#061018;
- --reason:#4ec6ee; --output:#7fdbf2; --retrieval:#19b3e6; --toolcall:#0aa4d4;
- --c-input:#00bceb; --c-output:#64d8ff; --c-cost:#c7a7ff; --c-cost-rgb:199 167 255;
- --chart-axis:#636d7b; --chart-label:#a8b3c1;
- --glow:.8;
- --page-texture:linear-gradient(rgb(var(--tint-rgb)/.03) 1px,transparent 1px),linear-gradient(90deg,rgb(var(--tint-rgb)/.022) 1px,transparent 1px);
- --page-texture-size:44px 44px;
- --radius-2xs:2px; --radius-xs:4px; --radius-sm:6px; --radius-md:8px; --radius-lg:12px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
- --ring-speed:60s;
- --title-glow:0 0 18px rgb(var(--signal-rgb)/.28);
- --grain-opacity:.05;
- --fx-front-rgb:53 202 238; --fx-back-rgb:103 74 180; --fx-edge-a-rgb:0 188 235; --fx-edge-b-rgb:77 139 214;
-}
-[data-theme=nebula]{
- --signal:#9d8bff; --signal-rgb:157 139 255; --signal-mid:#c77dff; --signal-mid-rgb:199 125 255;
- --signal-hi:#7ef3ff; --signal-hi-rgb:126 243 255; --signal-pale:#e6e0ff; --signal-pale-rgb:230 224 255; --signal-deep-rgb:38 26 92;
- --aura:#ff7ad9; --aura-rgb:255 122 217; --aura-pale:#ffc2ee; --aura-deep:#d24fb0; --aura-glow-rgb:214 92 255;
- --flare:#64ffda; --flare-rgb:100 255 218;
- --bg-deep:#040310; --bg-deep-rgb:4 3 16; --bg:#07061a; --bg-rgb:7 6 26; --bg-lift:#110c2e; --bg-lift-rgb:17 12 46;
- --bg2:#0c0a22; --bg2-rgb:12 10 34; --panel:#13102c; --panel-rgb:19 16 44; --panel2:#1b1739; --panel2-rgb:27 23 57; --panel3:#252046;
- --line-rgb:190 180 255;
- --fg:#f4f2ff; --soft:#d3cdf2; --soft-rgb:211 205 242; --dim:#afa9d4; --faint:#9089bd;
- --on-accent:#0d0726; --on-accent-deep:#07031a;
- --reason:#8fd8ff; --output:#c9bcff; --retrieval:#6fb6ff; --toolcall:#8a7dff;
- --c-input:#7ef3ff; --c-output:#b6a6ff; --c-cost:#ff8ad8; --c-cost-rgb:255 138 216;
- --chart-axis:#6c6890; --chart-label:#afa9d4;
- --glow:1;
- --page-texture:radial-gradient(circle at 20% 30%,rgb(var(--tint-rgb)/.07) 0 1px,transparent 1.6px),radial-gradient(circle at 70% 80%,rgb(var(--signal-hi-rgb)/.06) 0 1px,transparent 1.6px);
- --page-texture-size:97px 89px,61px 53px;
- --radius-2xs:2px; --radius-xs:4px; --radius-sm:6px; --radius-md:10px; --radius-lg:14px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
- --ring-speed:48s;
- --title-glow:0 0 22px rgb(var(--signal-mid-rgb)/.42);
- --grain-opacity:.06;
- --fx-front-rgb:255 122 217; --fx-back-rgb:157 139 255; --fx-edge-a-rgb:199 125 255; --fx-edge-b-rgb:255 122 217;
-}
-[data-theme=monolith]{
- --signal:#e4e7ee; --signal-rgb:228 231 238; --signal-mid:#a7aebd; --signal-mid-rgb:167 174 189;
- --signal-hi:#ffffff; --signal-hi-rgb:255 255 255; --signal-pale:#f4f5f8; --signal-pale-rgb:244 245 248; --signal-deep-rgb:44 46 54;
- --aura:#a9b8ff; --aura-rgb:169 184 255; --aura-pale:#d3dbff; --aura-deep:#7d8de0; --aura-glow-rgb:150 165 240;
- --flare:#ff6a3d; --flare-rgb:255 106 61;
- --bg-deep:#050506; --bg-deep-rgb:5 5 6; --bg:#09090a; --bg-rgb:9 9 10; --bg-lift:#121214; --bg-lift-rgb:18 18 20;
- --bg2:#0f0f11; --bg2-rgb:15 15 17; --panel:#151517; --panel-rgb:21 21 23; --panel2:#1c1c1f; --panel2-rgb:28 28 31; --panel3:#26262a;
- --line-rgb:232 234 240;
- --fg:#f5f5f7; --soft:#d5d6db; --soft-rgb:213 214 219; --dim:#abadb5; --faint:#909299;
- --on-accent:#0a0a0c; --on-accent-deep:#050506;
- --reason:#c3cad8; --output:#a9b8ff; --retrieval:#dfe3ec; --toolcall:#8e95a6;
- --c-input:#e4e7ee; --c-output:#a9b8ff; --c-cost:#c7a7ff; --c-cost-rgb:199 167 255;
- --chart-axis:#5f6068; --chart-label:#abadb5;
- --glow:.3;
- --page-texture:radial-gradient(circle,rgb(var(--tint-rgb)/.055) 0 .8px,transparent 1.2px);
- --page-texture-size:6px 6px;
- --radius-2xs:1px; --radius-xs:2px; --radius-sm:3px; --radius-md:4px; --radius-lg:6px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
- --ring-speed:24s;
- --title-glow:0 0 0 transparent;
- --grain-opacity:.07;
- --fx-front-rgb:244 245 248; --fx-back-rgb:169 184 255; --fx-edge-a-rgb:228 231 238; --fx-edge-b-rgb:167 174 189;
-}
-[data-theme=voltage]{
- --signal:#f5e63d; --signal-rgb:245 230 61; --signal-mid:#ffd23f; --signal-mid-rgb:255 210 63;
- --signal-hi:#fff27d; --signal-hi-rgb:255 242 125; --signal-pale:#fffbd6; --signal-pale-rgb:255 251 214; --signal-deep-rgb:64 58 8;
- --aura:#2ee6ff; --aura-rgb:46 230 255; --aura-pale:#a8f5ff; --aura-deep:#12b5cc; --aura-glow-rgb:46 200 255;
- --flare:#ff3df2; --flare-rgb:255 61 242;
- --bg-deep:#050504; --bg-deep-rgb:5 5 4; --bg:#0a0907; --bg-rgb:10 9 7; --bg-lift:#15130b; --bg-lift-rgb:21 19 11;
- --bg2:#100f0b; --bg2-rgb:16 15 11; --panel:#16150f; --panel-rgb:22 21 15; --panel2:#1e1c14; --panel2-rgb:30 28 20; --panel3:#28261b;
- --line-rgb:255 244 150;
- --fg:#f8f6ea; --soft:#ddd9c4; --soft-rgb:221 217 196; --dim:#b6b19a; --faint:#99947d;
- --on-accent:#141200; --on-accent-deep:#0a0900;
- --reason:#fff27d; --output:#2ee6ff; --retrieval:#ffe68a; --toolcall:#c8bb2a;
- --c-input:#f5e63d; --c-output:#2ee6ff; --c-cost:#ff6fd8; --c-cost-rgb:255 111 216;
- --chart-axis:#6c6956; --chart-label:#b6b19a;
- --glow:.85;
- --page-texture:repeating-linear-gradient(0deg,rgb(var(--tint-rgb)/.026) 0 1px,transparent 1px 3px);
- --page-texture-size:auto;
- --radius-2xs:0; --radius-xs:1px; --radius-sm:2px; --radius-md:2px; --radius-lg:3px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
- --ring-speed:18s;
- --title-glow:0 0 20px rgb(var(--signal-rgb)/.5);
- --grain-opacity:.05;
- --fx-front-rgb:245 230 61; --fx-back-rgb:46 230 255; --fx-edge-a-rgb:245 230 61; --fx-edge-b-rgb:46 230 255;
-}
-[data-theme=phosphor]{
- --signal:#3dfc8f; --signal-rgb:61 252 143; --signal-mid:#19d97a; --signal-mid-rgb:25 217 122;
- --signal-hi:#b8ffd2; --signal-hi-rgb:184 255 210; --signal-pale:#e3fff0; --signal-pale-rgb:227 255 240; --signal-deep-rgb:6 60 32;
- --aura:#c6ff4d; --aura-rgb:198 255 77; --aura-pale:#e6ffb0; --aura-deep:#8fd11f; --aura-glow-rgb:120 255 160;
- --flare:#4dd2ff; --flare-rgb:77 210 255;
- --bg-deep:#020604; --bg-deep-rgb:2 6 4; --bg:#040a06; --bg-rgb:4 10 6; --bg-lift:#08160e; --bg-lift-rgb:8 22 14;
- --bg2:#07100a; --bg2-rgb:7 16 10; --panel:#0b170f; --panel-rgb:11 23 15; --panel2:#102016; --panel2-rgb:16 32 22; --panel3:#172b1e;
- --line-rgb:140 255 190;
- --fg:#effff4; --soft:#c9e8d4; --soft-rgb:201 232 212; --dim:#a2c4ae; --faint:#86aa93;
- --on-accent:#021a0c; --on-accent-deep:#010d06;
- --reason:#b8ffd2; --output:#c6ff4d; --retrieval:#7dffb6; --toolcall:#19d97a;
- --c-input:#3dfc8f; --c-output:#c6ff4d; --c-cost:#c7a7ff; --c-cost-rgb:199 167 255;
- --chart-axis:#4f6b59; --chart-label:#a2c4ae;
- --glow:.9;
- --page-texture:repeating-linear-gradient(90deg,rgb(var(--signal-rgb)/.026) 0 1px,transparent 1px 14px);
- --page-texture-size:auto;
- --radius-2xs:1px; --radius-xs:2px; --radius-sm:4px; --radius-md:4px; --radius-lg:6px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
- --ring-speed:30s;
- --title-glow:0 0 22px rgb(var(--signal-rgb)/.45);
- --grain-opacity:.06;
- --fx-front-rgb:61 252 143; --fx-back-rgb:25 120 70; --fx-edge-a-rgb:61 252 143; --fx-edge-b-rgb:198 255 77;
-}
-[data-theme=omarchy]{
- --signal:#7aa2f7; --signal-rgb:122 162 247; --signal-mid:#7dcfff; --signal-mid-rgb:125 207 255;
- --signal-hi:#bb9af7; --signal-hi-rgb:187 154 247; --signal-pale:#d6dbff; --signal-pale-rgb:214 219 255; --signal-deep-rgb:30 44 92;
- --aura:#ff9e64; --aura-rgb:255 158 100; --aura-pale:#ffc9a3; --aura-deep:#d96f3f; --aura-glow-rgb:255 158 100;
- --flare:#f7768e; --flare-rgb:247 118 142;
- --bg-deep:#0d0e14; --bg-deep-rgb:13 14 20; --bg:#14151d; --bg-rgb:20 21 29; --bg-lift:#1a1b26; --bg-lift-rgb:26 27 38;
- --bg2:#1a1b26; --bg2-rgb:26 27 38; --panel:#1b1e2b; --panel-rgb:27 30 43; --panel2:#202334; --panel2-rgb:32 35 52; --panel3:#24283b;
- --line-rgb:187 154 247;
- --fg:#c0caf5; --soft:#b4bee6; --soft-rgb:180 190 230; --dim:#a9b1d6; --faint:#9099c0;
- --on-accent:#10121c; --on-accent-deep:#07080f;
- --reason:#7aa2f7; --output:#7dcfff; --retrieval:#bb9af7; --toolcall:#2ac3de;
- --c-input:#7aa2f7; --c-output:#7dcfff; --c-cost:#bb9af7; --c-cost-rgb:187 154 247;
- --chart-axis:#565f89; --chart-label:#a9b1d6;
- --glow:.9;
- --page-texture:linear-gradient(rgb(var(--tint-rgb)/.022) 1px,transparent 1px),linear-gradient(90deg,rgb(var(--tint-rgb)/.018) 1px,transparent 1px);
- --page-texture-size:34px 34px;
- --radius-2xs:2px; --radius-xs:4px; --radius-sm:8px; --radius-md:10px; --radius-lg:14px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);
- --ring-speed:40s;
- --title-glow:0 0 20px rgb(var(--signal-rgb)/.4);
- --grain-opacity:.05;
- --fx-front-rgb:122 162 247; --fx-back-rgb:187 154 247; --fx-edge-a-rgb:122 162 247; --fx-edge-b-rgb:125 207 255;
-}
-[data-theme=jadehorse]{
- --signal:#8bcbb1; --signal-rgb:139 203 177; --signal-mid:#86c7c5; --signal-mid-rgb:134 199 197;
- --signal-hi:#a7dfc5; --signal-hi-rgb:167 223 197; --signal-pale:#dff3ea; --signal-pale-rgb:223 243 234; --signal-deep-rgb:23 52 43;
- --aura:#96b7d0; --aura-rgb:150 183 208; --aura-pale:#c9dcea; --aura-deep:#6b93b3; --aura-glow-rgb:150 183 208;
- --flare:#c5cc91; --flare-rgb:197 204 145;
- --bg-deep:#08120f; --bg-deep-rgb:8 18 15; --bg:#0c1a16; --bg-rgb:12 26 22; --bg-lift:#152e27; --bg-lift-rgb:21 46 39;
- --bg2:#10211c; --bg2-rgb:16 33 28; --panel:#132720; --panel-rgb:19 39 32; --panel2:#162b24; --panel2-rgb:22 43 36; --panel3:#182f28;
- --line-rgb:186 214 199;
- --fg:#dfede5; --soft:#c3d8cc; --soft-rgb:195 216 204; --dim:#a9c3b5; --faint:#93b0a2;
- --on-accent:#081712; --on-accent-deep:#030b08;
- --reason:#86c7c5; --output:#a7dfc5; --retrieval:#b7a1c8; --toolcall:#96b7d0;
- --c-input:#8bcbb1; --c-output:#86c7c5; --c-cost:#b7a1c8; --c-cost-rgb:183 161 200;
- --chart-axis:#5b7a6c; --chart-label:#a9c3b5;
- --glow:.85;
- --page-texture:linear-gradient(rgb(var(--tint-rgb)/.024) 1px,transparent 1px),linear-gradient(90deg,rgb(var(--tint-rgb)/.018) 1px,transparent 1px);
- --page-texture-size:36px 36px;
- --radius-2xs:2px; --radius-xs:4px; --radius-sm:8px; --radius-md:10px; --radius-lg:14px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,var(--aura) 75%,var(--signal);
- --ring-speed:44s;
- --title-glow:0 0 20px rgb(var(--signal-rgb)/.4);
- --grain-opacity:.05;
- --fx-front-rgb:139 203 177; --fx-back-rgb:43 92 76; --fx-edge-a-rgb:139 203 177; --fx-edge-b-rgb:197 204 145;
-}
-[data-theme=ferrous]{
- --signal:#ff5a36; --signal-rgb:255 90 54; --signal-mid:#e8481f; --signal-mid-rgb:232 72 31;
- --signal-hi:#ffa27a; --signal-hi-rgb:255 162 122; --signal-pale:#ffe0d2; --signal-pale-rgb:255 224 210; --signal-deep-rgb:74 22 10;
- --aura:#ffb36b; --aura-rgb:255 179 107; --aura-pale:#ffd9ad; --aura-deep:#d9822b; --aura-glow-rgb:255 150 70;
- --flare:#5ee6d8; --flare-rgb:94 230 216;
- --bg-deep:#080403; --bg-deep-rgb:8 4 3; --bg:#0f0705; --bg-rgb:15 7 5; --bg-lift:#2a110a; --bg-lift-rgb:42 17 10;
- --bg2:#150b08; --bg2-rgb:21 11 8; --panel:#1c100c; --panel-rgb:28 16 12; --panel2:#271713; --panel2-rgb:39 23 19; --panel3:#33201a;
- --line-rgb:255 150 110;
- --fg:#fff3ee; --soft:#efd3c6; --soft-rgb:239 211 198; --dim:#c9aa9d; --faint:#ae8f83;
- --on-accent:#1c0602; --on-accent-deep:#0d0301;
- --reason:#ffa27a; --output:#ffb36b; --retrieval:#5ee6d8; --toolcall:#e8481f;
- --c-input:#ff5a36; --c-output:#ffb36b; --c-cost:#5ee6d8; --c-cost-rgb:94 230 216;
- --chart-axis:#7a5e54; --chart-label:#c9aa9d;
- --glow:1;
- --page-texture:repeating-linear-gradient(135deg,rgb(var(--signal-rgb)/.035) 0 1px,transparent 1px 10px);
- --page-texture-size:auto;
- --radius-2xs:1px; --radius-xs:2px; --radius-sm:3px; --radius-md:4px; --radius-lg:6px;
- --ring:var(--signal),rgb(var(--signal-rgb)/.35) 20%,var(--aura) 40%,rgb(var(--signal-rgb)/.35) 60%,var(--flare) 80%,var(--signal);
- --ring-speed:28s;
- --title-glow:0 0 22px rgb(var(--signal-rgb)/.5);
- --grain-opacity:.07;
- --fx-front-rgb:255 90 54; --fx-back-rgb:150 40 20; --fx-edge-a-rgb:255 90 54; --fx-edge-b-rgb:255 179 107;
-}
-[data-theme=afterglow]{
- --signal:#ff5fa2; --signal-rgb:255 95 162; --signal-mid:#ff8a5c; --signal-mid-rgb:255 138 92;
- --signal-hi:#ffc775; --signal-hi-rgb:255 199 117; --signal-pale:#ffe3f0; --signal-pale-rgb:255 227 240; --signal-deep-rgb:72 14 46;
- --aura:#8f7bff; --aura-rgb:143 123 255; --aura-pale:#c9bfff; --aura-deep:#6a55e0; --aura-glow-rgb:143 110 255;
- --flare:#3fe3ff; --flare-rgb:63 227 255;
- --bg-deep:#06020a; --bg-deep-rgb:6 2 10; --bg:#0b0510; --bg-rgb:11 5 16; --bg-lift:#240a26; --bg-lift-rgb:36 10 38;
- --bg2:#12081a; --bg2-rgb:18 8 26; --panel:#190d22; --panel-rgb:25 13 34; --panel2:#22122e; --panel2-rgb:34 18 46; --panel3:#2e1a3b;
- --line-rgb:255 160 210;
- --fg:#fff1f8; --soft:#efd0e2; --soft-rgb:239 208 226; --dim:#cbabc2; --faint:#b08fa8;
- --on-accent:#240418; --on-accent-deep:#12020c;
- --reason:#ffc775; --output:#ff8a5c; --retrieval:#c9bfff; --toolcall:#ff5fa2;
- --c-input:#ff5fa2; --c-output:#ffc775; --c-cost:#8f7bff; --c-cost-rgb:143 123 255;
- --chart-axis:#7a5f78; --chart-label:#cbabc2;
- --glow:1;
- --page-texture:linear-gradient(rgb(var(--signal-rgb)/.045) 1px,transparent 1px);
- --page-texture-size:100% 28px;
- --radius-2xs:3px; --radius-xs:6px; --radius-sm:8px; --radius-md:12px; --radius-lg:18px;
- --ring:var(--signal),var(--signal-mid) 25%,var(--signal-hi) 45%,var(--aura) 70%,var(--flare) 85%,var(--signal);
- --ring-speed:32s;
- --title-glow:0 0 22px rgb(var(--signal-rgb)/.45);
- --grain-opacity:.05;
- --fx-front-rgb:255 95 162; --fx-back-rgb:143 123 255; --fx-edge-a-rgb:255 95 162; --fx-edge-b-rgb:255 199 117;
-}
-*{box-sizing:border-box}
-html,body{margin:0}
-body{min-height:100vh;background:
- linear-gradient(180deg,var(--bg-deep) 0%,var(--bg2) 42%,var(--bg) 100%);
- color:var(--fg);font:var(--fs-14)/1.5 var(--font-sans);-webkit-font-smoothing:antialiased}
-body:before{content:"";position:fixed;inset:0;z-index:-1;pointer-events:none;background-image:var(--page-texture);background-size:var(--page-texture-size);mask-image:linear-gradient(180deg,rgb(var(--shade-rgb)/.9),rgb(var(--shade-rgb)/.28) 52%,transparent)}
-html{scrollbar-color:rgb(var(--signal-rgb)/.32) transparent}
-::selection{background:rgb(var(--signal-rgb)/.34);color:var(--fg)}
-::view-transition-old(root),::view-transition-new(root){animation-duration:.42s;animation-timing-function:var(--spectrum-ease)}
-.mono{font-family:var(--font-mono);font-variant-numeric:tabular-nums}
-.wrap{max-width:1320px;margin:0 auto;padding:18px 24px 64px}
-.top{position:sticky;top:0;z-index:20;display:flex;align-items:center;gap:14px;margin:0 0 18px;padding:10px 0 12px;background:linear-gradient(180deg,rgb(var(--bg-rgb)/.98),rgb(var(--bg-rgb)/.82));backdrop-filter:blur(18px);border-bottom:1px solid var(--line)}
-.brand{display:flex;align-items:center;gap:8px;font-weight:var(--fw-heavy);font-size:var(--fs-14);white-space:nowrap}
-.logo{width:50px;height:30px;display:flex;flex:0 0 auto;align-items:center;justify-content:flex-start}
-.logo img{display:block;width:50px;height:auto;max-height:30px;object-fit:contain}
-.tabs,.seg{display:flex;gap:3px;background:rgb(var(--tint-rgb)/.045);border:1px solid var(--line);border-radius:var(--radius-md);padding:3px;box-shadow:var(--inset)}
-.tab,.seg button{border:0;background:transparent;color:var(--dim);border-radius:var(--radius-sm);padding:6px 12px;font:inherit;font-size:var(--fs-13);font-weight:var(--fw-bold);text-decoration:none;cursor:pointer;transition:background .16s,border-color .16s,color .16s,transform .16s}
-.tab:hover,.seg button:hover{background:rgb(var(--tint-rgb)/.045);color:var(--fg)}
-.tab.on,.seg button.on{background:linear-gradient(180deg,rgb(var(--tint-rgb)/.11),rgb(var(--tint-rgb)/.055));color:var(--fg);box-shadow:0 1px 2px rgb(var(--shade-rgb)/.22),var(--inset)}
-.top .tabs{min-width:0;overflow-x:auto;scrollbar-width:none}
-.top .tabs::-webkit-scrollbar{display:none}
-.spacer{flex:1}
-.notify,.pill{display:inline-flex;align-items:center;gap:6px;border:1px solid var(--line);background:rgb(var(--panel-rgb)/.86);border-radius:var(--radius-pill);padding:6px 10px;font-size:var(--fs-12);color:var(--dim);white-space:nowrap;box-shadow:var(--inset)}
-.notify{cursor:pointer;user-select:none}
-.sw{width:32px;height:18px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.13);position:relative;box-shadow:inset 0 0 0 1px rgb(var(--tint-rgb)/.08)}
-.sw:after{content:"";position:absolute;top:2px;left:2px;width:14px;height:14px;border-radius:var(--radius-round);background:var(--white);transition:left .16s;box-shadow:0 2px 6px rgb(var(--shade-rgb)/.32)}
-.notify.on .sw{background:var(--good)}
-.notify.on .sw:after{left:16px}
-.notify.hasnew{border-color:rgb(var(--signal-rgb)/.52);box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.12),var(--inset)}
-.view{display:none}
-.view.on{display:block}
-.session-panel{display:none}
-.session-panel.on{display:block}
-.card{background:linear-gradient(180deg,rgb(var(--panel-rgb)/.95),rgb(var(--bg2-rgb)/.96));border:1px solid var(--line);border-radius:var(--radius-md);box-shadow:var(--shadow);position:relative;min-width:0}
-.card:hover{border-color:rgb(var(--tint-rgb)/.12)}
-.pad{padding:18px}
-.label{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.section-h{display:flex;align-items:center;gap:10px;margin:24px 0 10px}
-.section-h h2{font-size:var(--fs-14);margin:0;font-weight:var(--fw-heavy)}
-.section-h .hint{font-size:var(--fs-12);color:var(--faint)}
-.sessionhead{display:flex;align-items:center;gap:8px;margin-bottom:10px;min-width:0}
-.sessionStart{display:grid;grid-template-columns:max-content minmax(0,1fr);gap:8px;align-items:baseline;margin-bottom:12px;padding:8px 10px;border:1px solid var(--line);border-left:3px solid var(--accent);border-radius:var(--radius-md);background:rgb(var(--signal-rgb)/.055);min-width:0}
-.sessionStart[hidden]{display:none}
-.sessionStart span{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;white-space:nowrap}
-.sessionStart strong{font-size:var(--fs-13);font-weight:var(--fw-semibold);line-height:1.4;overflow-wrap:anywhere}
-.repo,.sessid{border:1px solid var(--line);background:rgb(var(--panel-rgb)/.76);border-radius:var(--radius-md);padding:6px 10px;font-size:var(--fs-12);min-width:0;box-shadow:var(--inset)}
-.repo{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.sessid{color:var(--dim);max-width:360px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.sessionDesktopLink{display:inline-flex;align-items:center;justify-content:center;text-decoration:none;white-space:nowrap}
-.sessionDesktopLink[hidden]{display:none}
-.currentSessionSlot{position:relative;display:flex;min-width:0}
-.currentSessionSlot>.currentSessionCard{flex:1 1 auto}
-.currentSessionSlot[data-desktop] .currentSessionTop{padding-right:36px}
-.currentSessionDesktop{position:absolute;top:14px;right:14px;z-index:2;display:inline-flex;align-items:center;justify-content:center;width:26px;height:26px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.62);color:var(--dim);transition:color .16s,border-color .16s,background .16s}
-.currentSessionDesktop:hover{color:var(--fg);border-color:var(--line3);background:rgb(var(--tint-rgb)/.07)}
-.currentSessionDesktop:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
-.currentSessionDesktop svg{width:13px;height:13px;fill:none;stroke:currentColor;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round}
-.sessionDelete{border:1px solid rgb(var(--red-rgb)/.36);background:rgb(var(--red-rgb)/.07);border-radius:var(--radius-md);color:var(--bad-text);font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);padding:6px 10px;cursor:pointer;box-shadow:var(--inset);white-space:nowrap}
-.sessionDelete:hover:not(:disabled){border-color:rgb(var(--red-rgb)/.68);background:rgb(var(--red-rgb)/.13);color:var(--bad-text-strong)}
-.sessionDelete:disabled{opacity:.42;cursor:not-allowed}
-.sessionDelete[hidden]{display:none}
-.sessionDeleteIcon{display:inline-grid;place-items:center;width:28px;height:28px;padding:0}
-.sessionDeleteIcon svg{width:15px;height:15px;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
-.smetrics .sessionDelete{font-size:var(--fs-11);padding:4px 6px;margin-top:4px}
-.sessionModelAssign{border:1px solid rgb(var(--signal-rgb)/.42);background:rgb(var(--signal-rgb)/.08);border-radius:var(--radius-md);color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);padding:4px 6px;cursor:pointer;box-shadow:var(--inset);white-space:nowrap;margin-top:4px}
-.sessionModelAssign:hover:not(:disabled){border-color:rgb(var(--signal-rgb)/.7);background:rgb(var(--signal-rgb)/.15);color:var(--fg)}
-.sessionModelAssign:disabled{opacity:.42;cursor:not-allowed}
-.previewRunMeta>.sessionModelAssign{font-size:var(--fs-12);padding:6px 10px;margin-top:0}
-.hero{display:grid;grid-template-columns:minmax(410px,.86fr) minmax(620px,1.14fr);gap:12px;align-items:start}
-.costcard{overflow:hidden;align-self:start;min-height:238px;padding:16px;display:flex;flex-direction:column;justify-content:flex-start;background:
- linear-gradient(180deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98)),
- linear-gradient(90deg,rgb(var(--signal-rgb)/.16),rgb(var(--signal-mid-rgb)/.06));}
-.costcard:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--signal),var(--signal-mid),rgb(var(--signal-hi-rgb)/.72),transparent)}
-.costcard:after{content:"";position:absolute;inset:auto 18px 18px auto;width:32%;height:1px;background:linear-gradient(90deg,transparent,rgb(var(--tint-rgb)/.24));opacity:.55}
-.meter{font-size:var(--fs-56);font-weight:var(--fw-heavy);line-height:1.02;margin-top:8px;background:linear-gradient(90deg,var(--white),var(--signal-hi) 70%,var(--signal-pale));-webkit-background-clip:text;background-clip:text;color:transparent}
-.costcard .meter{font-size:var(--fs-56);margin-top:4px}
-.costcard .subline{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.costtip{display:none;position:absolute;z-index:8;right:14px;top:78px;width:min(390px,calc(100% - 28px));border:1px solid rgb(var(--signal-rgb)/.48);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--bg-deep-rgb)/.98),rgb(var(--panel-rgb)/.98));box-shadow:0 18px 44px rgb(var(--shade-rgb)/.48);padding:10px 10px;color:var(--dim);font-size:var(--fs-12);line-height:1.35}
-.costcard:hover .costtip,.costcard:focus-within .costtip{display:block}
-.costtip .h{font-weight:var(--fw-heavy);color:var(--fg);margin-bottom:6px}
-.costtip .r{display:grid;grid-template-columns:90px minmax(0,1fr) auto;gap:8px;align-items:baseline;padding:3px 0;border-top:1px solid rgb(var(--tint-rgb)/.06)}
-.costtip .r:first-of-type{border-top:0}
-.costtip .name{color:var(--fg);font-weight:var(--fw-bold)}
-.costtip .formula{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.costtip .amt{color:var(--fg);font-weight:var(--fw-heavy)}
-.costtip .total{margin-top:6px;padding-top:6px;border-top:1px solid var(--line2);display:flex;justify-content:space-between;gap:10px;color:var(--fg);font-weight:var(--fw-heavy)}
-.costtip .note{margin-top:4px;color:var(--faint);font-size:var(--fs-11)}
-.costmeta{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;margin-top:14px}
-.costmeta>div{border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.035);padding:8px 10px;box-shadow:var(--inset);min-width:0}
-.costmeta .v{font-size:var(--fs-13);font-weight:var(--fw-heavy);margin-top:3px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.costmeta .sm{font-size:var(--fs-12);color:var(--faint)}
-.costsplit{margin-top:14px;padding-top:12px;border-top:1px solid var(--line);min-width:0}
-.costsplit .splithead{display:flex;align-items:baseline;gap:8px;margin-bottom:8px}
-.costsplit .splithead .hint{font-size:var(--fs-12);color:var(--faint)}
-.costsplit .bar{height:26px}
-.costsplit .legend{gap:10px;margin-top:8px}
-.meter.alert{background:none;color:var(--bad)}
-.subline{margin-top:10px;color:var(--dim);font-size:var(--fs-13)}
-.subline b{color:var(--fg)}
-.frozen{display:none;margin-top:10px;font-size:var(--fs-12);color:var(--warn);font-weight:var(--fw-bold)}
-.frozen.on{display:block}
-.statgrid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}
-.hero>.statgrid{grid-template-columns:repeat(2,minmax(0,1fr))}
-.usageDetails{margin-top:12px;border:1px solid var(--line2);border-radius:var(--radius-lg);background:rgb(var(--tint-rgb)/.018);box-shadow:var(--shadow-soft);overflow:hidden}
-.usageDetails>summary{display:flex;align-items:baseline;gap:10px;padding:12px 14px;cursor:pointer;font-weight:var(--fw-heavy);list-style-position:inside}
-.usageDetails>summary:hover{background:rgb(var(--tint-rgb)/.025)}
-.usageDetailsBody{padding:0 14px 16px;border-top:1px solid var(--line)}
-.usageSplit{margin-top:14px}
-.usageSplit .splithead{display:flex;align-items:baseline;gap:8px;margin-bottom:8px}
-.usageSplit .bar{height:26px}
-.usageSplit .legend{gap:10px;margin-top:8px}
-.usageDetailGrid{margin-top:10px}
-.stat{background:linear-gradient(180deg,rgb(var(--tint-rgb)/.055),rgb(var(--tint-rgb)/.025));border:1px solid var(--line);border-radius:var(--radius-md);padding:12px 14px;box-shadow:var(--shadow-soft);min-width:0}
-.stat .v{font-size:var(--fs-24);font-weight:var(--fw-heavy);margin-top:4px;overflow:hidden;text-overflow:ellipsis}
-.stat .sm{font-size:var(--fs-12);color:var(--faint)}
-.overview{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px;position:relative;z-index:2}
-.ov{padding:14px 14px;overflow:visible;min-height:92px;min-width:0}
-.ov:hover,.ov:focus-within{z-index:24}
-.ov:before{content:"";position:absolute;left:14px;right:14px;top:0;height:2px;background:linear-gradient(90deg,var(--signal),transparent);opacity:.78}
-.ov .v{font-size:var(--fs-22);font-weight:var(--fw-heavy);margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.ov.time .v{font-size:var(--fs-13);line-height:1.35;letter-spacing:0;white-space:normal}
-.ov .sm{font-size:var(--fs-12);color:var(--dim);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.banner{display:none;background:linear-gradient(180deg,rgb(var(--bad-deep-rgb)/.72),rgb(var(--bad-ink-rgb)/.86));border:1px solid rgb(var(--red-rgb)/.38);color:var(--bad-text-strong);padding:10px 14px;border-radius:var(--radius-md);margin:0 0 14px;font-size:var(--fs-13);font-weight:var(--fw-bold);box-shadow:var(--shadow-soft);align-items:center;gap:12px;flex-wrap:wrap}
-.banner.on{display:flex}
-.banner .msg{flex:1 1 280px;min-width:0}
-.budgetadd{display:none;align-items:center;gap:8px;flex-wrap:wrap;color:var(--dim);font-weight:var(--fw-semibold)}
-.banner.budget .budgetadd{display:inline-flex}
-.budgetadd label{display:flex;align-items:center;gap:6px}
-.budgetadd input{width:78px;background:rgb(var(--tint-rgb)/.07);border:1px solid rgb(var(--tint-rgb)/.2);color:var(--fg);border-radius:var(--radius-md);padding:6px 8px;font:inherit}
-.budgetadd input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.bar{display:flex;height:32px;border-radius:var(--radius-md);overflow:hidden;background:rgb(var(--tint-rgb)/.04);border:1px solid var(--line);box-shadow:inset 0 1px 10px rgb(var(--shade-rgb)/.22)}
-.bar span{display:flex;align-items:center;justify-content:center;font-size:var(--fs-11);color:var(--white);font-weight:var(--fw-heavy);min-width:0;transition:width .35s ease;white-space:nowrap}
-#sembar span{color:var(--bg)}
-.legend{display:flex;gap:14px;margin-top:10px;flex-wrap:wrap;font-size:var(--fs-12);color:var(--dim)}
-.dot{width:9px;height:9px;border-radius:var(--radius-xs);display:inline-block;margin-right:6px;vertical-align:middle}
-.fieldtip{position:relative;display:inline-flex;align-items:center;cursor:help;outline:none}
-.currentSessionCard.fieldtip{display:grid}
-.fieldtip:focus-visible{color:var(--fg)}
-#fieldtip-popup{position:fixed;left:0;top:0;z-index:1000;box-sizing:border-box;width:min(320px,calc(100vw - 24px));pointer-events:none;border:1px solid rgb(var(--signal-rgb)/.42);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--bg-deep-rgb)/.98),rgb(var(--panel-rgb)/.98));box-shadow:0 14px 32px rgb(var(--shade-rgb)/.46);padding:8px 10px;color:var(--dim);font-size:var(--fs-12);line-height:1.35;font-weight:var(--fw-medium);overflow-wrap:anywhere}
-#fieldtip-popup[hidden]{display:none}
-@keyframes enter{from{opacity:.3;transform:translateY(3px)}to{opacity:1;transform:none}}
-.chartbar{display:flex;align-items:center;gap:12px;margin-bottom:10px;flex-wrap:wrap}
-.chartbar .label{margin-right:auto}
-.chartbar .seg{flex-wrap:wrap}
-.chartwrap{position:relative}
-.chart{height:252px;width:100%;display:block;background:rgb(var(--tint-rgb)/.025);border:1px solid var(--line);border-radius:var(--radius-md)}
-.chart text{user-select:none}
-.charttip{z-index:4;display:none;min-width:238px;overflow:hidden;font:var(--fs-12)/1.35 var(--font-mono)}
-.charttip .h{padding:6px 10px;background:rgb(var(--signal-rgb)/.16);font-weight:var(--fw-heavy);color:var(--fg)}
-.charttip .r{display:flex;justify-content:space-between;gap:16px;padding:3px 10px}
-.charttip .prompt{display:block;padding:6px 10px;border-top:1px solid rgb(var(--tint-rgb)/.08);max-width:360px}
-.charttip .prompt span{display:block;color:var(--chart-label);margin-bottom:2px}
-.charttip .prompt b{display:block;color:var(--fg);font-weight:var(--fw-semibold);white-space:normal}
-.charttip .in,.charttip .fresh{color:var(--c-input)}
-.charttip .out{color:var(--c-output)}
-.charttip .cacheRead{color:var(--c-cache-read)}
-.charttip .cacheWrite{color:var(--c-cache-write)}
-.charttip .cost{color:var(--c-cost)}
-.charttip .context{color:var(--c-context)}
-.charttip .tools{color:var(--toolcall)}
-.mini{height:8px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.045);overflow:hidden;margin:10px 0 4px;border:1px solid var(--line)}
-.mini>i{display:block;height:100%;border-radius:var(--radius-xs);transition:width .35s ease}
-.tbl{width:100%;border-collapse:collapse;font-size:var(--fs-13)}
-.tbl th{text-align:left;color:var(--faint);font-weight:var(--fw-heavy);font-size:var(--fs-11);text-transform:uppercase;padding:8px;border-bottom:1px solid var(--line);background:rgb(var(--tint-rgb)/.02)}
-.tbl td{padding:8px 8px;border-bottom:1px solid rgb(var(--tint-rgb)/.055);vertical-align:top}
-.tbl tr:hover td{background:rgb(var(--tint-rgb)/.025)}
-.tbl tr:last-child td{border-bottom:0}
-.tbl .num{text-align:right;color:var(--dim)}
-.tbl .nm{font-weight:var(--fw-bold)}
-.chips{display:flex;gap:6px;flex-wrap:wrap}
-.chip{font-size:var(--fs-11);border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);border-radius:var(--radius-pill);padding:3px 6px;color:var(--dim);box-shadow:var(--inset)}
-.chip.tone-warn{border-color:rgb(var(--orange-rgb)/.4);background:rgb(var(--orange-rgb)/.08);color:var(--warn)}
-.chip.mcp{color:var(--aura-pale);border-color:rgb(var(--aura-glow-rgb)/.42);background:rgb(var(--aura-glow-rgb)/.12)}
-.tbtn{border:1px solid var(--line2);background:linear-gradient(180deg,rgb(var(--signal-rgb)/.18),rgb(var(--signal-rgb)/.08));color:var(--fg);border-radius:var(--radius-md);padding:6px 10px;font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);cursor:pointer}
-.tbtn:hover{border-color:rgb(var(--signal-rgb)/.56);background:linear-gradient(180deg,rgb(var(--signal-rgb)/.24),rgb(var(--signal-rgb)/.1))}
-#e-builder-recap{display:inline-flex;align-items:center;text-decoration:none}
-.sessionEfficiency{display:grid;grid-template-columns:minmax(112px,.55fr) repeat(2,minmax(0,1fr));align-items:stretch;margin-top:12px;padding:10px 14px;box-shadow:var(--shadow-soft)}
-.sessionEfficiencyIntro{display:flex;flex-direction:column;justify-content:center;padding-right:14px}
-.sessionEfficiencyIntro .sm{margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.sessionEfficiencyMetric{min-width:0;padding:2px 16px;border-left:1px solid var(--line)}
-.sessionEfficiencyMetric strong{margin-top:2px;font-size:var(--fs-22);line-height:1.15;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.sessionEfficiencyMetric span{display:block;color:var(--dim);margin-top:2px;font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.sessionEfficiencyMetric .label{letter-spacing:0}
-.previewStatus .previewRunEfficiencySlot{margin-top:14px;padding-top:10px;border-top:1px solid rgb(var(--signal-rgb)/.14)}
-.previewStatus .previewRunEfficiencySlot .sessionEfficiency{grid-template-columns:repeat(2,minmax(0,1fr));margin:0;padding:0;border:0;border-radius:0;background:transparent;box-shadow:none}
-.previewStatus .previewRunEfficiencySlot .sessionEfficiencyIntro{grid-column:1/-1;flex-direction:row;align-items:baseline;justify-content:space-between;padding:0 0 8px}
-.previewStatus .previewRunEfficiencySlot .sessionEfficiencyIntro .sm{display:none}
-.previewStatus .previewRunEfficiencySlot .sessionEfficiencyMetric{padding:0 10px 0 0;border-left:0}
-.previewStatus .previewRunEfficiencySlot .sessionEfficiencyMetric+.sessionEfficiencyMetric{padding:0 0 0 10px;border-left:1px solid var(--line)}
-.previewStatus .previewRunEfficiencySlot .sessionEfficiencyMetric strong{font-size:var(--fs-18)}
-.sessionBudget{margin-top:12px;padding:12px 14px;display:grid;gap:8px;overflow:visible}
-.sessionBudgetHead,.sessionBudgetMeta{display:flex;align-items:center;justify-content:space-between;gap:14px}
-.sessionBudgetHead>div:first-child{min-width:0}
-.sessionBudgetExact{display:flex;align-items:center;gap:6px;color:var(--dim);font-size:var(--fs-12);white-space:nowrap}
-.sessionBudgetExact input{width:86px;background:rgb(var(--tint-rgb)/.05);border:1px solid var(--line2);border-radius:var(--radius-md);color:var(--fg);padding:6px 8px;font:var(--fw-bold) var(--fs-13) var(--font-mono)}
-.sessionBudgetExact input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.sessionBudgetTrack{display:grid;grid-template-columns:52px minmax(120px,1fr) 60px;align-items:center;gap:10px}
-.sessionBudgetTrack>span{font-size:var(--fs-11);color:var(--faint)}
-.sessionBudgetTrack>span:last-child{text-align:right}
-.sessionBudgetTrack input[type=range]{--budget-fill:0%;appearance:none;-webkit-appearance:none;width:100%;height:22px;margin:0;background:transparent;cursor:pointer}
-.sessionBudgetTrack input[type=range]::-webkit-slider-runnable-track{height:7px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:linear-gradient(90deg,var(--accent) 0 var(--budget-fill),rgb(var(--tint-rgb)/.075) var(--budget-fill) 100%);box-shadow:var(--inset)}
-.sessionBudgetTrack input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;margin-top:-6px;border:2px solid var(--signal-pale);border-radius:var(--radius-round);background:var(--accent);box-shadow:0 0 0 4px rgb(var(--signal-rgb)/.15),0 3px 10px rgb(var(--shade-rgb)/.45)}
-.sessionBudgetTrack input[type=range]:focus-visible{outline:none}
-.sessionBudgetTrack input[type=range]:focus-visible::-webkit-slider-thumb{box-shadow:0 0 0 5px rgb(var(--signal-rgb)/.28),0 3px 10px rgb(var(--shade-rgb)/.45)}
-.sessionBudgetTrack input[type=range]::-moz-range-track{height:7px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.075)}
-.sessionBudgetTrack input[type=range]::-moz-range-progress{height:7px;border-radius:var(--radius-pill);background:var(--accent)}
-.sessionBudgetTrack input[type=range]::-moz-range-thumb{width:16px;height:16px;border:2px solid var(--signal-pale);border-radius:var(--radius-round);background:var(--accent);box-shadow:0 0 0 4px rgb(var(--signal-rgb)/.15)}
-.sessionBudgetMeta{font-size:var(--fs-12);color:var(--faint)}
-.sessionBudgetMeta span:first-child{color:var(--dim);font-weight:var(--fw-semibold)}
-.toastbox{position:fixed;right:18px;bottom:18px;z-index:80;display:flex;flex-direction:column;gap:8px;width:min(360px,calc(100vw - 28px));pointer-events:none;transition:bottom .18s ease}
-.updateReady .toastbox{bottom:70px}
-.toast{pointer-events:auto;border:1px solid rgb(var(--signal-rgb)/.38);border-left:4px solid var(--signal);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98));box-shadow:0 16px 42px rgb(var(--shade-rgb)/.42);padding:10px 12px;animation:enter .18s ease}
-.toast.warn{border-left-color:var(--warn);border-color:rgb(var(--orange-rgb)/.42)}
-.toast.bad{border-left-color:var(--bad);border-color:rgb(var(--red-rgb)/.42)}
-.toast .th{display:flex;align-items:flex-start;justify-content:space-between;gap:10px;font-size:var(--fs-13);font-weight:var(--fw-heavy)}
-.toast .tb{font-size:var(--fs-12);color:var(--dim);margin-top:2px}
-.toast button{border:0;background:transparent;color:var(--faint);font:inherit;font-size:var(--fs-16);line-height:1;cursor:pointer;padding:0}
-.toast button:hover{color:var(--fg)}
-.updateNotice{position:fixed;right:18px;bottom:18px;z-index:79;border:1px solid rgb(var(--signal-rgb)/.58);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--signal-deep-rgb)/.98),rgb(var(--bg2-rgb)/.98));color:var(--fg);box-shadow:0 16px 42px rgb(var(--shade-rgb)/.48),0 0 26px rgb(var(--signal-rgb)/.12);padding:8px 12px;font:var(--fw-bold) var(--fs-12)/1.2 var(--font-sans);cursor:pointer;animation:enter .18s ease}
-.updateNotice:hover{border-color:var(--accent);background:linear-gradient(180deg,rgb(var(--signal-rgb)/.2),transparent),linear-gradient(180deg,rgb(var(--signal-deep-rgb)/.98),rgb(var(--bg2-rgb)/.98))}
-.updateNotice:disabled{cursor:wait;color:var(--dim);opacity:.84}
-.updateNotice[hidden]{display:none}
-.foot{margin-top:16px;font-size:var(--fs-11);color:var(--faint);text-align:center}
-.spark{display:flex;align-items:flex-end;gap:4px;height:84px;margin-top:8px;padding:0 2px}
-.spark .b{flex:1;background:linear-gradient(180deg,var(--signal),rgb(var(--signal-rgb)/.55));border-radius:var(--radius-xs) var(--radius-xs) 0 0;min-height:3px;position:relative;box-shadow:0 -8px 18px rgb(var(--signal-rgb)/.08)}
-.spark .b.anom{background:linear-gradient(180deg,var(--bad),rgb(var(--red-rgb)/.58))}
-.spark .b:hover:after{content:attr(data-l);position:absolute;bottom:100%;left:50%;transform:translateX(-50%);background:var(--panel);color:var(--fg);border:1px solid var(--line2);font-size:var(--fs-11);padding:3px 6px;border-radius:var(--radius-xs);white-space:nowrap;margin-bottom:4px;z-index:5;box-shadow:var(--shadow-soft)}
-.reco{display:inline-flex;border:1px solid var(--line);border-radius:var(--radius-pill);padding:3px 6px;font-size:var(--fs-11);color:var(--dim);white-space:nowrap}
-.reco.disable,.reco.fix_or_disable{color:var(--warn);border-color:rgb(var(--orange-rgb)/.36);background:rgb(var(--orange-rgb)/.08)}
-.reco.narrow_results,.reco.reduce_repeats{color:var(--signal-hi);border-color:rgb(var(--signal-rgb)/.3);background:rgb(var(--signal-rgb)/.08)}
-.mcpDialog{width:min(560px,calc(100vw - 28px));border:1px solid var(--line2);border-radius:var(--radius-lg);background:linear-gradient(180deg,var(--panel2),var(--bg2));color:var(--fg);padding:0;box-shadow:0 30px 90px rgb(var(--shade-rgb)/.7)}
-.mcpDialog::backdrop{background:rgb(var(--shade-rgb)/.68);backdrop-filter:blur(4px)}
-.mcpDialog .inner{padding:20px}
-.mcpDialog h3{margin:0 0 8px;font-size:var(--fs-20)}
-.mcpDialog .evidence{display:grid;gap:6px;margin:14px 0;padding:12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.03);color:var(--dim);font-size:var(--fs-12)}
-.mcpDialog code{display:block;margin:12px 0;padding:10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:var(--bg);color:var(--signal-hi);overflow:auto}
-.mcpDialog .actions{display:flex;justify-content:flex-end;gap:8px;margin-top:16px}
-.mcpDialog .danger{border-color:rgb(var(--orange-rgb)/.45);background:rgb(var(--orange-rgb)/.12);color:var(--warn)}
-.commandPalette{width:min(660px,calc(100vw - 28px));max-height:min(680px,calc(100vh - 40px));border:1px solid rgb(var(--signal-hi-rgb)/.34);border-radius:var(--radius-lg);background:radial-gradient(ellipse 70% 40% at 12% 0,rgb(var(--signal-rgb)/calc(.16*var(--glow))),transparent 70%),linear-gradient(180deg,rgb(var(--panel2-rgb)/.9),rgb(var(--bg2-rgb)/.94));color:var(--fg);padding:0;overflow:hidden;box-shadow:0 34px 100px rgb(var(--shade-rgb)/.76),0 0 70px rgb(var(--signal-rgb)/calc(.16*var(--glow)));backdrop-filter:blur(24px) saturate(1.3)}
-.commandPalette::backdrop{background:rgb(var(--shade-rgb)/.7);backdrop-filter:blur(6px)}
-.commandShell{display:flex;max-height:min(680px,calc(100vh - 40px));flex-direction:column}
-.commandSearch{display:grid;grid-template-columns:20px minmax(0,1fr) auto;align-items:center;gap:10px;padding:14px 16px;border-bottom:1px solid var(--line2);background:rgb(var(--tint-rgb)/.025)}
-.commandSearch svg{width:19px;height:19px;stroke:var(--faint)}
-.commandSearch input{min-width:0;border:0;outline:0;background:transparent;color:var(--fg);font:var(--fw-semibold) var(--fs-16)/1.4 var(--font-sans)}
-.commandSearch input::placeholder{color:var(--faint)}
-.commandSearch kbd,.commandFooter kbd{border:1px solid var(--line2);border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.05);color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.35 var(--font-mono);box-shadow:0 1px 0 rgb(var(--tint-rgb)/.07)}
-.commandSearch kbd{padding:2px 6px}
-.commandList{min-height:100px;overflow:auto;padding:8px;scrollbar-color:var(--line2) transparent}
-.commandGroup{padding:8px 10px 4px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.06em}
-.commandItem{width:100%;display:grid;grid-template-columns:30px minmax(0,1fr) auto;align-items:center;gap:10px;border:1px solid transparent;border-radius:var(--radius-md);background:transparent;color:var(--fg);padding:8px 10px;text-align:left;font:inherit;cursor:pointer}
-.commandItem:hover,.commandItem.selected{border-color:rgb(var(--signal-rgb)/.3);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.16),rgb(var(--aura-rgb)/.04));box-shadow:inset 2px 0 0 var(--signal-hi)}
-.commandGlyph{width:28px;height:28px;display:grid;place-items:center;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.04);color:var(--signal-hi);font:var(--fw-heavy) var(--fs-11) var(--font-mono)}
-.commandCopy{min-width:0}
-.commandLabel,.commandDescription{display:block}
-.commandLabel{font-size:var(--fs-13);font-weight:var(--fw-heavy);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.commandDescription{font-size:var(--fs-12);color:var(--faint);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.commandEmpty{min-height:120px}
-.commandFooter{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:8px 14px;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11)}
-.commandFooter span{display:flex;align-items:center;gap:4px}
-.commandFooter kbd{padding:1px 4px;color:var(--fg)}
-.globalControls{display:grid;grid-template-columns:minmax(220px,1fr) minmax(190px,.78fr) minmax(150px,.52fr) auto auto;gap:10px;align-items:end;margin:12px 0}
-.filterControl{display:grid;gap:4px;min-width:0}
-.filterControl>span{font-size:var(--fs-11);line-height:1;text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.searchbox,.filterSelect{width:100%;min-width:0;height:38px;border:1px solid var(--line2);background:var(--panel);color:var(--fg);border-radius:var(--radius-md);padding:8px 10px;font:inherit;font-size:var(--fs-13);font-weight:var(--fw-bold);box-shadow:var(--inset);color-scheme:dark}
-.searchbox{background:rgb(var(--tint-rgb)/.045);font-weight:inherit}
-.filterSelect{appearance:auto;padding-right:28px}
-select{color-scheme:dark;font-weight:var(--fw-bold)}
-select option{color:var(--fg);background-color:var(--panel2)}
-select option:checked{background-color:var(--panel3)}
-.searchbox:focus,.filterSelect:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.filterSort .seg{min-height:38px;align-items:center}
-.filterClear{display:grid;gap:4px;justify-items:stretch;min-width:148px}
-.clearFilters{height:38px;background:rgb(var(--tint-rgb)/.045);color:var(--dim)}
-.clearFilters:hover:not(:disabled){color:var(--fg)}
-.clearFilters:disabled{opacity:.42;cursor:not-allowed}
-.filterCount{text-align:right}
-.globalMeta{font-size:var(--fs-12);color:var(--faint);white-space:nowrap}
-.logsSummary{display:grid;grid-template-columns:minmax(380px,.78fr) minmax(440px,1.22fr);gap:10px;margin:0 0 12px;align-items:stretch}
-.logKpis{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}
-.logStat{padding:12px 14px;min-height:82px;overflow:hidden}
-.logStat .v{font-size:var(--fs-24);line-height:1.1;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.logStat .subline{font-size:var(--fs-11);margin-top:4px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.logModelCount{font-size:var(--fs-11);color:var(--faint);white-space:nowrap}
-.logModelList{display:grid;margin-top:6px}
-.logModelRow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:14px;align-items:center;padding:6px 0;border-top:1px solid var(--line);min-width:0}
-.logModelRow:first-child{border-top:0}
-.logModelName{font-size:var(--fs-13);font-weight:var(--fw-heavy);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.logModelMeta{font-size:var(--fs-11);color:var(--faint);margin-top:1px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.logModelValue{text-align:right}
-.logModelValue b{display:block;font-size:var(--fs-13)}
-.logModelValue span{display:block;font-size:var(--fs-11);color:var(--faint);margin-top:1px}
-.logModelEmpty{font-size:var(--fs-12);color:var(--faint);padding:16px 0 6px}
-.logsSummary{display:grid;grid-template-columns:minmax(380px,.78fr) minmax(440px,1.22fr);gap:10px;margin:0 0 12px;align-items:stretch}
-.logKpis{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}
-.logStat{padding:12px 14px;min-height:82px;overflow:hidden}
-.logStat.waitStat{grid-column:1/-1;min-height:72px}
-.logStat .v{font-size:var(--fs-24);line-height:1.1;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.logStat .subline{font-size:var(--fs-11);margin-top:4px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.logModelCount{font-size:var(--fs-11);color:var(--faint);white-space:nowrap}
-.logModelList{display:grid;margin-top:6px}
-.logModelRow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:14px;align-items:center;padding:6px 0;border-top:1px solid var(--line);min-width:0}
-.logModelRow:first-child{border-top:0}
-.logModelName{font-size:var(--fs-13);font-weight:var(--fw-heavy);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.logModelMeta{font-size:var(--fs-11);color:var(--faint);margin-top:1px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.logModelValue{text-align:right}
-.logModelValue b{display:block;font-size:var(--fs-13)}
-.logModelValue span{display:block;font-size:var(--fs-11);color:var(--faint);margin-top:1px}
-.logModelEmpty{font-size:var(--fs-12);color:var(--faint);padding:16px 0 6px}
-.outputPair{display:flex;align-items:flex-end;justify-content:space-between;gap:10px;min-width:0}
-.outputPair .v{min-width:0}
-.outputRate{display:grid;justify-items:end;line-height:1;padding-bottom:2px;white-space:nowrap}
-.outputRate strong{font-size:var(--fs-16);color:var(--signal-hi);font-weight:var(--fw-heavy)}
-.outputRate span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-bold);text-transform:uppercase;margin-top:3px}
-.modelHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:14px}
-.modelHead h1,.modelHead h2{font-size:var(--fs-24);line-height:1.2;margin:0}
-.modelHead p{color:var(--dim);margin:4px 0 0;font-size:var(--fs-13);max-width:760px}
-.modelControls{display:grid;grid-template-columns:minmax(220px,290px) minmax(150px,190px);gap:8px;align-items:end}
-.modelPicker{position:relative;min-width:0}
-.modelPicker>summary{list-style:none;display:flex;align-items:center;justify-content:space-between;gap:10px;width:100%;min-width:0;height:38px;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-md);padding:8px 10px;font-size:var(--fs-13);box-shadow:var(--inset);cursor:pointer}
-.modelPicker>summary::-webkit-details-marker{display:none}
-.modelPicker>summary:after{content:"\25be";color:var(--faint);font-size:var(--fs-11);flex:0 0 auto}
-.modelPicker>summary span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.modelPicker[open]>summary,.modelPicker>summary:focus-visible{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.modelPickerMenu{position:absolute;right:0;top:calc(100% + 6px);z-index:60;width:max(100%,290px);max-height:min(360px,55vh);overflow:auto;border:1px solid var(--line2);border-radius:var(--radius-md);background:linear-gradient(180deg,var(--panel2),var(--bg2));box-shadow:0 18px 46px rgb(var(--shade-rgb)/.58);padding:6px}
-.modelOption{display:grid;grid-template-columns:18px minmax(0,1fr);align-items:center;gap:8px;padding:8px 8px;border-radius:var(--radius-sm);color:var(--dim);font-size:var(--fs-13);cursor:pointer}
-.modelOption:hover{background:rgb(var(--tint-rgb)/.055);color:var(--fg)}
-.modelOption input{width:15px;height:15px;margin:0;accent-color:var(--accent)}
-.modelOption span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.modelOption.all{border-bottom:1px solid var(--line);border-radius:var(--radius-sm) var(--radius-sm) 0 0;margin-bottom:4px;padding-bottom:10px;font-weight:var(--fw-heavy);color:var(--fg)}
-.modelHero{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:10px}
-.modelKpi{padding:14px;min-height:110px;overflow:visible}
-.modelKpi .v{font-size:var(--fs-28);line-height:1.08;margin-top:6px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.modelKpi .subline{font-size:var(--fs-12);margin-top:4px}
-.modelDelta{display:inline-flex;align-items:center;gap:6px;color:var(--dim)}
-.modelDelta:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:var(--faint)}
-.modelDelta.up{color:var(--good)}
-.modelDelta.up:before{background:var(--good)}
-.modelDelta.down{color:var(--warn)}
-.modelDelta.down:before{background:var(--warn)}
-.modelCoverage{height:7px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045);overflow:hidden;margin-top:8px}
-.modelCoverage i{display:block;height:100%;width:0;background:linear-gradient(90deg,var(--accent),var(--signal-hi));border-radius:var(--radius-pill)}
-.modelTrendCard{margin-top:12px;padding:16px 16px}
-.modelTrendHead{display:flex;justify-content:space-between;align-items:flex-start;gap:14px}
-.modelTrendHead h2{font-size:var(--fs-14);margin:0}
-.modelTrendHead p{font-size:var(--fs-12);color:var(--faint);margin:2px 0 0}
-.modelTrendControls{display:flex;gap:12px;align-items:center;justify-content:flex-end;flex-wrap:wrap}
-.modelSwatch{display:inline-block;width:9px;height:9px;border-radius:var(--radius-xs);margin-right:4px;flex:0 0 auto}
-.modelChartWrap{position:relative;margin-top:10px}
-.modelChart{display:block;width:100%;height:270px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.022)}
-.modelChartTip{z-index:5;display:none;min-width:300px;max-width:min(440px,calc(100% - 16px));max-height:260px;overflow:auto;font:var(--fs-12)/1.35 var(--font-mono)}
-.modelChartTip .h{padding:6px 10px;background:rgb(var(--signal-rgb)/.14);font-weight:var(--fw-heavy);color:var(--fg)}
-.modelChartTip .r{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:18px;padding:4px 10px}
-.modelChartTip .r span{display:flex;align-items:center;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.modelChartTip .r b{color:var(--fg);white-space:nowrap}
-.modelChartTip .cols{color:var(--faint);font-size:var(--fs-11);border-bottom:1px solid var(--line);text-transform:uppercase}
-.modelTipSeries{padding:6px 10px;border-top:1px solid var(--line)}
-.modelTipSeries:first-of-type{border-top:0}
-.modelTipName{display:flex;align-items:center;min-width:0;color:var(--fg);font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.modelTipMetrics{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:8px;margin-top:4px}
-.modelTipMetrics span{display:grid;gap:1px;min-width:0}
-.modelTipMetrics small{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
-.modelTipMetrics b{color:var(--fg);font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.modelTableWrap{margin-top:12px;overflow:auto;max-height:620px}
-.modelTableWrap .tbl th{position:sticky;top:0;z-index:2;background:var(--panel);white-space:nowrap}
-.modelTableWrap .tbl th .fieldtip:after{bottom:auto;top:calc(100% + 7px);left:auto;right:0;z-index:4}
-.modelTableWrap .tbl td{vertical-align:middle}
-.modelNameLine{display:flex;align-items:center;min-width:0}
-.modelName{font-weight:var(--fw-heavy);max-width:260px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.modelRuntime{font-size:var(--fs-11);color:var(--faint);margin-top:2px}
-.modelEmpty{padding:36px 16px}
-.efficiencyHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px}
-.efficiencyRange{display:grid;gap:6px;min-width:260px}
-.efficiencyRange>span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase}
-.efficiencyHero{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}
-.efficiencyHeadline{position:relative;min-height:184px;padding:14px 16px 12px;overflow:hidden}
-.efficiencyHeadline:after{content:"";position:absolute;right:-54px;bottom:-88px;width:210px;height:210px;border-radius:var(--radius-round);background:radial-gradient(circle,rgb(var(--signal-rgb)/.15),transparent 68%);pointer-events:none}
-.efficiencyEyebrow{color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.efficiencyValueRow,.efficiencySupportValueRow{min-width:0}
-.efficiencyValueRow{margin-top:6px}
-.efficiencyHeadline .v{min-width:0;font-size:var(--fs-36);font-weight:var(--fw-heavy);line-height:1.02;letter-spacing:-.04em}
-.efficiencyCoverage{position:relative;z-index:1;margin-top:4px;color:var(--faint);font-size:var(--fs-11)}
-.efficiencyChartWrap{position:relative;z-index:2;margin-top:8px}
-.efficiencyChart{display:block;width:100%;height:64px;margin:0;color:var(--signal-hi);overflow:visible;cursor:crosshair}
-.efficiencyChartGrid{stroke:rgb(var(--tint-rgb)/.07);stroke-width:1}
-.efficiencyChartLine{fill:none;stroke:currentColor;stroke-width:2.25;stroke-linecap:round;stroke-linejoin:round}
-.efficiencyChartArea{fill:currentColor;opacity:.08}
-.efficiencyChartDot,.efficiencyChartInspectDot{fill:var(--panel);stroke:currentColor;stroke-width:2}
-.efficiencyChartInspect{pointer-events:none}
-.efficiencyChartInspectLine{stroke:currentColor;stroke-width:1;stroke-dasharray:3 3;opacity:.48}
-.efficiencyChartLabel{fill:var(--faint);font:var(--fs-11) var(--font-mono)}
-.efficiencyChartEmpty{fill:var(--faint);font:var(--fs-11) var(--font-sans)}
-.efficiencyChartTip{z-index:4;top:3px;transform:translateX(-50%);padding:4px 8px;color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono);white-space:nowrap}
-.efficiencyChartTip[hidden]{display:none}
-.efficiencySupport{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;margin-top:10px}
-.efficiencySupportItem{min-height:184px;padding:14px 16px 12px;overflow:hidden}
-.efficiencySupportValueRow{margin-top:6px}
-.efficiencySupportValueRow .v{margin-top:0}
-.efficiencySupportItem .v{font-size:var(--fs-28);font-weight:var(--fw-heavy);line-height:1.1;margin-top:6px}
-.efficiencySupportItem .subline{font-size:var(--fs-11);line-height:1.35;margin-top:4px}
-.efficiencySupportItem .efficiencyChart{height:64px}
-.efficiencyModelCard{margin-top:12px;padding:0;overflow:hidden}
-.efficiencyModelHead{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:14px 16px 10px;border-bottom:1px solid var(--line)}
-.efficiencyModelHead h2{font-size:var(--fs-14);margin:0}
-.efficiencyModelMeta{font-size:var(--fs-11);color:var(--faint);white-space:nowrap}
-.efficiencyTableWrap{overflow:auto;max-height:580px}
-.efficiencyTableWrap .tbl th{position:sticky;top:0;z-index:2;background:var(--panel);white-space:nowrap}
-.efficiencyTableWrap .tbl td{vertical-align:middle}
-.efficiencySort{display:inline-flex;align-items:center;justify-content:flex-end;gap:4px;width:100%;padding:0;border:0;background:none;color:inherit;font:inherit;font-weight:inherit;text-transform:inherit;letter-spacing:inherit;cursor:pointer}
-.efficiencyTableWrap .tbl th:first-child .efficiencySort,.workBreakdownTable th:first-child .efficiencySort,.workScore th:first-child .efficiencySort{justify-content:flex-start}
-.efficiencySort:hover,.efficiencySort:focus-visible{color:var(--fg)}
-.efficiencySort:focus-visible{outline:1px solid var(--signal);outline-offset:3px;border-radius:var(--radius-2xs)}
-.efficiencySortMark{width:9px;color:var(--signal-hi);font-size:var(--fs-11);text-align:center}
-.efficiencyMetric strong{display:block;color:var(--fg);font-size:var(--fs-13)}
-.efficiencyMetric span{display:block;color:var(--faint);font-size:var(--fs-11);margin-top:2px}
-.efficiencyEvidence{padding:8px 16px;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11);line-height:1.35}
-.efficiencyTableWrap .tbl th,.efficiencyTableWrap .tbl td{padding-left:6px;padding-right:6px}
-.efficiencyChart{border-radius:var(--radius-xs)}
-.efficiencyChart:focus-visible{outline:1px solid currentColor;outline-offset:3px}
-.efficiencyChartStatus{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
-.capHero{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}
-.currentCapHero{grid-template-columns:repeat(3,minmax(0,1fr));margin-top:10px}
-.capHero .pad{padding:12px 14px;overflow:visible}
-.capHero .card:hover,.capHero .card:focus-within{z-index:50}
-.capHero .fieldtip:after{bottom:auto;top:calc(100% + 8px);z-index:40}
-.capHero .card:last-child .fieldtip:after{left:auto;right:0}
-.capHero .meter{font-size:var(--fs-28);margin-top:4px}
-.capHero .subline{font-size:var(--fs-12);margin-top:4px}
-.capStatBar{height:8px;margin-top:8px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.055);overflow:hidden;box-shadow:inset 0 1px 3px rgb(var(--shade-rgb)/.42)}
-.capStatBar i{display:block;width:0;height:100%;border-radius:var(--radius-pill);transition:width .35s ease;background:linear-gradient(90deg,var(--good),var(--accent));box-shadow:0 0 14px rgb(var(--green-rgb)/.3)}
-.capStatBar.mcp i{background:linear-gradient(90deg,var(--aura-deep),var(--aura));box-shadow:0 0 14px rgb(var(--aura-glow-rgb)/.3)}
-.capStatBar.skill i{background:linear-gradient(90deg,var(--accent),var(--signal-hi));box-shadow:0 0 14px rgb(var(--signal-rgb)/.3)}
-.capStatBar.warn i{background:linear-gradient(90deg,var(--warn),var(--signal));box-shadow:0 0 14px rgb(var(--orange-rgb)/.3)}
-.defBar{height:12px;margin-top:10px;background:rgb(var(--tint-rgb)/.05);border:1px solid var(--line);border-radius:var(--radius-pill);overflow:hidden;display:flex}
-.defBar i{display:block;height:100%}
-.defBar .used{background:var(--good)}
-.defBar .unused{background:var(--warn)}
-.defBar .deferred{background:rgb(var(--signal-hi-rgb)/.42)}
-.capFilters{display:grid;grid-template-columns:minmax(220px,1fr) auto auto;gap:10px;align-items:center;margin:10px 0}
-.capTableWrap{overflow:auto;max-height:620px}
-.capTableWrap .tbl th{position:sticky;top:0;z-index:2;background:var(--panel)}
-.capTableWrap .tbl th.sortable{cursor:pointer;user-select:none;white-space:nowrap}
-.capTableWrap .tbl th.sortable:after{content:"\2195";display:inline-block;margin-left:6px;color:var(--faint);font-size:var(--fs-11)}
-.capTableWrap .tbl th.sortable.sort-asc:after{content:"\2191";color:var(--accent)}
-.capTableWrap .tbl th.sortable.sort-desc:after{content:"\2193";color:var(--accent)}
-.capTableWrap .tbl th.sortable:focus-visible{outline:1px solid var(--accent);outline-offset:-2px}
-.stateDot{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
-.stateDot:before{content:"";width:8px;height:8px;border-radius:var(--radius-round);background:var(--faint)}
-.stateDot.on:before{background:var(--good)}
-.stateDot.off:before{background:var(--bad)}
-.stateDot.lazy:before{background:var(--signal-hi)}
-.stateDot.prompt:before{background:var(--accent)}
-.capAction{border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:4px 8px;font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer;white-space:nowrap}
-.capAction:hover{border-color:var(--accent)}
-.capAction.disable{color:var(--warn);border-color:rgb(var(--orange-rgb)/.4);background:rgb(var(--orange-rgb)/.08)}
-.capAction:disabled{opacity:.45;cursor:not-allowed}
-.capPath{max-width:330px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--faint);font-size:var(--fs-11)}
-.tbtn.danger{border-color:rgb(var(--orange-rgb)/.45);background:rgb(var(--orange-rgb)/.12);color:var(--warn)}
-.tbtn.danger:hover{background:rgb(var(--orange-rgb)/.19)}
-.dailyHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:16px}
-.dailyHead h1,.learnHead h1{font-size:var(--fs-24);line-height:1.2;margin:0}
-.dailyHead p,.learnHead p{color:var(--dim);margin:4px 0 0;font-size:var(--fs-13)}
-.iconBtn:hover:not(:disabled){border-color:var(--accent);background:rgb(var(--signal-rgb)/.09)}
-.learnHead{max-width:760px;margin-bottom:20px}
-.bulkControls{max-height:220px;white-space:pre-wrap}
-.agentDiscovery{display:flex;align-items:center;gap:14px;margin-bottom:12px;padding:12px 14px;border:1px solid rgb(var(--signal-rgb)/.32);border-left:3px solid var(--accent);border-radius:var(--radius-md);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.11),rgb(var(--panel-rgb)/.88) 58%,rgb(var(--panel-rgb)/.94));box-shadow:var(--shadow-soft)}
-.agentDiscovery[hidden]{display:none}
-.agentDiscoveryMain{flex:1;min-width:0}
-.agentDiscoveryTitle{font-weight:var(--fw-heavy)}
-.agentDiscoveryText{color:var(--dim);font-size:var(--fs-13);margin-top:2px}
-.agentDiscoveryClose{border:0;background:transparent;color:var(--faint);font:var(--fw-bold) var(--fs-18)/1 var(--font-sans);cursor:pointer;padding:6px}
-.agentDiscoveryClose:hover{color:var(--fg)}
-.settingsPageHead{margin-bottom:14px}
-.settingsPageHead p{max-width:680px}
-.agentAccess{overflow:hidden}
-.agentAccessHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}
-.agentAccessHead h1,.agentAccessHead h2{font-size:var(--fs-22);line-height:1.15;margin:4px 0 0}
-.agentAccessHead p{color:var(--dim);font-size:var(--fs-13);margin:4px 0 0;max-width:650px}
-.agentAccessBadge{padding:4px 8px;white-space:nowrap}
-.agentAccessHead .tbtn{text-decoration:none}
-.agentClients{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;margin-top:16px}
-.agentClient{display:grid;gap:10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.035);padding:10px 10px}
-.agentClientPart{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:12px;align-items:center}
-.agentClientSkills{border-top:1px solid var(--line);padding-top:10px}
-.agentClientActions{display:flex;gap:8px}
-.agentClientName{display:flex;align-items:center;gap:6px;font-weight:var(--fw-heavy)}
-.agentClientState{font-size:var(--fs-12);color:var(--faint);margin-top:2px}
-.agentClientState.connected{color:var(--good)}
-.agentClientState.warn{color:var(--warn)}
-.agentCommand{white-space:pre-wrap;overflow-wrap:anywhere}
-.compareToggle{width:22px;height:22px;display:grid;place-items:center;padding:0;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);color:transparent;cursor:pointer;transition:border-color .16s,background .16s,color .16s}
-.compareToggle svg{width:14px;height:14px;fill:none;stroke:currentColor;stroke-width:2.2;stroke-linecap:round;stroke-linejoin:round}
-.compareToggle:hover{border-color:rgb(var(--signal-rgb)/.6);color:var(--faint)}
-.compareToggle:focus-visible{outline:0;box-shadow:0 0 0 3px rgb(var(--signal-rgb)/.22);border-color:rgb(var(--signal-rgb)/.7)}
-.compareToggle[aria-pressed=true]{background:var(--compare-color,var(--accent));border-color:var(--compare-color,var(--accent));color:var(--bg-deep)}
-.compareToggle[aria-disabled=true]{opacity:.35;cursor:not-allowed}
-.srow.compareSelected{border-color:color-mix(in srgb,var(--compare-color,var(--accent)) 55%,transparent)}
-.compareTabCount{margin-left:6px;min-width:18px;height:18px;padding:0 4px;border-radius:var(--radius-pill);background:var(--accent);color:var(--bg-deep);font-size:var(--fs-11);font-weight:var(--fw-heavy);line-height:18px;text-align:center}
-.compareTabCount[hidden]{display:none}
-.tab[aria-selected=true] .compareTabCount{background:var(--on-accent);color:var(--signal-hi)}
-.compareTray{position:sticky;bottom:14px;z-index:6;display:flex;align-items:center;justify-content:space-between;gap:14px;margin-top:12px;padding:10px 12px;border:1px solid rgb(var(--signal-rgb)/.42);border-radius:var(--radius-lg);background:linear-gradient(180deg,rgb(var(--panel-rgb)/.97),rgb(var(--bg2-rgb)/.97));box-shadow:0 14px 40px rgb(var(--shade-rgb)/.45);backdrop-filter:blur(14px)}
-.compareTray[hidden]{display:none}
-.compareTrayItems{display:flex;gap:6px;flex-wrap:wrap;min-width:0}
-.compareTrayActions{display:flex;align-items:center;gap:8px;flex:0 0 auto}
-.compareTrayNote{color:var(--faint);font-size:var(--fs-12);max-width:280px}
-.compareChip{display:inline-flex;align-items:center;gap:6px;max-width:240px;padding:3px 4px 3px 3px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.04);font-size:var(--fs-12);color:var(--dim)}
-.compareChip span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.compareChip button{border:0;background:transparent;color:var(--faint);font:inherit;font-size:var(--fs-14);line-height:1;padding:0 3px;cursor:pointer;border-radius:var(--radius-xs)}
-.compareChip button:hover{color:var(--fg)}
-.compareLetter{flex:0 0 auto;display:inline-grid;place-items:center;width:20px;height:20px;border-radius:var(--radius-xs);background:var(--compare-color,var(--accent));color:var(--bg-deep);font-size:var(--fs-11);font-weight:var(--fw-heavy)}
-.compareHeadActions{display:flex;gap:8px;align-items:center}
-.tbtn.compareClear{background:rgb(var(--tint-rgb)/.04)}
-#compare-body{display:grid;gap:14px}
-.compareEmpty{padding:28px 24px}
-.compareEmpty h3{margin:0 0 6px;font-size:var(--fs-16);color:var(--fg)}
-.compareEmpty p{margin:0 auto 14px;max-width:560px;font-size:var(--fs-13);line-height:1.55}
-.compareNote{padding:8px 12px;border:1px solid rgb(var(--orange-rgb)/.35);border-radius:var(--radius-md);background:rgb(var(--orange-rgb)/.08);color:var(--warn);font-size:var(--fs-12)}
-.compareCards{display:grid;gap:10px}
-.compareCard{padding:12px 12px;border-top:3px solid var(--compare-color);display:flex;flex-direction:column;gap:4px;min-width:0}
-.compareCardTop{display:flex;align-items:center;gap:6px;min-width:0}
-.compareBaselineTag{margin-left:auto;font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.05em;color:var(--compare-color)}
-.compareCardTitle{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.compareCardMeta{font-size:var(--fs-12);color:var(--faint);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.compareCardCost{font-size:var(--fs-22);font-weight:var(--fw-heavy);margin-top:2px}
-.compareCardActions{display:flex;gap:6px;flex-wrap:wrap;margin-top:4px}
-.compareCardActions button{border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.04);color:var(--dim);border-radius:var(--radius-sm);padding:4px 8px;font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);cursor:pointer}
-.compareCardActions button:hover:not(:disabled){color:var(--fg);border-color:rgb(var(--signal-rgb)/.5)}
-.compareCardActions button:disabled{opacity:.45;cursor:default}
-.compareSection{padding:14px 16px}
-.compareSection h3{margin:0 0 10px;font-size:var(--fs-14)}
-.compareSectionHead{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:10px}
-.compareSectionHead h3{margin:0}
-.compareWinners{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}
-.compareWinners strong{display:flex;align-items:center;gap:8px}
-.compareWinners small{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.compareTableWrap{overflow-x:auto}
-.compareTable{width:100%;border-collapse:collapse;font-size:var(--fs-13)}
-.compareTable th,.compareTable td{padding:6px 10px;text-align:right;border-bottom:1px solid var(--line);white-space:nowrap}
-.compareTable th:first-child,.compareTable td:first-child{text-align:left;color:var(--dim);font-weight:var(--fw-semibold)}
-.compareTable thead th{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
-.compareTable thead th .compareLetter{margin-right:6px;vertical-align:middle}
-.compareTable tr.compareGroup th{padding-top:14px;text-align:left;color:var(--signal-hi);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.06em;border-bottom-color:var(--line2)}
-.compareTable td.text{max-width:150px;overflow:hidden;text-overflow:ellipsis}
-.compareTable th,.compareTable td{padding-left:8px;padding-right:8px}
-.compareTable tr.differs td:first-child:after{content:"differs";margin-left:8px;font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;color:var(--warn)}
-.compareDelta{display:block;font-size:var(--fs-11);font-weight:var(--fw-bold);color:var(--faint)}
-.compareDelta.better{color:var(--good)}
-.compareDelta.worse{color:var(--bad)}
-.compareBest{margin-left:6px;padding:1px 4px;border-radius:var(--radius-xs);background:rgb(var(--green-rgb)/.14);color:var(--good);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;vertical-align:1px}
-.compareUnavailable{color:var(--faint)}
-.compareCaption{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
-.compareChart{width:100%;height:auto;display:block}
-.compareLegend{display:flex;gap:14px;flex-wrap:wrap;margin-top:8px;font-size:var(--fs-12);color:var(--dim)}
-.compareLegend span{display:inline-flex;align-items:center;gap:6px}
-.compareLegend i{width:12px;height:3px;border-radius:var(--radius-2xs);background:var(--compare-color)}
-.compareLegend i.part{width:10px;height:10px;border-radius:var(--radius-xs)}
-.compareBreakdown{display:grid;gap:8px}
-.compareBreakdownRow{display:grid;grid-template-columns:28px minmax(0,1fr) 84px;gap:10px;align-items:center}
-.compareBreakdownBar{display:flex;height:16px;border-radius:var(--radius-xs);overflow:hidden;background:rgb(var(--tint-rgb)/.04)}
-.compareBreakdownBar i{display:block;height:100%}
-.compareBreakdownRow b{text-align:right;font-size:var(--fs-13)}
-.compareMatches{display:grid;gap:6px}
-.compareMatch{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:12px;align-items:center;padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025)}
-.compareMatch .t{font-weight:var(--fw-semibold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.compareMatch .meta{font-size:var(--fs-12);color:var(--faint)}
-.compareMatchActions{display:flex;gap:6px}
-.slist{display:flex;flex-direction:column;gap:8px}
-.srow{display:grid;grid-template-columns:26px 132px minmax(0,1fr) auto auto 28px;gap:12px;align-items:center;background:linear-gradient(180deg,rgb(var(--panel-rgb)/.94),rgb(var(--bg2-rgb)/.94));border:1px solid var(--line);border-radius:var(--radius-md);padding:12px 14px;cursor:pointer;box-shadow:var(--shadow-soft);transition:border-color .16s,background .16s,transform .16s;min-width:0}
-.srow.hasChildren{align-items:start}
-.srow:hover{border-color:var(--line2);background:linear-gradient(180deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg2-rgb)/.96));transform:translateY(-1px)}
-.srow.active,.srow.live{border-color:rgb(var(--signal-rgb)/.62);box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.12),var(--shadow-soft)}
-.srow .t{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.srow .meta{font-size:var(--fs-12);color:var(--faint);margin-top:2px}
-.srow .c{font-weight:var(--fw-heavy);font-size:var(--fs-16);text-align:right}
-.sMain{min-width:0}
-.sbar{height:4px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.045);overflow:hidden;margin-top:8px}
-.sbar i{display:block;height:100%;background:linear-gradient(90deg,var(--accent),var(--signal));border-radius:var(--radius-xs)}
-.smetrics{text-align:right;min-width:88px}
-.sactions{display:flex;align-items:center;justify-content:flex-end}
-.sactions .sessionDelete{margin-top:0}
-.smetrics .meta{font-size:var(--fs-11)}
-.badge{font-size:var(--fs-11);color:var(--dim);background:rgb(var(--tint-rgb)/.045);border:1px solid var(--line);padding:3px 6px;border-radius:var(--radius-sm);box-shadow:var(--inset)}
-/* == Components: shared building blocks. :where() gives them zero specificity, so any screen rule overrides them. They own identity (color, type, tracking), not layout. == */
-:where(.emptyState){display:grid;place-items:center;align-content:center;gap:4px;padding:18px;color:var(--dim);font-size:var(--fs-12);line-height:1.45;text-align:center}
-:where(.emptyState)[hidden]{display:none}
-:where(.emptyState>strong,.emptyState>h3){display:block;margin:0;color:var(--fg);font-size:var(--fs-13)}
-:where(.emptyState>p){max-width:56ch;margin:0 auto}
-:where(.metric){min-width:0}
-:where(.metric>span:first-child,.metric>.label){display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
-:where(.metric>strong,.metric>b,.metric>.v){display:block;margin-top:4px;color:var(--fg);font-family:var(--font-mono);font-size:var(--fs-16);font-weight:var(--fw-heavy);font-variant-numeric:tabular-nums}
-:where(.metric>small,.metric>.subline,.metric>.sm){display:block;margin-top:2px;color:var(--dim);font-size:var(--fs-11)}
-:where(.chartTip){position:absolute;pointer-events:none;border:1px solid rgb(var(--signal-rgb)/.42);border-radius:var(--radius-md);background:var(--tip-bg);box-shadow:var(--shadow-tip);color:var(--dim)}
-:where(.valueWithDelta){display:flex;flex-wrap:wrap;align-items:center;gap:6px 16px;min-width:0}
-@media(max-width:1180px){:where(.valueWithDelta){gap:6px 10px}}
-:where(.trendDelta){display:grid;justify-items:start;gap:2px;color:var(--dim);line-height:1.15}
-:where(.trendDelta)[hidden]{display:none}
-:where(.trendDelta>strong){font-family:var(--font-mono);font-size:var(--fs-20);font-weight:var(--fw-heavy);font-variant-numeric:tabular-nums;white-space:nowrap}
-:where(.trendDelta>span){max-width:16ch;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-:where(.trendDelta[data-tone=improving]>strong){color:var(--good)}
-:where(.trendDelta[data-tone=degrading]>strong){color:var(--bad)}
-:where(.trendDelta[data-direction=""]>strong){color:var(--faint);font-family:var(--font-sans);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-:where(.readoutScale){--scale-tone:var(--signal);position:relative;display:block;height:8px;margin-top:8px;border-radius:var(--radius-2xs);background:rgb(var(--tint-rgb)/.06)}
-:where(.readoutScale)[hidden]{display:none}
-:where(.readoutScale[data-tone=high]){--scale-tone:var(--warn)}
-:where(.readoutScale>.readoutScaleFill){position:absolute;inset:0 auto 0 0;width:var(--at,0%);border-radius:inherit;background:var(--scale-tone);-webkit-mask:var(--dither-50) 0 0/4px 4px;mask:var(--dither-50) 0 0/4px 4px;transition:width var(--dur-data) var(--ease-out)}
-:where(.readoutScale>.readoutScaleTypical){position:absolute;top:-3px;bottom:-3px;left:var(--typ,50%);width:2px;border-radius:var(--radius-2xs);background:var(--soft);transform:translateX(-50%)}
-:where(.readoutScale>.readoutScaleMark){position:absolute;top:-2px;bottom:-2px;left:var(--at,0%);width:4px;border-radius:var(--radius-2xs);background:var(--scale-tone);box-shadow:0 0 10px var(--scale-tone);transform:translateX(-50%);transition:left var(--dur-data) var(--ease-out)}
-:where(.readoutCaption){display:block;margin-top:6px;color:var(--soft);font-size:var(--fs-12);font-weight:var(--fw-medium);line-height:1.35}
-:where(.readoutCaption)[hidden]{display:none}
-:where(.chartGapBridge){fill:none;stroke:var(--faint);stroke-width:1.5;stroke-dasharray:2 4;stroke-linecap:round}
-:where(.readoutCaption)::before{content:"› ";color:var(--signal);font-family:var(--font-mono);font-weight:var(--fw-heavy)}
-:where(.conceptFrame){display:grid;align-content:start;gap:16px;min-width:0;margin:0;padding:20px;border:1px solid var(--spectrum-border);border-radius:var(--radius-lg);background:var(--spectrum-card);box-shadow:var(--spectrum-shadow);color:var(--fg)}
-:where(.conceptFrame)[hidden]{display:none}
-:where(.conceptFrame>.conceptFrameHead){display:flex;align-items:center;justify-content:space-between;gap:8px;min-height:22px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
-:where(.conceptFrame>.conceptFrameHead>.chip){letter-spacing:0;text-transform:none}
-:where(.conceptFrame>.conceptFrameStage){position:relative;display:grid;gap:12px;min-width:0}
-:where(.conceptFrame>.conceptFrameStage [data-callout]){position:relative}
-:where(.conceptFrame>figcaption){margin:0;padding-top:14px;border-top:1px solid var(--line)}
-:where(.frameCallout){display:inline-grid;flex:none;place-items:center;width:24px;height:24px;border:2px solid var(--bg-deep);border-radius:var(--radius-round);background:var(--spectrum-active);box-shadow:var(--spectrum-glow);color:var(--on-accent);font:var(--fw-heavy) var(--fs-12)/1 var(--font-mono);font-style:normal;letter-spacing:0;text-transform:none;vertical-align:middle}
-:where(.frameCallout)[hidden]{display:none}
-:where(.frameCallout[data-at]){position:absolute;z-index:3}
-:where(.frameCallout[data-at=tr]){top:-12px;right:-12px}
-:where(.frameCallout[data-at=tl]){top:-12px;left:-12px}
-:where(.frameCallout[data-at=t]){top:-14px;left:50%;transform:translateX(-50%)}
-:where(.frameCallout[data-at=r]){top:50%;right:-32px;transform:translateY(-50%)}
-:where(.frameCallout[data-at=l]){top:50%;left:-32px;transform:translateY(-50%)}
-:where(.frameCallout[data-at=bar]){bottom:calc(var(--bar-h) + 6px);left:50%;transform:translateX(-50%)}
-:where(.frameLegend){display:grid;gap:10px;margin:0;padding:0;list-style:none}
-:where(.frameLegend)[hidden]{display:none}
-:where(.frameLegend>li){display:grid;grid-template-columns:24px minmax(0,1fr);align-items:center;gap:12px;color:var(--fg);font-size:var(--fs-14);font-weight:var(--fw-medium);line-height:1.4}
-:where(.levelBar){--level-tone:var(--spectrum-active);position:relative;display:block;height:8px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.07)}
-:where(.levelBar)[hidden]{display:none}
-:where(.levelBar[data-tone=warn]){--level-tone:var(--warn)}
-:where(.levelBar>i){display:block;width:var(--fill,0%);min-width:2px;height:100%;border-radius:inherit;background:var(--level-tone);transition:width var(--dur-data) var(--ease-out)}
-:where(.levelBar>b){position:absolute;top:-4px;bottom:-4px;left:var(--mark,0%);width:2px;border-radius:var(--radius-2xs);background:var(--fg);transform:translateX(-50%)}
-@media(prefers-reduced-motion:reduce){:where(.readoutScale>i){transition:none}}
-.badge.codex{color:var(--provider-codex);border-color:rgb(var(--provider-codex-rgb)/.42);background:rgb(var(--provider-codex-rgb)/.08)}
-.badge.claude{color:var(--provider-claude);border-color:rgb(var(--provider-claude-rgb)/.42);background:rgb(var(--provider-claude-rgb)/.08)}
-.badge.cursor{color:var(--provider-cursor);border-color:rgb(var(--provider-cursor-rgb)/.44);background:rgb(var(--provider-cursor-rgb)/.08)}
-.badge.opencode{color:var(--provider-opencode);border-color:rgb(var(--provider-opencode-rgb)/.42);background:rgb(var(--provider-opencode-rgb)/.08)}
-.badge.kiro{color:var(--provider-kiro);border-color:rgb(var(--provider-kiro-rgb)/.42);background:rgb(var(--provider-kiro-rgb)/.08)}
-.srow .subagentTag{display:inline-block;margin-right:6px;padding:1px 6px;font-size:var(--fs-11);font-weight:var(--fw-bold);letter-spacing:.03em;vertical-align:1px;color:var(--aura);border-color:rgb(var(--aura-rgb)/.34);background:rgb(var(--aura-rgb)/.08)}
-/* Child-agent subsection inside a parent session card. The parent row stays a
-   single button; children are their own buttons nested in a non-interactive
-   container so a child click never double-fires the parent navigation. */
-.subagents{margin-top:10px;padding:10px 12px 8px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.022);display:grid;gap:6px;min-width:0}
-.subagentsHead{display:flex;align-items:center;justify-content:space-between;gap:10px;min-width:0}
-.subagentsTitle{display:inline-flex;align-items:center;gap:6px;font-size:var(--fs-11);font-weight:var(--fw-bold);text-transform:uppercase;letter-spacing:.06em;color:var(--faint);min-width:0}
-.subagentsTitle b{color:var(--dim);font-weight:var(--fw-bold);letter-spacing:0}
-.subagentsStats{font-size:var(--fs-12);color:var(--faint);white-space:nowrap;font-variant-numeric:tabular-nums}
-.subagentsStats b{color:var(--fg);font-weight:var(--fw-heavy)}
-.subagentList{display:grid;gap:4px;min-width:0}
-.subagentRow{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:10px;align-items:center;width:100%;text-align:left;font:inherit;color:inherit;background:rgb(var(--tint-rgb)/.028);border:1px solid transparent;border-radius:var(--radius-sm);padding:6px 8px;cursor:pointer;min-width:0;transition:border-color .16s,background .16s}
-.subagentRow:hover,.subagentRow:focus-visible{border-color:rgb(var(--signal-rgb)/.34);background:rgb(var(--signal-rgb)/.07);outline:none}
-.subagentMain{min-width:0;overflow:hidden}
-.subagentMain .t{font-size:var(--fs-13);font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentMain .meta{font-size:var(--fs-11);color:var(--faint);margin-top:2px;display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}
-.subagentRole{display:inline-flex;align-items:center;border:1px solid rgb(var(--pink-rgb)/.34);background:rgb(var(--pink-rgb)/.11);color:var(--pink);border-radius:var(--radius-xs);padding:1px 6px;font-size:var(--fs-11);font-weight:var(--fw-bold);margin-right:6px;white-space:nowrap;vertical-align:1px}
-.subagentTokens{font-size:var(--fs-12);color:var(--dim);white-space:nowrap;font-variant-numeric:tabular-nums}
-.subagentCost{font-size:var(--fs-13);font-weight:var(--fw-heavy);text-align:right;white-space:nowrap;font-variant-numeric:tabular-nums}
-.subagentZero{font-weight:var(--fw-semibold);color:var(--faint)}
-.subagentMore{font-size:var(--fs-11);color:var(--faint);padding:1px 2px}
-@media(max-width:1100px){.subagentRow{grid-template-columns:minmax(0,1fr) auto}.subagentTokens{display:none}}
-.signalEmpty{min-height:112px;padding:18px}
-.settingsLexicon{box-shadow:var(--shadow-soft)}
-.settingsLexiconHead{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}
-.settingsLexicon h2{font-size:var(--fs-16);line-height:1.25;margin:4px 0}
-.settingsLexicon p{color:var(--dim);font-size:var(--fs-12);line-height:1.45;margin:0;max-width:420px}
-.settingsField{display:grid;gap:6px;margin-top:12px}
-.settingsField span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.settingsField textarea{width:100%;min-height:150px;resize:vertical;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-md);padding:8px 10px;font:var(--fs-12)/1.45 var(--font-mono);box-shadow:var(--inset)}
-.settingsField textarea:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.settingsStatus{width:100%;font-size:var(--fs-11);color:var(--faint)}
-.settingsStatus.good{color:var(--good)}
-.settingsStatus.warn{color:var(--warn)}
-.previewHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin:3px 0 14px}
-.previewHeadCopy{max-width:760px}
-.previewHead h1{font-size:var(--fs-28);line-height:1.08;margin:6px 0 0}
-.previewHead p{color:var(--dim);font-size:var(--fs-13);margin:6px 0 0}
-.previewHead p:empty{display:none}
-.previewRunMeta{display:flex;align-items:center;gap:8px;margin-bottom:10px;min-width:0}
-.sessionBackRow{display:flex;margin-bottom:10px}
-.sessionBack{display:inline-flex;align-items:center;gap:6px}
-.previewRunMeta .repo{max-width:460px}
-.previewRunGrid{display:grid;grid-template-columns:minmax(0,1.75fr) minmax(300px,.65fr);gap:12px;align-items:stretch}
-.previewChartSlot,.previewDecision{min-width:0}
-.previewChartSlot{display:grid}
-.previewChartSlot #session-chart-module{display:grid;grid-template-rows:auto minmax(0,1fr);gap:12px}
-.previewChartSlot .section-h,.previewDecision>.section-h{margin:0}
-.previewChartSlot #session-chart-module>.card{min-height:350px}
-.previewChartSlot .chart{height:286px}
-.previewDecision{display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:auto minmax(0,1fr) auto;gap:12px}
-.previewStatus{display:flex;flex-direction:column;overflow:hidden;padding:16px;background:linear-gradient(155deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98))}
-.previewStatus:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--good),var(--accent),transparent)}
-.previewStatus.warn:before{background:linear-gradient(90deg,var(--bad),var(--warn),transparent)}
-.previewStatusTop{display:flex;align-items:center;justify-content:space-between;gap:12px}
-.previewState{display:inline-flex;align-items:center;gap:6px;color:var(--good);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.05em}
-.previewState:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
-.previewStatus.warn .previewState{color:var(--bad)}
-.previewIdle{color:var(--faint);font-size:var(--fs-11)}
-.previewCost{font-size:var(--fs-readout-xl);font-weight:var(--fw-heavy);line-height:1.02;margin-top:12px;white-space:nowrap}
-.previewCostNote{color:var(--dim);font-size:var(--fs-12);margin-top:6px}
-.previewPressure{margin-top:16px;padding-top:12px;border-top:1px solid var(--line)}
-.previewStatus .previewPressure{margin-block:auto}
-.previewPressureHead{display:flex;align-items:baseline;justify-content:space-between;gap:10px;color:var(--dim);font-size:var(--fs-12)}
-.previewPressureHead b{color:var(--fg)}
-.previewPressureHead>span{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.04em}
-.previewPressureBar{height:7px;margin-top:6px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.07);overflow:hidden}
-.previewPressureBar i{display:block;width:0;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi));transition:width .2s}
-.previewRunBudgetSlot .sessionBudget{margin:0;box-shadow:var(--shadow-soft)}
-.previewRunBudgetSlot .sessionBudgetHead{align-items:flex-start;flex-direction:column;gap:8px}
-.previewRunBudgetSlot .sessionBudgetExact{width:100%;justify-content:space-between}
-.previewRunBudgetSlot .sessionBudgetTrack{grid-template-columns:52px minmax(0,1fr) 60px}
-.previewKpis{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:8px;margin-top:12px}
-.previewKpi{padding:12px 12px;min-height:92px}
-.previewKpi .v{font-size:var(--fs-20);margin-top:4px;overflow-wrap:anywhere}
-.previewKpi .sm{font-size:var(--fs-11);margin-top:3px}
-.previewStartText{font-size:var(--fs-14);font-weight:var(--fw-bold);line-height:1.45;margin-top:6px;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}
-.sessionChartModule{min-width:0}
-.previewChartColumn{display:grid;grid-template-rows:minmax(0,1fr) auto;gap:12px;min-width:0}
-.previewChartColumn .previewTokenSlot{margin-top:0}
-.previewTimes{display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-top:12px;padding-top:12px;border-top:1px solid var(--line)}
-.previewTimes div{min-width:0}
-.previewTimes span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.04em}
-.previewTimes b{display:block;margin-top:4px;color:var(--dim);font-size:var(--fs-11);line-height:1.5;overflow:hidden;text-overflow:ellipsis;white-space:pre}
-.previewKpis{grid-template-columns:repeat(4,minmax(0,1fr));gap:8px}
-.previewKpi{min-height:96px}
-.previewKpi .v{font-size:var(--fs-readout-md)}
-.settingsPageLayout{display:grid;gap:10px}
-.themePicker{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px;margin:14px 0 10px}
-.themeOption{display:grid;gap:8px;min-width:0;padding:8px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02);color:var(--fg);text-align:left;font:inherit;cursor:pointer;transition:border-color .16s,box-shadow .16s,transform .16s}
-.themeOption:hover{border-color:var(--spectrum-edge-hover);transform:translateY(-1px)}
-.themeOption[aria-pressed=true]{border-color:var(--signal-hi);box-shadow:var(--spectrum-glow)}
-.themePreview{position:relative;display:block;height:48px;overflow:hidden;border-radius:var(--radius-sm);background:var(--theme-swatch-bg);box-shadow:inset 0 0 0 1px rgb(var(--tint-rgb)/.08)}
-.themePreview i{position:absolute;display:block;left:10px}
-.themePreview i:nth-child(1){top:9px;width:42%;height:8px;border-radius:var(--radius-pill);background:var(--theme-swatch)}
-.themePreview i:nth-child(2){top:24px;width:58%;height:4px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.16)}
-.themePreview i:nth-child(3){right:10px;bottom:8px;height:18px;background:var(--theme-swatch);opacity:.55;-webkit-mask-image:repeating-linear-gradient(90deg,var(--black) 0 7px,transparent 7px 11px),linear-gradient(0deg,var(--black),transparent);mask-image:repeating-linear-gradient(90deg,var(--black) 0 7px,transparent 7px 11px),linear-gradient(0deg,var(--black),transparent);-webkit-mask-composite:source-in;mask-composite:intersect}
-.themeCopy{display:grid;gap:2px;min-width:0}
-.themeCopy b{font-family:var(--font-display);font-size:var(--fs-14);font-weight:var(--fw-semibold)}
-.themeCopy small{display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;overflow:hidden;color:var(--dim);font-size:var(--fs-12);line-height:1.35}
-.appearanceSettings kbd{padding:1px 4px;border:1px solid var(--line2);border-radius:var(--radius-xs);color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.35 var(--font-mono)}
-.settingsMap{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));align-items:stretch;padding:8px 10px;overflow:hidden}
-.settingsMap:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent)}
-.settingsMap button{width:100%;display:grid;grid-template-columns:25px minmax(0,1fr);gap:8px;align-items:center;text-align:left;border:0;border-left:1px solid var(--line);background:transparent;color:var(--dim);padding:6px 10px;font:inherit;cursor:pointer;border-radius:0}
-.settingsMap button:hover,.settingsMap button:focus-visible{color:var(--fg);background:rgb(var(--tint-rgb)/.03)}
-.settingsMap button>span:first-child{display:grid;place-items:center;width:23px;height:23px;border:1px solid var(--line2);border-radius:var(--radius-sm);color:var(--signal-hi);font:var(--fw-heavy) var(--fs-11)/1 var(--font-mono)}
-.settingsMap button b,.settingsMap button small{display:block}
-.settingsMap button b{font-size:var(--fs-12)}
-.settingsMap button small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium);margin-top:1px}
-.settingsPageContent{display:grid;gap:10px;min-width:0}
-.settingsPageContent>.card{scroll-margin-top:100px;width:100%;padding:14px 16px}
-.settingsPageContent .settingsLexicon p{max-width:760px}
-.settingsPageContent .agentClients{margin-top:12px}
-.sessionChartModule{min-width:0}
-.previewSurface{display:none}
-.previewSurface.on{display:block}
-.previewStartStrip{display:grid;grid-template-columns:max-content minmax(0,1fr);align-items:center;gap:12px;margin-bottom:12px;padding:10px 14px;min-width:0;border-left:3px solid var(--accent)}
-.previewStartLabel{color:var(--signal-hi);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.05em;white-space:nowrap}
-.previewStartStrip .previewStartText{display:block;min-width:0;margin:0;color:var(--fg);font-size:var(--fs-13);font-weight:var(--fw-bold);line-height:1.35;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.previewStartStrip .previewStartText:after{bottom:auto;top:calc(100% + 8px);z-index:60}
-.previewTokenSlot{margin-top:12px;min-width:0}
-.previewTokenSlot>.usageSplit{width:100%;margin:0}
-.previewTokenSlot .bar{height:26px}
-.previewKpi.fieldtip{display:block;overflow:visible}
-.previewKpi.fieldtip:after{bottom:auto;top:calc(100% + 8px);z-index:45}
-.previewKpi:hover,.previewKpi:focus{z-index:50;border-color:rgb(var(--signal-rgb)/.34)}
-.previewSpeed .v{color:var(--accent);text-shadow:0 0 18px rgb(var(--signal-rgb)/.18)}
-.sessionChartModule{min-width:0}
-.currentSessionFilterGroups{display:flex;align-items:center;gap:10px;min-width:0;overflow-x:auto;scrollbar-width:none}
-.currentSessionFilterGroups::-webkit-scrollbar{display:none}
-.currentSessionFilterGroup{display:flex;align-items:center;gap:4px;flex:0 0 auto}
-.currentSessionFilterGroup[hidden]{display:none}
-.currentSessionFilterLabel{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.currentSessionsCount{white-space:nowrap}
-.currentOverviewHidden{display:none!important}
-.currentSessionsHead{display:flex;align-items:center;gap:12px;margin:0 0 12px}
-.currentSessionsCount{color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
-.currentSessionGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}
-.currentSessionCard{--harness:var(--provider-other);appearance:none;display:flex;flex-direction:column;width:100%;min-width:0;min-height:218px;overflow:hidden;padding:20px 20px 16px;border:1px solid color-mix(in srgb,var(--harness) 48%,var(--line));border-radius:var(--radius-lg);background:linear-gradient(160deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98));box-shadow:var(--shadow-soft);color:var(--fg);font:inherit;text-align:left;cursor:grab;transition:transform .16s,border-color .16s,box-shadow .16s,opacity .16s}
-.currentSessionCard:before{content:"";position:absolute;inset:0 auto 0 0;width:3px;background:var(--harness);box-shadow:0 0 18px color-mix(in srgb,var(--harness) 55%,transparent)}
-.currentSessionCard:hover{transform:translateY(-2px);border-color:color-mix(in srgb,var(--harness) 78%,var(--line));box-shadow:0 14px 30px rgb(var(--shade-rgb)/.34)}
-.currentSessionCard:focus-visible{outline:0;border-color:var(--harness);box-shadow:0 0 0 3px color-mix(in srgb,var(--harness) 20%,transparent),var(--shadow)}
-.currentSessionCard.dragging{opacity:.42;cursor:grabbing;transform:scale(.99)}
-.currentSessionCard.dropBefore{box-shadow:inset 4px 0 0 var(--harness),var(--shadow)}
-.currentSessionCard.dropAfter{box-shadow:inset -4px 0 0 var(--harness),var(--shadow)}
-.currentSessionTop{display:flex;align-items:center;justify-content:space-between;gap:12px}
-.currentSessionRuntime{display:inline-flex;align-items:center;gap:8px;min-width:0;color:var(--harness);font-size:var(--fs-12);font-weight:var(--fw-heavy);letter-spacing:.012em}
-.currentSessionRuntime:before{content:"";width:7px;height:7px;flex:0 0 auto;border-radius:var(--radius-2xs);background:currentColor;box-shadow:0 0 10px currentColor}
-.currentSessionRuntime span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.currentSessionStatus{display:inline-flex;align-items:center;gap:6px;flex:0 0 auto;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-bold)}
-.currentSessionStatus:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:currentColor}
-.currentSessionStatus.working{color:var(--good)}
-.currentSessionStatus.working:before{box-shadow:0 0 9px currentColor}
-.currentSessionStatus.waiting{color:var(--warn)}
-.currentSessionStatus.recent{color:var(--faint)}
-.cacheRing{--ring-tone:var(--good);position:relative;display:inline-grid;place-items:center;flex:0 0 auto;width:40px;height:40px;margin:-10px 0;color:var(--fg)}
-.cacheRing svg{position:absolute;inset:0;width:100%;height:100%;overflow:visible}
-.cacheRing line{stroke:var(--ring-tone);stroke-width:1.5;stroke-linecap:round;transition:stroke .5s,opacity .5s}
-.cacheRing line.off{stroke:var(--line2)}
-.cacheRing line.maybe{stroke:var(--warn);opacity:.38}
-.cacheRing b{position:relative;font-family:var(--font-mono);font-size:var(--fs-11);font-weight:var(--fw-semibold);letter-spacing:0;line-height:1}
-.cacheRing.warn{--ring-tone:var(--warn)}
-.cacheRing.bad{--ring-tone:var(--bad);animation:cacheRingPulse 1s ease-in-out infinite}
-.cacheRing.maybe b,.cacheRing.cold b{color:var(--faint)}
-@keyframes cacheRingPulse{50%{filter:drop-shadow(0 0 4px var(--bad))}}
-@media(prefers-reduced-motion:reduce){.cacheRing.bad{animation:none}.cacheRing line{transition:none}}
-.currentSessionIdentity{margin-top:18px;min-width:0}
-.currentSessionIdentity h3{margin:0;font-size:var(--fs-20);line-height:1.2;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.currentSessionIdentity p{margin:4px 0 0;color:var(--faint);font:var(--fs-11)/1.25 var(--font-mono);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.currentSessionMetrics{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px;margin-top:20px;padding-top:16px;border-top:1px solid var(--line)}
-.currentSessionMetric{min-width:0}
-.currentSessionMetric span{font-size:var(--fs-11)}
-.currentSessionMetric b{margin-top:6px;font-size:var(--fs-18);line-height:1.15;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.currentSessionMetric b.mono{font-size:var(--fs-18);letter-spacing:-.015em}
-.currentSessionMove{display:inline-flex;align-items:center;gap:4px}
-.currentSessionCaps{display:block;margin-top:6px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.currentSessionProject{flex:0 1 auto;color:var(--faint);font-family:var(--font-mono);font-size:var(--fs-11);font-weight:var(--fw-medium);letter-spacing:0}
-.currentSessionProject:before{content:"·";margin-right:8px}
-.currentSessionTopMeta{display:inline-flex;flex:0 0 auto;align-items:center;gap:12px;color:var(--faint);font-size:var(--fs-11)}
-.currentSessionMove b{color:var(--harness);font-size:var(--fs-13);letter-spacing:-2px}
-.currentSessionOrderStatus{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
-.currentSessionsEmpty{padding:32px 20px;text-align:center}
-.currentSessionsEmpty h3{font-size:var(--fs-18);margin:0}
-.currentSessionsEmpty p{margin:4px auto 0;color:var(--dim);font-size:var(--fs-12)}
-.budgetDashboard{display:block}
-.budgetLead{overflow:hidden;background:linear-gradient(145deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.98))}
-.budgetLead:before{content:"";position:absolute;inset:0 0 auto;height:3px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent 78%)}
-.budgetLead h2,.budgetConfig h2{font-size:var(--fs-18);margin:4px 0 0}
-.budgetLeadHeadActions{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap}
-.budgetLeadBody{display:grid;grid-template-columns:minmax(0,1.08fr) minmax(440px,.92fr);gap:18px;align-items:stretch;margin-top:14px}
-.budgetSpend{margin:0;display:flex;flex-direction:column;justify-content:center}
-.budgetSpendValue{font-size:var(--fs-hero-fluid);font-weight:var(--fw-heavy);line-height:1;letter-spacing:-1.5px;margin-top:4px}
-.budgetState{display:inline-flex;align-items:center;gap:6px}
-.budgetState:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
-.budgetState.on_track{color:var(--good);border-color:rgb(var(--green-rgb)/.32);background:rgb(var(--green-rgb)/.07)}
-.budgetState.warning{color:var(--warn);border-color:rgb(var(--orange-rgb)/.34);background:rgb(var(--orange-rgb)/.07)}
-.budgetState.over{color:var(--bad);border-color:rgb(var(--red-rgb)/.36);background:rgb(var(--red-rgb)/.08)}
-.budgetProgress{position:relative;height:10px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.035);overflow:hidden;margin-top:12px}
-.budgetProgress>i{display:block;height:100%;width:0;background:linear-gradient(90deg,var(--accent),var(--signal));border-radius:var(--radius-pill);transition:width .2s}
-.budgetProgress.warn>i{background:linear-gradient(90deg,var(--warn),var(--bad))}
-.budgetProgressMarkers{position:absolute;inset:0;pointer-events:none}
-.budgetProgressMarkers span{position:absolute;top:0;bottom:0;width:1px;background:rgb(var(--tint-rgb)/.58);box-shadow:0 0 0 1px rgb(var(--shade-rgb)/.18);transform:translateX(-1px)}
-.budgetRuntimeCard{min-width:0;overflow:hidden;padding:14px 16px}
-.spendBudgetSection{display:grid;gap:10px;margin:0 0 12px}
-.spendBudgetEditor .budgetConfig{margin-top:0}
-.budgetConfig[hidden]{display:none}
-.spendBudgetSection .budgetForm.budgetInlineForm{grid-template-columns:minmax(220px,.7fr) minmax(0,1.3fr);column-gap:24px;row-gap:12px;align-items:start}
-.spendBudgetSection .budgetConfigHead,.spendBudgetSection .budgetInlineForm .budgetActions{grid-column:1/-1}
-.spendBudgetSection .budgetRuntimeFields{grid-column:2;grid-row:2}
-.spendBudgetSection .budgetSessionDefault{grid-template-columns:minmax(0,220px)}
-@media(max-width:900px){.spendBudgetSection .budgetForm.budgetInlineForm{grid-template-columns:1fr}.spendBudgetSection .budgetRuntimeFields{grid-column:auto;grid-row:auto}}
-.spendBudgetSection .budgetLead{padding:16px 18px 14px;background:linear-gradient(150deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg-rgb)/.96))}
-.spendBudgetSection .budgetLead:before{height:2px;opacity:.75}
-.budgetLeadTop{display:flex;align-items:center;justify-content:space-between;gap:14px}
-.budgetLeadTitle{display:flex;align-items:baseline;gap:10px;min-width:0;flex-wrap:wrap}
-.spendBudgetSection .budgetLead h2{font-size:var(--fs-16);margin:0}
-.budgetMonth{color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold);opacity:.82}
-.budgetMeta{color:var(--faint);font-size:var(--fs-12)}
-.budgetMeta:not(:empty):before{content:"·";margin-right:10px;color:var(--line3)}
-.spendBudgetSection .budgetLeadBody{grid-template-columns:minmax(0,1fr) minmax(250px,.42fr);gap:24px;align-items:center;margin-top:12px}
-.budgetFigure{display:grid;gap:6px}
-.budgetFigureLine{display:flex;align-items:baseline;gap:10px;flex-wrap:wrap;min-width:0}
-.spendBudgetSection .budgetSpendValue{font-size:var(--fs-readout-lg);font-weight:var(--fw-heavy);letter-spacing:-1px;line-height:1;margin:0;font-variant-numeric:tabular-nums}
-.budgetQualifier{align-self:center;padding:3px 8px;border:1px solid rgb(var(--orange-rgb)/.34);border-radius:var(--radius-pill);color:var(--warn);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
-.budgetQualifier[hidden]{display:none}
-.budgetOf{color:var(--dim);font-size:var(--fs-14)}
-.budgetOf b{color:var(--fg);font-size:var(--fs-18);font-weight:var(--fw-bold)}
-.budgetTotalNote{color:var(--faint);font-size:var(--fs-11)}
-.spendBudgetSection .budgetProgress{height:7px;margin-top:12px;border-color:rgb(var(--tint-rgb)/.08)}
-.budgetMeterFoot{display:flex;justify-content:space-between;gap:12px;flex-wrap:wrap;margin-top:8px;color:var(--dim);font-size:var(--fs-12)}
-.spendBudgetSection .budgetCoverage{margin:0;font-size:var(--fs-11)}
-.budgetStats{display:grid;gap:0;margin:0;padding-left:24px;border-left:1px solid var(--line)}
-.budgetStats>div{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:baseline;gap:2px 12px;padding:10px 0}
-.budgetStats>div+div{border-top:1px solid var(--line)}
-.budgetStats dt{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
-.budgetStats dd{margin:0}
-.budgetStats dd.mono{font-size:var(--fs-20);font-weight:var(--fw-heavy);text-align:right;font-variant-numeric:tabular-nums}
-.budgetStats dd.mono.warn{color:var(--warn)}
-.budgetStatNote{grid-column:1/-1;color:var(--faint);font-size:var(--fs-11);line-height:1.35}
-.budgetRuntimeList{display:grid;margin-top:6px}
-.budgetRuntime{--provider-color:var(--accent);display:grid;grid-template-columns:minmax(0,1fr) auto;gap:4px 12px;padding:8px 0;border-top:1px solid var(--line)}
-.budgetRuntime:first-child{border-top:0;padding-top:2px}
-.budgetRuntimeName{display:flex;align-items:center;gap:8px;font-weight:var(--fw-heavy)}
-.budgetRuntimeName:before{content:"";width:7px;height:7px;border-radius:var(--radius-round);background:var(--provider-color);box-shadow:0 0 9px var(--provider-color)}
-.budgetRuntimeValue{display:flex;align-items:baseline;justify-content:flex-end;gap:6px}
-.budgetRuntimeValue b{font-weight:var(--fw-heavy)}
-.budgetRuntimeValue small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-semibold)}
-.budgetRuntimeTrack{grid-column:1/-1;height:5px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.05);overflow:hidden}
-.budgetRuntimeTrack i{display:block;height:100%;border-radius:inherit;background:var(--provider-color)}
-.budgetConfig{min-width:0;margin-top:12px;transition:border-color .18s ease,box-shadow .18s ease}
-.budgetConfig.attention{border-color:rgb(var(--signal-rgb)/.62);box-shadow:var(--focus-ring),var(--shadow-soft)}
-.budgetConfigHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px}
-.budgetConfigHead .subline{margin-top:3px}
-.budgetForm{display:grid;grid-template-columns:minmax(300px,.75fr) minmax(440px,1.15fr) auto;gap:14px;margin-top:12px;align-items:end}
-.budgetFormGroup{min-width:0;margin:0;padding:0;border:0}
-.budgetFormGroup legend{width:100%;padding:0 0 6px;border-bottom:1px solid var(--line);color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
-.budgetForm label{display:grid;gap:4px}
-.budgetForm label span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.budgetForm input[type=number],.budgetForm input[type=text]{width:100%;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:var(--fs-12)/1.2 var(--font-mono)}
-.budgetForm input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.budgetActions{display:grid;align-content:end;justify-items:start;gap:6px;min-width:128px;padding:0;border:0}
-.budgetActions .tbtn{white-space:nowrap}
-.budgetActions .settingsStatus{font-size:var(--fs-11);line-height:1.25}
-.budgetCoverage{margin-top:6px;color:var(--dim);font-size:var(--fs-11)}
-.budgetCoverage.warn{color:var(--warn)}
-.budgetForm.budgetInlineForm{grid-template-columns:1fr;gap:10px;margin-top:12px;align-items:stretch}
-.budgetInlineForm .budgetActions{display:flex;align-items:center;justify-content:flex-start;gap:8px;min-width:0;padding-top:8px;border-top:1px solid var(--line)}
-.budgetInlineForm .budgetRuntimeList{grid-template-columns:1fr;gap:0;margin-top:0}
-.budgetRuntimeHead{display:grid;grid-template-columns:minmax(90px,.6fr) minmax(135px,1fr) minmax(100px,.8fr);gap:12px;padding:6px 0;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.budgetRuntime{grid-template-columns:minmax(90px,.6fr) minmax(135px,1fr) minmax(100px,.8fr);grid-template-areas:"name value input";gap:4px 12px;align-items:center;padding:8px 0;border:0;border-top:1px solid var(--line);border-radius:0;background:transparent}
-.budgetRuntime:first-child{border-top:1px solid var(--line);padding-top:8px}
-.budgetRuntimeName{grid-area:name}
-.budgetRuntimeValue{grid-area:value;align-self:start;display:flex;gap:6px;justify-content:flex-start;justify-items:start}
-.budgetRuntimeTrack{grid-area:value;grid-column:auto;align-self:end;height:3px;transform:translateY(2px)}
-.budgetRuntimeInput{grid-area:input;align-self:center;display:grid;gap:4px}
-.budgetRuntimeInput span{display:none;font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.budgetConfigHead{display:grid;grid-template-columns:minmax(108px,1fr) auto;align-items:center;gap:14px}
-.budgetConfigHead .subline{margin-top:3px}
-.budgetAlertInline{display:flex;align-items:center;justify-content:flex-end;gap:8px;min-height:32px}
-.budgetAlertTitle{color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);white-space:nowrap}
-.budgetThresholds{display:flex;align-items:center;gap:4px}
-.budgetThresholds label{position:relative;display:block}
-.budgetForm .budgetThresholds input[type=number]{width:46px;padding:6px 14px 6px 4px;text-align:right;appearance:textfield}
-.budgetThresholds input::-webkit-inner-spin-button,.budgetThresholds input::-webkit-outer-spin-button{margin:0;appearance:none}
-.budgetForm .budgetThresholds label span{position:absolute;right:5px;top:50%;transform:translateY(-50%);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono);pointer-events:none}
-.budgetNotifySwitch{position:relative;display:flex!important;align-items:center;cursor:pointer}
-.budgetNotifySwitch input{position:absolute;width:1px;height:1px;opacity:0;pointer-events:none}
-.budgetNotifySwitch input:checked+.sw{background:var(--good)}
-.budgetNotifySwitch input:checked+.sw:after{left:16px}
-.budgetNotifySwitch input:focus-visible+.sw{outline:2px solid var(--accent);outline-offset:2px}
-.budgetForm.budgetInlineForm{margin-top:0}
-.budgetSessionDefault{display:grid;grid-template-columns:minmax(160px,220px);gap:12px;align-items:end;margin-top:8px}
-.settingsPricing{grid-column:1/-1}
-.settingsPricing .agentAccessBadge[hidden]{display:none}
-.modelPricingProvenance{display:flex;align-items:center;gap:6px;flex-wrap:wrap;margin-top:8px;color:var(--faint);font-size:var(--fs-11)}
-.modelPricingProvenance a{color:var(--dim);text-decoration:none}
-.modelPricingProvenance a:hover{color:var(--accent);text-decoration:underline}
-.modelPriceScope{display:flex;align-items:end;gap:12px;flex-wrap:wrap;margin:12px 0 0;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025)}
-.modelPriceScope legend{position:static;width:100%;height:auto;padding:0;margin:0;overflow:visible;clip:auto;white-space:normal;border:0;color:var(--fg);font-size:var(--fs-11);font-weight:var(--fw-heavy)}
-.modelPriceScopeOptions{display:flex;border:1px solid var(--line2);border-radius:var(--radius-md);padding:2px;background:rgb(var(--shade-rgb)/.14)}
-.modelPriceScopeOptions label{position:relative;display:flex;cursor:pointer}
-.modelPriceScopeOptions input{position:absolute;opacity:0;pointer-events:none}
-.modelPriceScopeOptions span{padding:6px 10px;border-radius:var(--radius-sm);color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-heavy)}
-.modelPriceScopeOptions input:checked+span{background:rgb(var(--signal-rgb)/.16);color:var(--fg);box-shadow:var(--inset)}
-.modelPriceScopeOptions input:focus-visible+span{outline:2px solid var(--accent);outline-offset:1px}
-.modelPriceEffective{display:grid;gap:4px;margin-left:auto}
-.modelPriceEffective span{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
-.modelPriceEffective input{width:190px;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 6px;font:var(--fs-11)/1.2 var(--font-mono);color-scheme:dark}
-.modelPriceEffective input:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.modelPriceEffective input:disabled{opacity:.45}
-.modelPriceScope>span{flex:1 1 100%;color:var(--dim);font-size:var(--fs-12)}
-#model-price-selection-count{color:var(--fg);font-weight:var(--fw-bold)}
-.modelPriceScope.history{border-color:rgb(var(--orange-rgb)/.48);background:rgb(var(--orange-rgb)/.07)}
-.modelPriceScope.history>span{color:var(--warn)}
-.modelPriceTabs{display:flex;gap:3px;width:max-content;max-width:100%;overflow-x:auto;margin-top:12px;padding:3px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--shade-rgb)/.14);scrollbar-width:none}
-.modelPriceTabs:empty{display:none}
-.modelPriceTabs button{display:flex;align-items:center;gap:8px;border:0;border-radius:var(--radius-sm);background:transparent;color:var(--dim);padding:6px 12px;font:inherit;font-size:var(--fs-12);font-weight:var(--fw-heavy);white-space:nowrap;cursor:pointer}
-.modelPriceTabs button:hover{color:var(--fg);background:rgb(var(--signal-rgb)/.07)}
-.modelPriceTabs button[aria-selected=true]{background:rgb(var(--signal-rgb)/.16);color:var(--fg);box-shadow:var(--inset)}
-.modelPriceTabs button:focus-visible{outline:2px solid var(--accent);outline-offset:1px}
-.modelPriceTabs .count{color:var(--faint);font:var(--fs-11)/1 var(--font-mono)}
-.modelPriceTabs .edited{width:6px;height:6px;border-radius:var(--radius-round);background:var(--warn)}
-.modelPriceTable tr[hidden]{display:none!important}
-.modelPriceTableWrap{overflow:auto;max-height:min(460px,58vh);overscroll-behavior:contain;margin-top:8px;border:1px solid var(--line);border-radius:var(--radius-md)}
-.modelPriceTable{min-width:1030px}
-.modelPriceTable th{white-space:nowrap}
-.modelPriceTable td{vertical-align:middle}
-.modelPriceTable tr.selected{outline:1px solid rgb(var(--signal-rgb)/.58);outline-offset:-1px;background:rgb(var(--signal-rgb)/.055)}
-.modelPriceSelectCell{width:54px;text-align:center}
-.modelPriceSelectCell input{width:16px;height:16px;accent-color:var(--accent);cursor:pointer}
-.modelPriceModel{display:grid;gap:3px;min-width:205px}
-.modelPriceModel code{font-size:var(--fs-12);color:var(--fg)}
-.modelPriceSource{font-size:var(--fs-11);color:var(--faint);text-transform:capitalize}
-.modelPriceLifecycle{justify-self:start;border:0;background:transparent;color:var(--accent);padding:1px 0;text-align:left;font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);line-height:1.3;cursor:pointer}
-.modelPriceLifecycle:hover{text-decoration:underline}
-.modelPriceLifecycle:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:var(--radius-2xs)}
-.modelPriceInput{width:90px;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 6px;font:var(--fs-11)/1.2 var(--font-mono)}
-.modelPriceInput:focus,.modelPriceAdd input:focus,.modelPriceAdd select:focus{outline:none;border-color:var(--accent);box-shadow:var(--focus-ring)}
-.modelPriceAdd{display:grid;grid-template-columns:150px minmax(180px,1.4fr) repeat(4,minmax(105px,.65fr)) auto;gap:8px;align-items:end;margin-top:14px;padding-top:12px;border-top:1px solid var(--line)}
-.modelPriceAdd label{display:grid;gap:4px;min-width:0}
-.modelPriceAdd label span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.modelPriceAdd input,.modelPriceAdd select{width:100%;min-width:0;border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:var(--fs-11)/1.2 var(--font-mono)}
-.modelPriceAdd select{font-family:inherit}
-.discountCue{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap;margin-top:12px;padding:10px 12px;border:1px solid rgb(var(--signal-rgb)/.35);border-radius:var(--radius-md);background:rgb(var(--signal-rgb)/.07);color:var(--dim);font-size:var(--fs-12)}
-.discountCue.active{border-color:var(--line);background:rgb(var(--tint-rgb)/.03)}
-.discountCue b{color:var(--fg)}
-.discountCue .discountCueText{display:grid;gap:2px;min-width:0}
-.discountCue .discountCueActions{display:flex;gap:8px;align-items:center}
-.discountCueList{display:flex;gap:6px;flex-wrap:wrap;align-items:center}
-.discountLink{border:0;background:none;padding:0;color:var(--faint);font:inherit;font-size:var(--fs-11);cursor:pointer;text-decoration:underline}
-.discountCard,.spendBudgetEditor{min-width:0}
-.discountCard .modelPriceTable{min-width:760px}
-.discountCard h2{font-size:var(--fs-16);margin:0}
-.discountAdd{grid-template-columns:repeat(auto-fill,minmax(150px,1fr))}
-.discountAdd .tbtn{justify-self:start;align-self:end;padding:6px 12px}
-.discountAdd .hint{display:block;font-size:var(--fs-11);color:var(--faint);text-transform:none;font-weight:var(--fw-medium)}
-.discountMore{margin-top:12px;border-top:1px solid var(--line);padding-top:10px}
-.discountMore summary{cursor:pointer;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-heavy)}
-.discountMore p{margin:8px 0;color:var(--faint);font-size:var(--fs-12)}
-.discountMore code{color:var(--dim)}
-.discountApps{display:flex;gap:12px;flex-wrap:wrap}
-.discountApps label{display:grid;gap:4px}
-.discountApps label span{font-size:var(--fs-11);text-transform:uppercase;color:var(--faint);font-weight:var(--fw-heavy)}
-.discountApps select{border:1px solid var(--line2);background:rgb(var(--tint-rgb)/.045);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:inherit;font-size:var(--fs-12)}
-.modelPriceAdd .tbtn{height:31px;white-space:nowrap}
-.modelPricingFooter{display:flex;align-items:center;gap:10px;justify-content:flex-end;margin-top:12px;padding-top:12px;border-top:1px solid var(--line)}
-.modelPricingFooter .settingsStatus{margin-right:auto}
-.modelPricingFooter .tbtn:disabled{opacity:.42;cursor:not-allowed}
-.modelPricingEmpty{padding:18px;text-align:center;color:var(--faint)}
-.softwareUpdates{display:grid;gap:8px;padding:12px 16px!important}
-.softwareUpdateHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
-.softwareUpdateHead h2{margin-top:2px}
-.softwareUpdateHead p{margin-top:3px;color:var(--dim);font-size:var(--fs-12);line-height:1.4}
-.softwareUpdateToggle{display:flex;align-items:flex-start;gap:8px;padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025);cursor:pointer}
-.softwareUpdateToggle input{margin-top:2px;accent-color:var(--accent)}
-.softwareUpdateToggle span{display:grid;gap:1px}
-.softwareUpdateToggle b{font-size:var(--fs-13)}
-.softwareUpdateToggle small{color:var(--faint);font-size:var(--fs-11);line-height:1.35}
-.softwareUpdateActions{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:10px}
-.softwareUpdateActions .tbtn:disabled{opacity:.45;cursor:not-allowed}
-.softwareUpdateActions .settingsStatus{width:auto;min-width:0}
-.softwareUpdateMeta{justify-self:end;color:var(--faint);font:var(--fs-11)/1.4 var(--font-mono);white-space:nowrap}
-.settingsMap:before,.agentAccess:before,.budgetLead:before{display:none}
-.settingsPageContent .agentAccessHead h2{font-size:var(--fs-16);margin:0}
-.settingsPageContent :is(.learnSectionHead,.softwareUpdateHead) h2.fieldtip{display:flex;width:fit-content;margin:0}
-.workSettings>.softwareUpdateHead{margin-bottom:14px}
-.workSettings>.softwareUpdateHead .subline{margin-top:4px}
-.softwareUpdateToggles{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}
-.softwareUpdateToggle:has(input:disabled){opacity:.55;cursor:not-allowed}
-@media(max-width:900px){.modelPriceAdd{grid-template-columns:repeat(2,minmax(0,1fr))}.modelPriceAdd .tbtn{justify-self:start}.softwareUpdateToggles{grid-template-columns:1fr}}
-@media(max-width:700px){.modelPriceTableWrap{overflow:visible;border:0}.modelPriceTable{display:block;min-width:0}.modelPriceTable thead{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.modelPriceTable tbody{display:grid;gap:10px}.modelPriceTable tr{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px;padding:10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02)}.modelPriceTable td{display:grid;gap:4px;padding:0;border:0;text-align:left}.modelPriceTable td:before{content:attr(data-label);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.modelPriceTable td:nth-child(1){grid-column:1;grid-row:1}.modelPriceTable td:nth-child(2){grid-column:1/-1;grid-row:2}.modelPriceTable td:nth-child(3){grid-column:2;grid-row:1}.modelPriceTable td:nth-child(n+4){grid-column:auto}.modelPriceTable .badge{justify-self:start}.modelPriceSelectCell{width:auto;text-align:left}.modelPriceModel{min-width:0}.modelPriceInput{width:100%}.modelPricingEmpty{display:block!important;grid-column:1/-1!important}.modelPriceScopeOptions{width:100%}.modelPriceScopeOptions label{flex:1}.modelPriceScopeOptions span{width:100%;text-align:center}.modelPriceEffective{width:100%;margin-left:0}.modelPriceEffective input{width:100%}.modelPricingFooter{align-items:flex-start;flex-direction:column}.modelPricingFooter .settingsStatus{margin-right:0}}
-@media(max-width:520px){.modelPriceAdd{grid-template-columns:1fr}.modelPriceScope .modelPriceEffective{width:100%;margin-left:0;justify-content:space-between}.modelPriceEffective input{width:min(210px,62vw)}}
-@media(max-width:520px){.updateNotice{right:14px;bottom:14px;max-width:calc(100vw - 28px)}.updateReady .toastbox{bottom:66px}.softwareUpdateHead{display:block}.softwareUpdateHead .agentAccessBadge{display:inline-block;margin-top:6px}.softwareUpdateActions{grid-template-columns:1fr;align-items:stretch;gap:6px}.softwareUpdateActions .tbtn{width:100%}.softwareUpdateMeta{justify-self:start;white-space:normal}}
-.spark .b.estimated{background:repeating-linear-gradient(135deg,var(--accent) 0 5px,rgb(var(--signal-rgb)/.28) 5px 10px)}
-.capFilters{grid-template-columns:minmax(220px,1fr) auto auto minmax(130px,auto)}
-.capFilters select{border:1px solid var(--line2);background:var(--panel);color:var(--fg);border-radius:var(--radius-sm);padding:6px 8px;font:inherit;font-weight:var(--fw-bold);color-scheme:dark}
-@media(max-width:900px){.section-h{flex-wrap:wrap}}
-@media(max-width:1120px){.hero{grid-template-columns:1fr}.costcard{min-height:0}.overview{grid-template-columns:repeat(2,minmax(0,1fr))}}
-@media(max-width:900px){.budgetLeadBody{grid-template-columns:1fr}}
-@media(max-width:980px){.budgetForm{grid-template-columns:minmax(280px,.8fr) minmax(0,1.2fr)}.budgetActions{grid-column:1/-1;display:flex;align-items:center;justify-items:normal;padding-top:8px;border-top:1px solid var(--line)}}
-@media(max-width:1120px){.previewRunGrid{grid-template-columns:minmax(0,1.5fr) minmax(280px,.7fr)}.previewKpis{grid-template-columns:repeat(3,minmax(0,1fr))}}
-.currentSessionGrid{gap:10px}
-.currentSessionCard{min-height:190px;padding:16px 18px 14px}
-.currentSessionIdentity{margin-top:14px}
-.currentSessionIdentity h3{font-size:var(--fs-18)}
-.currentSessionMetrics{gap:12px;margin-top:14px;padding-top:12px}
-.currentSessionMetric b{margin-top:4px;font-size:var(--fs-18)}
-.currentSessionMetric b.mono{font-size:var(--fs-18)}
-.currentSessionContextValue{display:flex;align-items:flex-end;gap:8px;min-width:0}
-.currentSessionContextValue b{flex:0 0 auto}
-.currentSessionContextUnavailable{display:block;min-width:0;margin:0 0 2px;color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.1 var(--font-mono);letter-spacing:.02em;white-space:nowrap}
-.currentSessionContextSpark{--context-tone:var(--harness);display:block;flex:1 1 44px;width:auto;min-width:30px;max-width:88px;height:20px;margin:0 0 1px;overflow:visible}
-.currentSessionContextSpark.watch{--context-tone:var(--warn)}
-.currentSessionContextSpark.high{--context-tone:var(--bad)}
-.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-20)}
-.currentSessionContextSpark{height:22px}
-.currentSessionContextBaseline{fill:none;stroke:rgb(var(--tint-rgb)/.1);stroke-width:1;vector-effect:non-scaling-stroke}
-.currentSessionContextBar{fill:var(--harness);opacity:.42}
-.currentSessionContextBar.watch{fill:var(--warn);opacity:.78}
-.currentSessionContextBar.high{fill:var(--bad);opacity:.86}
-.currentSessionContextBar.latest{opacity:1;filter:drop-shadow(0 0 2px color-mix(in srgb,var(--harness) 60%,transparent))}
-.currentSessionContextBar.watch.latest{filter:drop-shadow(0 0 2px rgb(var(--orange-rgb)/.48))}
-.currentSessionContextBar.high.latest{filter:drop-shadow(0 0 2px rgb(var(--red-rgb)/.52))}
-@media(max-width:1120px){.currentSessionGrid{grid-template-columns:repeat(2,minmax(0,1fr))}}
-@media(max-width:1120px) and (min-width:901px){.globalControls{grid-template-columns:minmax(220px,1fr) minmax(190px,.8fr) minmax(150px,.55fr)}.filterSort{grid-column:1/3}.filterCount{align-self:end}}
-@media(max-width:900px){.logsSummary{grid-template-columns:1fr}.logKpis,.modelHero{grid-template-columns:repeat(2,minmax(0,1fr))}.modelHead{align-items:flex-start;flex-direction:column}.modelControls{width:100%;grid-template-columns:repeat(2,minmax(0,1fr))}.efficiencySupport{grid-template-columns:repeat(2,minmax(0,1fr))}.efficiencyHead{align-items:flex-start;flex-direction:column}.efficiencyRange{width:100%;min-width:0}}
-@media(max-width:900px){.budgetForm{grid-template-columns:1fr}}
-@media(max-width:900px){.wrap{padding:14px}.top{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:8px 8px;padding-top:8px}.top .brand{grid-column:1/-1;min-width:0}.top .tabs{grid-column:1/-1;justify-self:stretch;justify-content:flex-start;width:100%;max-width:100%;overflow-x:auto}.top .spacer{display:none}.top .notify{grid-column:3;justify-self:end}.globalControls,.capHero,.capFilters,.agentClients,.budgetDashboard{grid-template-columns:1fr}.globalControls .seg,.capFilters .seg{justify-content:flex-start}.globalMeta{white-space:normal}.srow{grid-template-columns:26px 132px minmax(0,1fr) auto 28px}.srow .models{display:none}.meter{font-size:var(--fs-44);overflow-wrap:anywhere}.costcard .meter{font-size:var(--fs-56)}.sessionhead{flex-wrap:wrap}.sessid{max-width:100%}.pill{white-space:normal}.statgrid{grid-template-columns:repeat(2,minmax(0,1fr))}.dailyHead{align-items:flex-start;flex-direction:column}.agentDiscovery{align-items:flex-start;flex-wrap:wrap}.agentAccessHead{display:block}.agentAccessBadge{display:inline-block;margin-top:10px}}
-@media(max-width:900px){.previewHead{align-items:flex-start;flex-direction:column}.previewRunGrid{grid-template-columns:1fr}.settingsMap{grid-template-columns:repeat(2,minmax(0,1fr))}.settingsMap button{border:1px solid var(--line);border-radius:var(--radius-sm);padding:8px}.previewChartSlot .chart{height:250px}.previewKpis{grid-template-columns:repeat(3,minmax(0,1fr))}}
-@media(max-width:520px){body{overflow-x:hidden}.tab,.seg button{padding:6px 10px}.top{grid-template-columns:minmax(0,1fr) auto}.top .notify{grid-column:1/-1;justify-self:start}.commandPalette{width:calc(100vw - 20px)}.commandSearch{padding:12px}.commandFooter{justify-content:flex-start;flex-wrap:wrap}.commandDescription{white-space:normal}.sessionStart{grid-template-columns:1fr;gap:3px}.overview,.modelHero,.efficiencyHero{grid-template-columns:1fr;gap:8px}.efficiencySupport{grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}.efficiencyHeadline{min-height:226px;padding:16px}.efficiencyHeadline .v{font-size:var(--fs-36)}.efficiencyModelHead,.efficiencyEvidence{align-items:flex-start;flex-direction:column}.ov{padding:12px 12px}.stat .v,.ov .v{font-size:var(--fs-22)}.meter{font-size:var(--fs-44)}.costcard .meter{font-size:var(--fs-44)}.costcard .subline{white-space:normal}.costmeta,.statgrid,.modelControls{grid-template-columns:1fr}.repo{max-width:100%}.dailyHead{width:100%}.modelChart{height:230px}.modelTrendHead{display:block}.outputPair{display:block}.outputRate{justify-items:start;margin-top:4px}.settingsLexiconHead{display:block}.settingsStatus{width:100%;margin-left:0}}
-@media(max-width:520px){.previewHead h1{font-size:var(--fs-24)}.previewRunMeta{flex-wrap:wrap}.previewRunMeta .repo{max-width:100%;width:100%}.previewChartSlot #session-chart-module>.card{min-height:0}.previewChartSlot .chart{height:226px}.previewChartSlot .chartbar{align-items:flex-start}.previewChartSlot .chartbar .label{width:100%;margin:0}.previewKpis{grid-template-columns:repeat(2,minmax(0,1fr))}.previewKpi{min-height:82px;padding:10px}.previewKpi .v{font-size:var(--fs-18)}.previewCost{font-size:var(--fs-36)}.budgetForm,.settingsMap{grid-template-columns:1fr}.budgetLeadHeadActions{justify-content:flex-start;margin-top:10px}.learnSectionHead .budgetLeadHeadActions .tbtn{margin-top:0}.budgetConfigHead{display:block}.budgetActions .settingsStatus{width:auto}.budgetRuntimeValue{display:grid;gap:1px;justify-items:end}.settingsMap button{width:100%;margin:0}.settingsPageContent>.card{padding:12px}.settingsPageContent .modelPriceTableWrap{margin-left:-4px;margin-right:-4px}}
-@media(max-width:520px){.budgetRuntimeHead{display:none}.budgetRuntime{grid-template-columns:minmax(0,1fr) minmax(100px,108px);grid-template-areas:"name input" "value input";padding:8px 0}.budgetRuntime:first-child{padding-top:8px}.budgetRuntimeValue{justify-items:start}.budgetRuntimeInput span{display:block}}
-@media(max-width:520px){.budgetSpendValue{font-size:var(--fs-readout-xl)}}
-@media(max-width:520px){.previewStartStrip{grid-template-columns:1fr;gap:4px}.previewTokenSlot .legend{gap:8px}}
-@media(max-width:700px){.currentSessionGrid{grid-template-columns:1fr;gap:8px}.currentSessionCard{min-height:184px;padding:14px 14px 12px}.currentSessionIdentity{margin-top:12px}.currentSessionIdentity h3{font-size:var(--fs-18)}.currentSessionMetrics{grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;margin-top:12px;padding-top:10px}.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-16);letter-spacing:-.025em}.currentSessionContextValue{gap:4px}.currentSessionContextSpark{min-width:24px;max-width:58px;height:17px}.currentSessionCard.dropBefore{box-shadow:inset 0 4px 0 var(--harness),var(--shadow)}.currentSessionCard.dropAfter{box-shadow:inset 0 -4px 0 var(--harness),var(--shadow)}}
-@media(max-width:700px){.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-18)}.currentSessionContextSpark{height:19px}}
-/* shared-spectrum-system-v1 */
-/* spectrum-professional-finish-v2 */
-@font-face{font-family:"Tektur Local";src:url("/assets/fonts/Tektur-Variable.ttf") format("truetype");font-style:normal;font-weight:400 900;font-stretch:75% 100%;font-display:swap}
-body.spectrumApp{background:var(--spectrum-page)}
-body.spectrumApp:after{content:"";position:fixed;inset:-18%;z-index:-2;pointer-events:none;background:radial-gradient(34% 28% at 28% 22%,rgb(var(--signal-rgb)/calc(.13*var(--glow))),transparent 70%),radial-gradient(30% 26% at 78% 68%,rgb(var(--aura-rgb)/calc(.1*var(--glow))),transparent 70%),radial-gradient(26% 22% at 52% 96%,rgb(var(--signal-hi-rgb)/calc(.07*var(--glow))),transparent 70%);animation:atmosphereDrift 46s ease-in-out infinite alternate}
-@keyframes atmosphereDrift{0%{transform:translate3d(-3%,-2%,0) scale(1)}100%{transform:translate3d(3%,2%,0) scale(1.06)}}
-@keyframes foilDrift{0%{background-position:0 0}100%{background-position:200% 0}}
-@keyframes ionSheen{0%{transform:translateX(-120%)}100%{transform:translateX(220%)}}
-/* vertical-navigation-rail-v1 */
-body.spectrumApp .wrap{--navigation-rail-width:184px;display:grid;grid-template-columns:var(--navigation-rail-width) minmax(0,1320px);column-gap:20px;align-items:start;width:100%;max-width:1532px}
-body.spectrumApp .wrap>:not(.top){grid-column:2;min-width:0}
-body.spectrumApp .top{grid-column:1;grid-row:1;position:sticky;top:18px;z-index:20;display:flex;height:calc(100vh - 36px);min-height:520px;align-items:stretch;flex-direction:column;gap:12px;margin:0;padding:12px;border:1px solid var(--spectrum-border);border-radius:var(--radius-lg);background:radial-gradient(ellipse 120% 38% at 18% -4%,rgb(var(--signal-rgb)/.22),transparent 62%),radial-gradient(ellipse 110% 42% at 118% 84%,rgb(var(--aura-rgb)/.11),transparent 62%),linear-gradient(165deg,rgb(var(--panel-rgb)/.86),rgb(var(--bg-lift-rgb)/.84) 52%,rgb(var(--bg-rgb)/.9));box-shadow:var(--spectrum-depth-focus);backdrop-filter:blur(22px) saturate(1.25)}
-body.spectrumApp .top:before{content:"";position:absolute;inset:0 12px auto;height:1px;background:var(--spectrum-foil);background-size:200% 100%;opacity:.8;animation:foilDrift 14s linear infinite}
-body.spectrumApp .top .brand{flex:0 0 auto;min-width:0;padding:3px 2px 0}
-.brandCopy{display:grid;min-width:0;line-height:1.1}
-.brandName{overflow:hidden;text-overflow:ellipsis}
-body.spectrumApp .top .tabs{display:flex;min-width:0;max-width:100%;overflow:visible;flex:1;flex-direction:column;gap:4px;padding:10px 0 0;border:0;border-top:1px solid var(--line);border-radius:0;background:transparent;box-shadow:none;scrollbar-width:none}
-body.spectrumApp .top .tabs::-webkit-scrollbar{display:none}
-.navPrimary,.navSecondary{display:flex;flex-direction:column;gap:4px}
-.navSecondary{margin-top:auto;padding-top:10px;border-top:1px solid var(--line)}
-body.spectrumApp .top .tab{display:grid;width:100%;min-height:42px;grid-template-columns:18px minmax(0,1fr);align-items:center;gap:10px;padding:8px 10px;text-align:left}
-.tabIcon{width:18px;height:18px;fill:none;stroke:currentColor;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round}
-.tabLabel{min-width:0;overflow:hidden;text-overflow:ellipsis}
-body.spectrumApp .top>.spacer{display:none}
-@media(max-width:1180px){body.spectrumApp .wrap{--navigation-rail-width:68px;column-gap:16px;padding-right:18px;padding-left:18px}body.spectrumApp .top{padding:10px 8px}body.spectrumApp .top .brand{justify-content:center;padding-right:0;padding-left:0}.logo,.logo img{width:50px}body.spectrumApp .top .brandCopy,body.spectrumApp .top .tabLabel{display:none}body.spectrumApp .top .tab{display:grid;grid-template-columns:1fr;place-items:center;padding:8px}}
-@media(max-width:760px){body.spectrumApp .wrap{display:block;max-width:1320px;padding:12px 14px 64px}body.spectrumApp .wrap>:not(.top){min-width:0}body.spectrumApp .top{position:sticky;top:0;display:grid;height:auto;min-height:0;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:8px;margin:0 0 14px;padding:8px 0 10px;border:0;border-bottom:1px solid var(--spectrum-border);border-radius:0;background:radial-gradient(ellipse 62% 90% at 5% 0,rgb(var(--signal-rgb)/.16),transparent 70%),linear-gradient(180deg,var(--bg),var(--bg-lift));box-shadow:0 10px 26px rgb(var(--shade-rgb)/.28)}body.spectrumApp .top:before{inset:auto 0 0}body.spectrumApp .top .brand{grid-column:1;grid-row:1;justify-content:flex-start;padding:0}.logo,.logo img{width:58px}body.spectrumApp .top .brandCopy{display:grid}body.spectrumApp .top .tabs{grid-column:1/-1;grid-row:2;min-width:0;width:100%;overflow-x:auto;flex:none;flex-direction:row;gap:3px;padding:8px 0 0;border-top:1px solid var(--line)}.navPrimary,.navSecondary{display:contents}body.spectrumApp .top .tab{display:flex;width:auto;min-height:38px;grid-template-columns:none;gap:6px;padding:8px 10px;white-space:nowrap}body.spectrumApp .top .tabLabel{display:inline}}
-@media(max-width:760px){#view-models{overflow-x:clip}}
-@media(max-width:520px){.brandName{font-size:var(--fs-14)}}
-body.spectrumApp .seg{border-color:var(--spectrum-border);background:var(--spectrum-control);box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.055),0 6px 18px rgb(var(--shade-rgb)/.1)}
-body.spectrumApp .tab.on,body.spectrumApp .seg button.on{background:var(--spectrum-active);color:var(--on-accent);box-shadow:var(--spectrum-glow)}
-body.spectrumApp .top .tab{position:relative;overflow:hidden}
-body.spectrumApp .top .tab.on:after{content:"";position:absolute;inset:0 auto 0 0;width:40%;pointer-events:none;background:linear-gradient(100deg,transparent,rgb(var(--tint-rgb)/.42),transparent);transform:translateX(-120%);animation:ionSheen .9s var(--spectrum-ease) .08s 1 both}
-body.spectrumApp .tab.on:hover,body.spectrumApp .seg button.on:hover{background:var(--spectrum-active-hover)}
-body.spectrumApp .tab:hover:not(.on),body.spectrumApp .seg button:hover:not(.on){background:linear-gradient(135deg,rgb(var(--signal-rgb)/.105),rgb(var(--aura-rgb)/.055));color:var(--fg)}
-body.spectrumApp .card{border-color:var(--spectrum-border);background:var(--spectrum-card);box-shadow:var(--spectrum-shadow)}
-body.spectrumApp .card:hover{border-color:var(--spectrum-edge-hover);box-shadow:var(--spectrum-depth-focus),0 0 0 1px rgb(var(--signal-rgb)/.1),0 0 32px rgb(var(--signal-rgb)/calc(.1*var(--glow)))}
-body.spectrumApp .tbtn{border-color:rgb(var(--signal-rgb)/.3);background:radial-gradient(circle at 88% 0,rgb(var(--signal-hi-rgb)/.12),transparent 52%),linear-gradient(145deg,rgb(var(--signal-rgb)/.18),rgb(var(--signal-mid-rgb)/.075));box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.075),0 6px 16px rgb(var(--shade-rgb)/.12);transition:border-color .16s,background .16s,box-shadow .16s,color .16s}
-body.spectrumApp .tbtn:hover:not(:disabled){border-color:var(--spectrum-edge-hover);background:radial-gradient(circle at 88% 0,rgb(var(--signal-hi-rgb)/.17),transparent 52%),linear-gradient(145deg,rgb(var(--signal-rgb)/.25),rgb(var(--signal-mid-rgb)/.11));box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.1),0 8px 20px rgb(var(--signal-rgb)/.12)}
-/* After the spectrum button rules: the turn-on button must win their signal fill (see DESIGN.md Buttons). */
-:is(body,body.spectrumApp) .tbtn.go{padding:10px 18px;border-color:rgb(var(--green-rgb)/.7);background:var(--good);box-shadow:none;color:var(--on-accent-deep);font-size:var(--fs-14);font-weight:var(--fw-heavy)}
-:is(body,body.spectrumApp) .tbtn.go:hover:not(:disabled){border-color:var(--good);background:rgb(var(--green-rgb)/.86);box-shadow:none}
-:is(body,body.spectrumApp) .tbtn.go:focus-visible{outline:2px solid var(--good);outline-offset:2px}
-body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary){border-color:var(--spectrum-border);background:var(--spectrum-control);box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.035),0 5px 14px rgb(var(--shade-rgb)/.1)}
-body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary):hover{border-color:var(--spectrum-border-strong)}
-body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary):focus{outline:none;border-color:var(--signal-hi);box-shadow:0 0 0 3px rgb(var(--signal-rgb)/.16),0 9px 22px rgb(var(--signal-rgb)/.12)}
-body.spectrumApp :is(button,input,select,textarea,summary):focus-visible{outline:2px solid var(--signal-hi);outline-offset:2px}
-body.spectrumApp .meter{background:none;color:var(--signal-hi);-webkit-background-clip:initial;background-clip:initial}
-body.spectrumApp .tbl th,body.spectrumApp .modelTableWrap .tbl th,body.spectrumApp .capTableWrap .tbl th{background:linear-gradient(180deg,rgb(var(--panel-rgb)/.99),rgb(var(--bg-lift-rgb)/.99));box-shadow:inset 0 -1px 0 var(--spectrum-border)}
-body.spectrumApp .tbl tr:hover td{background:linear-gradient(90deg,rgb(var(--signal-rgb)/.055),rgb(var(--aura-rgb)/.025))}
-.spectrumPageHeadFrame{position:relative;width:100%;margin:0 0 16px}
-@property --ring-angle{syntax:"<angle>";inherits:false;initial-value:0deg}
-@keyframes ringSpin{to{--ring-angle:360deg}}
-@keyframes titleShimmer{0%{background-position:0 0}100%{background-position:100% 0}}
-body.spectrumApp .spectrumPageHeadFrame:before,body.spectrumApp .spectrumPageHeadFrame:after{content:"";position:absolute;inset:-1px;pointer-events:none;border-radius:var(--radius-md);background:conic-gradient(from var(--ring-angle),var(--ring));animation:ringSpin var(--ring-speed) linear infinite}
-body.spectrumApp .spectrumPageHeadFrame:before{z-index:1;padding:1px;-webkit-mask:linear-gradient(var(--black) 0 0) content-box,linear-gradient(var(--black) 0 0);-webkit-mask-composite:xor;mask:linear-gradient(var(--black) 0 0) content-box exclude,linear-gradient(var(--black) 0 0)}
-body.spectrumApp .spectrumPageHeadFrame:after{z-index:-1;opacity:calc(.32*var(--glow));filter:blur(16px)}
-.spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;height:138px;align-items:flex-start;justify-content:space-between;gap:24px;flex-direction:row;margin:0;padding:24px 28px;overflow:hidden;border:1px solid var(--spectrum-border-strong);border-radius:var(--radius-md);background:linear-gradient(116deg,rgb(var(--panel-rgb)/.995),rgb(var(--bg-lift-rgb)/.995) 52%,rgb(var(--bg-lift-rgb)/.99));box-shadow:var(--spectrum-depth-focus)}
-.spectrumPageHead:before{content:none}
-body.spectrumApp .spectrumPageHead:after{content:"";position:absolute;right:0;bottom:0;left:0;height:1px;background:var(--spectrum-foil);background-size:200% 100%;opacity:.9;box-shadow:0 0 14px rgb(var(--signal-hi-rgb)/calc(.5*var(--glow)));animation:foilDrift 9s linear infinite}
-body.spectrumApp .spectrumPageHead h1{background:linear-gradient(100deg,var(--fg) 0%,var(--fg) 30%,var(--signal-hi) 50%,var(--aura) 62%,var(--fg) 80%,var(--fg) 100%);background-size:250% 100%;-webkit-background-clip:text;background-clip:text;color:transparent;filter:drop-shadow(var(--title-glow));animation:titleShimmer 11s ease-in-out infinite alternate}
-.spectrumPageHeadCopy{position:relative;z-index:3;max-width:min(760px,72%);min-width:0}
-.hasPageActions .spectrumPageHeadCopy{max-width:min(560px,48%)}
-.spectrumPageHead h1{max-width:22ch;margin:0;color:var(--fg);font-family:var(--font-display);font-size:var(--fs-hero-fluid);font-stretch:88%;font-weight:var(--fw-semibold);line-height:.98;letter-spacing:-.035em;text-wrap:balance}
-.spectrumPageSubtitle{max-width:52ch;margin:6px 0 0;color:var(--dim);font-size:var(--fs-12);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.spectrumPageActions{position:absolute;z-index:5;right:30px;bottom:24px;display:flex;max-width:62%;align-items:flex-end;justify-content:flex-end}
-.pageSignalField{position:absolute;z-index:1;top:-46%;right:-8%;bottom:-48%;width:76%;overflow:hidden;pointer-events:none;opacity:.88;-webkit-mask-image:linear-gradient(90deg,transparent 0,var(--black) 23%,var(--black) 94%,transparent 100%);mask-image:linear-gradient(90deg,transparent 0,var(--black) 23%,var(--black) 94%,transparent 100%);transition:opacity .35s ease}
-.pageDither,.pageSignalFallback{position:absolute;inset:0}
-.pageDither{z-index:1;transform:scale(1.02)}
-.pageDither canvas{z-index:0!important;opacity:.94;filter:saturate(.92) contrast(1.05)}
-.pageSignalFallback{z-index:0;background:radial-gradient(circle,rgb(var(--fx-front-rgb)/.32) 0 1px,transparent 1.4px) 0 0/7px 7px,linear-gradient(118deg,transparent 16%,rgb(var(--fx-edge-a-rgb)/.14) 56%,rgb(var(--fx-back-rgb)/.16));opacity:.82;transition:opacity .35s ease}
-.pageDither[data-page-effect=ready]+.pageSignalFallback{opacity:.08}
-.pageHeroBorder{position:absolute;z-index:4;inset:0;overflow:hidden;pointer-events:none;border-radius:inherit;opacity:.88}
-.pageHeroBorder canvas{z-index:0!important;opacity:.9}
-.workTags{display:inline-flex;flex-wrap:wrap;gap:6px;min-width:0}
-.workTag{padding:3px 8px;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--signal-mid-rgb)/.1);color:var(--dim);font-size:var(--fs-11);white-space:nowrap}
-.workTag.pushback{border-color:rgb(var(--orange-rgb)/.45);color:var(--warn)}
-.workSrOnly{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}
-.workStatus{display:flex;align-items:center;justify-content:space-between;gap:14px;margin-bottom:10px;padding:12px 14px}
-.workStatusMain{display:flex;align-items:center;gap:12px;min-width:0}
-.workStatusText{display:grid;gap:2px;min-width:0}
-.workStatusText strong{font-size:var(--fs-13)}
-.currentSessionHints{display:grid;gap:6px;margin-top:14px}
-.currentSessionHint{display:-webkit-box;min-width:0;overflow:hidden;padding:6px 10px 6px 10px;border-left:2px solid var(--warn);border-radius:0 var(--radius-sm) var(--radius-sm) 0;background:rgb(var(--orange-rgb)/.07);color:var(--dim);font-size:var(--fs-12);line-height:1.45;-webkit-box-orient:vertical;-webkit-line-clamp:2}
-.currentSessionHint b{margin-right:6px;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.currentSessionHint small{font-size:inherit}
-.currentSessionHint[data-kind=premium_routine],.currentSessionHint[data-kind=effort_routine],.currentSessionHint[data-kind=long_thread]{border-left-color:var(--signal);background:rgb(var(--signal-rgb)/.07)}
-.workEnableCta{display:flex;align-items:center;gap:12px;margin:12px 0}
-.workEnableCta[hidden]{display:none}
-.workSetupSteps{display:flex;flex-wrap:wrap;gap:6px 16px;margin:8px 0 0;padding:0;list-style:none;color:var(--faint);font-size:var(--fs-12)}
-.workSetupSteps[hidden]{display:none}
-.workSetupSteps li::before{content:"○";margin-right:6px}
-.workSetupSteps li[data-state=done]{color:var(--dim)}
-.workSetupSteps li[data-state=done]::before{content:"✓";color:var(--good)}
-.workSetupSteps li[data-state=current]{color:var(--fg);font-weight:var(--fw-bold)}
-.workSetupSteps li[data-state=current]::before{content:"●";color:var(--accent)}
-.workSetupSteps li[data-state=failed]{color:var(--warn);font-weight:var(--fw-bold)}
-.workSetupSteps li[data-state=failed]::before{content:"!";color:var(--warn)}
-.workSetupBar{width:min(100%,420px);height:6px;margin-top:8px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.08);overflow:hidden}
-.workSetupBar[hidden]{display:none}
-.workSetupBar i{display:block;height:100%;width:0;border-radius:inherit;background:var(--accent);transition:width .4s}
-.workEnableCta small{color:var(--dim);font-size:var(--fs-12)}
-.workStatusText span{color:var(--dim);font-size:var(--fs-11)}
-.workStatusActions{display:flex;align-items:center;gap:8px;flex:0 0 auto}
-.workStatusActions .filterSelect{min-width:170px}
-.workStatusPill{flex:0 0 auto;padding:4px 10px;border:1px solid var(--line2);border-radius:var(--radius-pill);color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase}
-.workStatusPill::before{content:"";display:inline-block;width:7px;height:7px;margin-right:6px;border-radius:var(--radius-round);background:currentColor;vertical-align:1px}
-.workStatusPill[data-state=running]{color:var(--good);border-color:rgb(var(--green-rgb)/.45)}
-.workStatusPill[data-state=idle]{color:var(--signal-hi);border-color:rgb(var(--signal-rgb)/.4)}
-.workStatusPill:is([data-state=paused],[data-state=throttled],[data-state=backoff]){color:var(--warn);border-color:rgb(var(--orange-rgb)/.45)}
-.workStatusPill:is([data-state=setup_needed],[data-state=storage_error]){color:var(--bad);border-color:rgb(var(--red-rgb)/.45)}
-.workCardHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;margin-bottom:12px}
-.workCardHead h2{margin:0;font-size:var(--fs-14)}
-.workCardHead .filterControl{min-width:160px}
-.workCardHead .filterControl>span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase}
-.workRework,.workSizing{position:relative;padding:16px 16px}
-.workMixSplit{margin-top:16px}
-.workSuggestion{display:grid;gap:2px;text-align:left}
-.workSuggestion b{font-weight:var(--fw-semibold)}
-.workSuggestion small{color:var(--faint);font-size:var(--fs-11);line-height:1.4;white-space:normal}
-.workSizing{margin-top:10px}
-.workSwatch{display:inline-block;flex:0 0 auto;width:10px;height:10px;border-radius:var(--radius-xs);background:var(--swatch)}
-.workTableToggle{margin-top:12px;color:var(--dim);font-size:var(--fs-11)}
-.workTableToggle summary{cursor:pointer}
-.workTableWrap{overflow:auto;max-height:460px}
-.workTableWrap .tbl th{position:sticky;top:0;z-index:1;background:var(--panel);white-space:nowrap}
-.workTableWrap .tbl td{vertical-align:middle}
-.workMuted{color:var(--faint)}
-.workProgressNote{margin:0}
-.workProgressNote strong[hidden]{display:none}
-.workEmpty{padding:18px 4px;color:var(--faint);font-size:var(--fs-12);text-align:center}
-.workSizingGrid{display:grid;grid-template-columns:110px repeat(3,minmax(0,1fr));gap:6px}
-.workSizingHead{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase;align-self:end;padding:0 4px 2px}
-.workSizingCell{min-height:78px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025)}
-.workSizingCell strong{display:block;font-size:var(--fs-16)}
-.workSizingCell span{display:block;color:var(--dim);font-size:var(--fs-11);margin-top:2px}
-.workSizingCell[data-flag]:not([data-flag=""]){border-color:rgb(var(--orange-rgb)/.5);background:rgb(var(--orange-rgb)/.07)}
-.workFlag{display:inline-flex;align-items:center;gap:4px;margin-top:6px;color:var(--warn);font-size:var(--fs-11);font-weight:var(--fw-bold)}
-.workSizingRowHead{display:flex;align-items:center;padding:0 4px;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-bold)}
-@media(max-width:1180px){.workStatus{flex-wrap:wrap}}
-.workSettingsGrid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}
-.workSettingsGrid input,.workAreaRow input{width:100%;min-width:0;padding:8px 10px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.035);color:var(--fg);font:inherit;font-size:var(--fs-12)}
-.workSettingsGrid .settingsField>span{font-size:var(--fs-11);color:var(--faint);font-weight:var(--fw-heavy);text-transform:uppercase}
-.workSetupHint{margin-top:10px;color:var(--dim);font-size:var(--fs-11)}
-.workSetupHint code{padding:2px 6px;border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.06);color:var(--fg)}
-.workSettingsActions{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:12px;margin-top:12px}
-.workActionGroup{display:flex;flex-wrap:wrap;align-items:center;gap:8px}
-.workSettingsActions .settingsStatus{width:auto;min-width:0;text-align:right}
-.workSettingsActions .tbtn,.workSettingsManage .tbtn,.workSettingsManage .filterSelect{height:32px;padding-top:0;padding-bottom:0}
-.workSettingsActions .tbtn:disabled{opacity:.45;cursor:not-allowed}
-.workSettingsManage{margin-top:16px;padding-top:12px;border-top:1px solid var(--line)}
-.workAreasHead{display:flex;align-items:baseline;gap:10px;margin-top:16px}
-.workAreasHead h3{margin:0;font-size:var(--fs-13)}
-.workAreas{display:grid;gap:6px;margin-top:8px}
-.workAreaRow{display:grid;grid-template-columns:14px minmax(140px,220px) minmax(0,1fr) auto;align-items:center;gap:8px}
-.workAreaRow .tbtn{padding:6px 8px}
-@media(max-width:1180px){.workSettingsGrid{grid-template-columns:repeat(2,minmax(0,1fr))}}
-.workFit{position:relative;padding:16px 16px;margin-top:10px}
-.workOutcomeBar{display:flex;gap:2px;height:14px;margin-bottom:12px;border-radius:var(--radius-xs);overflow:hidden;background:rgb(var(--tint-rgb)/.03)}
-.workOutcomeBar i{display:block;height:100%;min-width:2px;background:var(--swatch)}
-.workFit .workTableWrap,.workBreakdown .workTableWrap{max-height:none}
-.workFitBest{display:inline-block;margin-left:6px;padding:1px 6px;border:1px solid rgb(var(--green-rgb)/.5);border-radius:var(--radius-pill);color:var(--good);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.04em}
-.workFitCell small{display:block;color:var(--faint);font-size:var(--fs-11)}
-[data-drill]{cursor:pointer}
-tr[data-drill]:hover td,td:has(>.workDrillBtn):hover,.workSizingCell:has(>.workDrillBtn):hover{background:rgb(var(--tint-rgb)/.035)}
-.workDrillBtn{display:block;width:100%;height:100%;margin:0;padding:0;border:0;border-radius:var(--radius-xs);background:none;color:inherit;font:inherit;text-align:inherit;cursor:pointer}
-.workDrillBtn:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
-.workSizingCell:has(>.workDrillBtn){padding:0}
-.workSizingBtn{min-height:78px;padding:10px 10px;border-radius:var(--radius-md)}
-.workSizingBtn:focus-visible{outline-offset:-2px}
-
-.workAxisText{fill:var(--faint);font:var(--fs-11) var(--font-sans)}
-.workTrendWrap{flex:1;display:flex;align-items:center;margin:2px 0 4px}
-.workTrend{display:block;width:100%;height:auto;overflow:visible}
-.workGridLine{stroke:rgb(var(--tint-rgb)/.07)}
-.workLine{fill:none;stroke:var(--signal);stroke-width:2;stroke-linejoin:round;stroke-linecap:round}
-.workPoint{fill:var(--signal);stroke:var(--panel);stroke-width:2}
-.workPoint.few{fill:var(--panel);stroke:var(--signal)}
-.workTrendAvg{stroke:var(--aura);stroke-width:1;stroke-dasharray:4 4;opacity:.8}
-.workTrendAvgText{fill:var(--aura);font:var(--fw-semibold) var(--fs-11) var(--font-sans);paint-order:stroke;stroke:var(--panel);stroke-width:4px;stroke-linejoin:round}
-.workSplit{display:grid;grid-template-columns:minmax(0,1.2fr) minmax(0,1fr);gap:24px;align-items:start}
-.workSplit>div{min-width:0}
-.workSubhead{display:flex;align-items:baseline;justify-content:space-between;gap:10px;margin:0 0 8px}
-.workSubhead h3{margin:0;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.workSubhead span{color:var(--faint);font-size:var(--fs-11)}
-.workScore{width:100%;border-collapse:collapse;font-size:var(--fs-12)}
-.workScore th{padding:0 8px 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase;text-align:right;white-space:nowrap}
-.workScore th:first-child{text-align:left;padding-left:0}
-.workScore td{padding:0;border-top:1px solid var(--line);text-align:right;white-space:nowrap}
-.workScore td:first-child{text-align:left}
-.workScore tr:hover td{background:rgb(var(--tint-rgb)/.03)}
-.workScore .workDrillBtn{display:flex;align-items:center;gap:8px;padding:8px 8px 8px 0}
-.workScore td>span{display:block;padding:8px}
-.workLowest{margin-left:6px;padding:1px 6px;border:1px solid rgb(var(--green-rgb)/.45);border-radius:var(--radius-pill);color:var(--good);font:var(--fw-heavy) var(--fs-11) var(--font-sans);font-style:normal;letter-spacing:.04em;text-transform:uppercase;vertical-align:1px}
-.workScoreDot{flex:0 0 auto;width:8px;height:8px;border-radius:var(--radius-round);background:var(--swatch)}
-.workScoreName{display:grid;min-width:0;text-align:left}
-.workScoreName b{overflow:hidden;text-overflow:ellipsis;font-weight:var(--fw-bold)}
-.workScoreName small{color:var(--faint);font-size:var(--fs-11)}
-.workScoreKinds{display:flex;flex-wrap:wrap;align-items:center;justify-content:flex-end;gap:4px;padding:4px 8px;white-space:normal}
-.workScoreKinds .chip{white-space:nowrap}
-.workScoreKinds small{color:var(--faint);font-size:var(--fs-11)}
-.workMeter{display:inline-grid;grid-template-columns:64px 34px;align-items:center;gap:6px}
-.workMeter i{display:block;height:6px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.06);overflow:hidden}
-.workMeter i b{display:block;height:100%;border-radius:var(--radius-xs);background:var(--meter,var(--signal))}
-.workMeter[data-few=true]{opacity:.5}
-.workMix{display:grid;gap:10px}
-.workMixRow{display:grid;grid-template-columns:96px minmax(0,1fr) 78px;align-items:center;gap:10px}
-.workMixLabel{color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.workMixTotal{text-align:right;font:var(--fw-semibold) var(--fs-12) var(--font-sans);color:var(--fg)}
-.workStack{display:flex;gap:2px;height:22px;border-radius:var(--radius-sm);overflow:hidden;background:rgb(var(--tint-rgb)/.03)}
-.workStack button{position:relative;min-width:3px;height:100%;padding:0;border:0;background:var(--seg);cursor:pointer}
-.workStack button:hover,.workStack button:focus-visible{filter:brightness(1.25);outline:none}
-.workStack button[data-flag=true]{background:repeating-linear-gradient(135deg,var(--seg) 0 6px,rgb(var(--bg-rgb)/.5) 6px 9px);box-shadow:inset 0 0 0 1.5px var(--warn)}
-.workStack button[data-flag=true] span{inset:auto;left:50%;top:50%;padding:1px 6px;border-radius:var(--radius-xs);background:rgb(var(--bg-rgb)/.86);color:var(--fg);transform:translate(-50%,-50%)}
-.workStack button span{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;color:var(--on-accent-deep);font:var(--fw-bold) var(--fs-11) var(--font-sans);pointer-events:none}
-.workMixLegend{display:flex;flex-wrap:wrap;gap:4px 14px;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.workMixLegend span{display:inline-flex;align-items:center;gap:6px}
-.workMixLegend i{display:inline-block;width:10px;height:10px;border-radius:var(--radius-xs);background:var(--swatch)}
-.workMixLegend i.flag{background:repeating-linear-gradient(135deg,var(--w-tier-premium) 0 4px,rgb(var(--bg-rgb)/.55) 4px 6px);box-shadow:inset 0 0 0 1px var(--warn)}
-.workMixLegend small{color:var(--faint);font-size:var(--fs-11);margin-left:2px}
-.workMixLegend i.flag.effort{background:repeating-linear-gradient(135deg,var(--w-tier-premium) 0 4px,rgb(var(--bg-rgb)/.55) 4px 6px)}
-.workSuggestCards{display:grid;grid-template-columns:1.3fr 1fr 1fr;gap:14px;margin:16px 0 12px}
-.workEffortModels{margin:4px 0 14px;padding-top:12px;border-top:1px solid var(--line)}
-.workEffortModels .workSubhead{align-items:center;margin-bottom:10px}
-.workEffortGrid{display:grid;gap:6px;overflow-x:auto}
-.workEffortHead{display:grid;gap:2px}
-.workEffortHead small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium);letter-spacing:0;text-transform:none}
-.workEffortCell{display:flex;align-items:center;justify-content:center;min-width:0;min-height:40px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--red-rgb)/var(--heat,0));font-size:var(--fs-16);font-weight:var(--fw-heavy);font-variant-numeric:tabular-nums}
-.workEffortCell[data-few],.workEffortCell[data-empty]{border-color:transparent;background:rgb(var(--tint-rgb)/.025);color:var(--faint);font-size:var(--fs-12);font-weight:var(--fw-medium)}
-.workEffortVerdicts{display:grid;gap:6px;margin:10px 0 0;padding:0;list-style:none;font-size:var(--fs-12)}
-.workEffortVerdicts li{padding:6px 10px;border-left:2px solid var(--line2);border-radius:0 var(--radius-sm) var(--radius-sm) 0;color:var(--dim)}
-.workEffortVerdicts li b{color:var(--fg)}
-.workEffortVerdicts li[data-kind=lower]{border-left-color:var(--good);background:rgb(var(--green-rgb)/.06)}
-.workEffortVerdicts li[data-kind=raise]{border-left-color:var(--warn);background:rgb(var(--orange-rgb)/.06)}
-.workEffortNote{margin:8px 0 0;color:var(--faint);font-size:var(--fs-11)}
-.workEffortDetail{min-height:18px;margin:8px 0 0;color:var(--dim);font-size:var(--fs-12);font-variant-numeric:tabular-nums}
-.workEffortCell[tabindex]:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
-.workSuggestCard{display:flex;flex-direction:column;min-width:0;min-height:236px;padding:18px 18px 14px;border:1px solid var(--line);border-radius:var(--radius-lg);background:rgb(var(--tint-rgb)/.022)}
-.workSuggestEyebrow{display:flex;align-items:center;gap:8px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.workSuggestEyebrow i{width:8px;height:8px;border-radius:var(--radius-2xs);display:inline-block}
-.workSuggestHero{margin-top:12px;font:var(--fw-heavy) var(--fs-44)/1 var(--font-sans);letter-spacing:-.02em}
-.workSuggestHero small{display:block;margin-top:6px;color:var(--dim);font-size:var(--fs-13);font-weight:var(--fw-semibold);letter-spacing:0}
-.workSuggestRows{display:flex;flex-direction:column;gap:8px;margin-top:14px}
-.workSuggestRows .workDrillBtn{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:center;gap:10px;padding:8px 10px;border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.03)}
-.workSuggestRows .workDrillBtn:hover,.workSuggestRows .workDrillBtn:focus-visible{background:rgb(var(--signal-rgb)/.08)}
-.workSwap{min-width:0;font-size:var(--fs-13);font-weight:var(--fw-semibold);font-variant-numeric:tabular-nums;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.workSwap b{margin:0 6px;color:var(--faint);font-weight:var(--fw-medium)}
-.workSwap em{display:block;margin-top:2px;color:var(--faint);font:var(--fs-11) var(--font-sans);font-style:normal;overflow:hidden;text-overflow:ellipsis}
-.workSwapSave{color:var(--good);font-size:var(--fs-13);font-weight:var(--fw-bold);font-variant-numeric:tabular-nums}
-.workSuggestFoot{display:flex;justify-content:space-between;gap:10px;margin-top:auto;padding-top:12px;color:var(--faint);font-size:var(--fs-12)}
-.workSuggestFoot button{flex:none;padding:0;border:0;background:none;color:var(--accent);font:inherit;white-space:nowrap;cursor:pointer}
-.workSuggestBar{display:flex;gap:2px;height:10px;margin-top:16px;border-radius:var(--radius-sm);overflow:hidden}
-.workSuggestLegend{display:flex;flex-wrap:wrap;gap:6px 12px;margin-top:8px;color:var(--dim);font-size:var(--fs-11)}
-.workSuggestLegend i{display:inline-block;width:8px;height:8px;margin-right:6px;border-radius:var(--radius-2xs)}
-.workSuggestSpark{display:block;width:100%;height:54px;margin-top:14px}
-.workSuggestChips{display:flex;gap:8px;margin-top:12px}
-.workSuggestChips div{flex:1;min-width:0;padding:8px 10px;border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.03)}
-.workSuggestChips span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.workSuggestChips b{display:block;margin-top:3px;font-size:var(--fs-13);font-weight:var(--fw-semibold);font-variant-numeric:tabular-nums;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.workSuggestChips b s{color:var(--dim);font-weight:var(--fw-medium);text-decoration:none}
-.workSuggestEmpty{margin-top:14px;color:var(--faint);font-size:var(--fs-13)}
-.workIssues{width:100%;border-collapse:collapse;font-size:var(--fs-12)}
-.workIssues th{padding:0 8px 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.05em;text-transform:uppercase;text-align:right}
-.workIssues th:first-child{text-align:left;padding-left:0}
-.workIssues td{border-top:1px solid var(--line);padding:0;text-align:right;white-space:nowrap}
-.workIssues td:first-child{text-align:left}
-.workIssues td>span{display:block;padding:8px}
-.workIssues .workDrillBtn{display:flex;align-items:center;gap:8px;padding:8px 8px 8px 0}
-.workIssues tr:hover td{background:rgb(var(--tint-rgb)/.03)}
-.workIssueKind{color:var(--warn);font-size:var(--fs-11)}
-@media(max-width:1180px){.workSplit{grid-template-columns:1fr}.workSuggestCards{grid-template-columns:1.2fr 1fr 1fr}}
-#view-work .mono,#view-work .num{font-family:inherit;font-variant-numeric:tabular-nums}
-#view-work em.mono{font-style:normal}
-.workTagsCard,.workRhythm,.workBreakdown{padding:16px 16px;margin-top:10px}
-.workTrendPair{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;margin-top:10px;align-items:stretch}
-.workTrendPair>.card{display:flex;flex-direction:column;margin:0}
-.workBreakdownTable small{color:var(--faint);font-size:var(--fs-11)}
-.workCellNote,.workOutcomeCell small{display:block;margin-top:2px}
-.workTableWrap .workBreakdownTable th{white-space:normal;vertical-align:bottom}
-.workBreakdownTable .efficiencySort{text-align:right}
-.workBreakdownTable th:first-child .efficiencySort{text-align:left}
-.workBreakdownTable td.num{white-space:nowrap}
-.workCellBar{display:block;height:4px;margin-top:4px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.05);overflow:hidden}
-.workCellBar i{display:block;height:100%;border-radius:var(--radius-xs);background:linear-gradient(90deg,var(--signal-mid),var(--signal))}
-.workBreakdownTable .workMuted .workCellBar i{background:var(--w-unclear)}
-.workBreakdownTable .workOutcomeBar{height:8px;min-width:80px;margin:0}
-.workBreakdownTotal td{background:rgb(var(--tint-rgb)/.02)}
-
-.workTagGrid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px}
-.workTagTile{display:grid;align-content:start;gap:4px;min-width:0;padding:12px 14px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02);color:var(--fg);font:inherit;text-align:left;cursor:pointer}
-.workTagTile:hover,.workTagTile:focus-visible{border-color:var(--tone);background:rgb(var(--tint-rgb)/.045);outline:none}
-.workTagName{display:flex;align-items:center;gap:8px;font-size:var(--fs-13);font-weight:var(--fw-bold)}
-.workTagName i{flex:0 0 auto;width:8px;height:8px;border-radius:var(--radius-round);background:var(--tone)}
-.workTagTile strong{font-size:var(--fs-18);font-weight:var(--fw-bold)}
-.workTagStats{color:var(--dim);font-size:var(--fs-12)}
-.workTagTile small{color:var(--faint);font-size:var(--fs-11);line-height:1.4}
-.workRhythm .workSplit{grid-template-columns:minmax(0,1.6fr) minmax(0,1fr);gap:32px}
-.workHeat{display:grid;grid-template-columns:30px repeat(24,minmax(0,1fr));gap:3px;align-items:center}
-.workHeat>span{color:var(--dim);font-size:var(--fs-11)}
-.workHeat>span.h{grid-column:span 6;color:var(--faint);font-size:var(--fs-11)}
-.workHeat>i{display:block;height:16px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.035)}
-.workHeat>i[data-v]{background:color-mix(in oklab,var(--signal) calc(var(--v) * 100%),rgb(var(--tint-rgb)/.035))}
-.workBandList{display:grid;gap:2px}
-.workBand{display:grid;grid-template-columns:118px minmax(0,1fr) 52px;grid-template-areas:"label bar value" ". note note";align-items:center;column-gap:10px;row-gap:3px;padding:8px 6px}
-.workBand>span:first-child{grid-area:label;font-size:var(--fs-13)}
-.workBand>span small{display:block;color:var(--faint);font-size:var(--fs-11)}
-.workBand .workBarTrack{grid-area:bar;height:10px;border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.04);overflow:hidden}
-.workBand .workBarTrack i{display:block;height:100%;border-radius:var(--radius-xs);background:var(--signal)}
-.workBand b{grid-area:value;text-align:right;font-size:var(--fs-12)}
-.workBand>small{grid-area:note;color:var(--faint);font-size:var(--fs-11)}
-.workBand[data-few=true] .workBarTrack i{opacity:.45}
-@media(max-width:1180px){.workRhythm .workSplit{grid-template-columns:1fr}}
-.workFootnote{margin-top:10px;color:var(--faint);font-size:var(--fs-11)}
-body.spectrumApp .settingsMap{grid-template-columns:repeat(6,minmax(0,1fr));background:var(--spectrum-card)}
-body.spectrumApp .settingsMap button{grid-template-columns:1fr;border-left:1px solid var(--line);border-radius:0}
-body.spectrumApp :is(.sessionStart,.toast,.capReview,.agentDiscovery,.previewStartStrip,.modelScopeStatus){border-left-width:1px}
-@media(max-width:900px){.spectrumPageHead{height:126px;align-items:flex-start;padding:20px 24px}.spectrumPageHeadCopy,.hasPageActions .spectrumPageHeadCopy{max-width:72%}.spectrumPageActions{position:static;display:flex;width:100%;max-width:none;min-height:46px;align-items:center;justify-content:flex-start;margin-top:8px;padding:6px 8px;border:1px solid var(--spectrum-border);border-radius:var(--radius-md);background:var(--spectrum-control);box-shadow:var(--shadow-soft)}.spectrumPageActions>*{width:100%}.pageSignalField{right:-18%;width:88%}body.spectrumApp .settingsMap{grid-template-columns:repeat(2,minmax(0,1fr))}}
-@media(max-width:520px){.spectrumPageHead{height:116px;padding:18px 18px}.spectrumPageHeadCopy,.hasPageActions .spectrumPageHeadCopy{max-width:62%}.spectrumPageHead h1{font-size:var(--fs-28);line-height:1.02}.spectrumPageSubtitle{max-width:34ch;font-size:var(--fs-11)}.spectrumPageActions{padding:6px}.pageSignalField{top:-36%;right:-43%;bottom:-42%;width:112%;opacity:.78}body.spectrumApp .settingsMap{grid-template-columns:1fr}}
-@media(prefers-reduced-motion:reduce){.pageSignalField{transition:none}body.spectrumApp .tbtn{transition:none}body.spectrumApp:after,body.spectrumApp .top:before,body.spectrumApp .spectrumPageHead:after,body.spectrumApp .top .tab.on:after,.themeOption,body.spectrumApp .spectrumPageHeadFrame:before,body.spectrumApp .spectrumPageHeadFrame:after,body.spectrumApp .spectrumPageHead h1{animation:none;transition:none}}
-/* spectrum-motion-v1: purposeful motion and material detail shared by every theme */
-html:after{content:"";position:fixed;inset:0;z-index:-1;pointer-events:none;background-image:var(--grain);background-size:180px 180px;opacity:var(--grain-opacity);mix-blend-mode:overlay}
-body.spectrumApp .card:not(.currentSessionCard):not(.budgetConfig){transition:border-color .16s,box-shadow .16s}
-body.spectrumApp :is(.tbtn,.seg button,.themeOption){transition:border-color .16s,background .16s,box-shadow .16s,color .16s,transform var(--dur-press) var(--ease-out)}
-body.spectrumApp :is(.tbtn,.seg button,.themeOption):active:not(:disabled){transform:scale(.97)}
-body.spectrumApp .top .tab:active{transform:scale(.98)}
-@keyframes viewEnter{from{opacity:0;transform:translateY(8px)}}
-.view.viewEnter>*{animation:viewEnter var(--dur-enter) var(--ease-out) both;animation-delay:calc(var(--enter-i,0)*45ms)}
-html.themeReveal::view-transition-old(root),html.themeReveal::view-transition-new(root){animation:none;mix-blend-mode:normal}
-html.themeReveal::view-transition-new(root){z-index:1}
-@media(prefers-reduced-motion:reduce){body.spectrumApp :is(.tbtn,.seg button,.themeOption,.top .tab):active{transform:none}.view.viewEnter>*{animation-name:none}body.spectrumApp .card:not(.currentSessionCard):not(.budgetConfig){transition:none}}
-/* session-spectrum-field-v2 */
-body.sessionRoute{--session-signal:var(--signal);--session-signal-mid:var(--signal-mid);--session-signal-hi:var(--signal-hi);--session-aura:var(--aura);--session-orange:var(--orange)}
-/* session-signal-field-v1 */
-body.sessionRoute #view-session .sessionFlowStatus{display:inline-flex;width:auto;min-height:28px;align-items:center;gap:8px;margin:0;padding:6px 10px;border:1px solid rgb(var(--signal-hi-rgb)/.22);border-radius:var(--radius-pill);background:rgb(var(--bg-lift-rgb)/.72);box-shadow:inset 0 1px 0 rgb(var(--tint-rgb)/.035);color:var(--session-signal-hi);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono);letter-spacing:.055em;text-transform:uppercase}
-body.sessionRoute #view-session .sessionFlowStatus i{width:6px;height:6px;flex:0 0 auto;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
-body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=working] .sessionFlowStatus{border-color:rgb(var(--green-rgb)/.3);color:var(--good)}
-body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=working] .sessionFlowStatus i{animation:sessionFlowStatusPulse 2.8s ease-out infinite}
-body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=waiting] .sessionFlowStatus{color:var(--warn)}
-body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=recent] .sessionFlowStatus{color:var(--session-aura)}
-body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=idle] .sessionFlowStatus{color:var(--dim)}
-body.sessionRoute #view-session .spectrumPageHeadFrame[data-session-flow=unavailable] .sessionFlowStatus{border-style:dashed;color:var(--faint)}
-body.sessionRoute #view-session .sessionFlowHead[data-session-flow=waiting] .pageSignalField{opacity:.86}
-body.sessionRoute #view-session .sessionFlowHead[data-session-flow=recent] .pageSignalField{opacity:.8}
-body.sessionRoute #view-session .sessionFlowHead[data-session-flow=idle] .pageSignalField{opacity:.72}
-body.sessionRoute #view-session .sessionFlowHead[data-session-flow=unavailable] .pageSignalField{opacity:.62}
-body.sessionRoute #view-session.sessionDetail .sessionFlowHead :is(.pageSignalField,.pageHeroBorder),body.sessionRoute #view-session.sessionDetail .spectrumPageActions{display:none}
-@keyframes sessionFlowStatusPulse{0%,70%{box-shadow:0 0 0 0 rgb(var(--green-rgb)/.4)}100%{box-shadow:0 0 0 9px transparent}}
-body.sessionRoute #view-session .sessionScopeTabs{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:4px;width:100%;margin:-4px 0 12px;padding:4px;border-color:rgb(var(--signal-rgb)/.24);background:rgb(var(--bg-rgb)/.72)}
-body.sessionRoute #view-session .sessionScopeTabs .tab{display:flex;min-height:44px;align-items:center;justify-content:center;gap:8px;padding:10px 14px;text-align:center}
-body.sessionRoute #view-session .sessionScopeTabs .tab .tabIcon{width:17px;height:17px;flex:0 0 auto}
-body.sessionRoute #view-session .sessionScopeTabs .tab[aria-selected=true]{background:var(--spectrum-active);color:var(--on-accent);box-shadow:0 7px 20px rgb(var(--signal-rgb)/.16)}
-body.sessionRoute #view-session .sessionScopeTabs .tab[aria-selected=false]:hover{background:rgb(var(--signal-rgb)/.07);color:var(--fg)}
-body.sessionRoute #view-session .currentDaySummary{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:stretch;gap:18px;margin:0 0 10px;padding:10px 12px;border-top:1px solid rgb(var(--signal-rgb)/.16);border-bottom:1px solid rgb(var(--signal-rgb)/.13);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.055),rgb(var(--signal-hi-rgb)/.025) 62%,rgb(var(--aura-rgb)/.035))}
-body.sessionRoute #view-session .currentDayReadouts{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));min-width:0}
-body.sessionRoute #view-session .currentDayMetric{min-width:0;padding:0 16px;border-left:1px solid rgb(var(--tint-rgb)/.08)}
-body.sessionRoute #view-session .currentDayMetric:first-child{padding-left:0;border-left:0}
-body.sessionRoute #view-session .currentDayMetricLabel{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.045em;text-transform:uppercase}
-body.sessionRoute #view-session .currentDayMetricValue{display:block;margin-top:3px;color:var(--fg);font-size:var(--fs-18);font-weight:var(--fw-bold);line-height:1.15;font-variant-numeric:tabular-nums;overflow-wrap:anywhere}
-body.sessionRoute #view-session .currentDayMetricNote{display:block;margin-top:3px;color:var(--faint);font-size:var(--fs-11);line-height:1.3;overflow-wrap:anywhere}
-body.sessionRoute #view-session .currentDayActions{align-self:center;display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap}
-body.sessionRoute #view-session :is(.currentDayMonth,.currentDayLearn){display:inline-flex;align-items:center;justify-content:center;gap:6px;min-height:40px;white-space:nowrap}
-body.sessionRoute #view-session .currentDayLearn{text-decoration:none}
-body.sessionRoute #view-session .currentDayLearnIcon{width:14px;height:14px;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
-body.sessionRoute #view-session .currentSessionsHead{justify-content:space-between;margin:-4px 0 8px;padding:0 2px}
-body.sessionRoute #view-session .currentSessionsCount{color:var(--faint);font-size:var(--fs-11);letter-spacing:.02em}
-body.sessionRoute #view-session .currentSessionFilterGroups{max-width:calc(100% - 96px)}
-body.sessionRoute #view-session .currentSessionRuntimeFilters,body.sessionRoute #view-session .currentSessionActivityFilters{display:flex;min-width:0}
-body.sessionRoute #view-session .currentSessionRuntimeFilters[hidden],body.sessionRoute #view-session .currentSessionActivityFilters[hidden]{display:none}
-body.sessionRoute #view-session .currentSessionRuntimeFilters button,body.sessionRoute #view-session .currentSessionActivityFilters button{min-height:30px;padding:6px 10px;white-space:nowrap}
-body.sessionRoute #view-session .currentSessionGrid{gap:12px}
-body.sessionRoute #view-session .currentSessionCard{isolation:isolate;min-height:0;padding:18px 20px 16px;border-color:rgb(var(--signal-rgb)/.16);border-radius:var(--radius-md);background:radial-gradient(circle at 92% 8%,rgb(var(--signal-hi-rgb)/.1),transparent 28%),radial-gradient(circle at 8% 100%,rgb(var(--aura-rgb)/.07),transparent 34%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg2-rgb)/.99));box-shadow:var(--shadow-soft);transition:transform .18s cubic-bezier(.16,1,.3,1),border-color .18s,box-shadow .18s,opacity .18s}
-body.sessionRoute #view-session .currentSessionCard:before{content:none}
-body.sessionRoute #view-session .currentSessionCard.activity-working{border-color:rgb(var(--signal-rgb)/.42);background:radial-gradient(circle at 88% 4%,rgb(var(--signal-rgb)/.18),transparent 34%),linear-gradient(135deg,rgb(var(--signal-deep-rgb)/.98),rgb(var(--bg-lift-rgb)/.99) 56%,rgb(var(--bg2-rgb)/.99))}
-body.sessionRoute #view-session .currentSessionCard.is-arriving{animation:currentSessionArrive .82s var(--spectrum-ease) both}
-@keyframes currentSessionArrive{0%{opacity:.15;transform:translateY(9px);box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.06)}55%{opacity:1;box-shadow:0 0 0 1px rgb(var(--signal-rgb)/.58),0 0 34px rgb(var(--signal-rgb)/.18)}100%{opacity:1;transform:none;box-shadow:var(--shadow-soft)}}
-body.sessionRoute #view-session .currentSessionCard:hover{transform:translateY(-3px);border-color:color-mix(in srgb,var(--harness) 72%,var(--session-signal));box-shadow:0 18px 38px rgb(var(--shade-rgb)/.3)}
-body.sessionRoute #view-session .currentSessionCard:focus-visible{outline:2px solid var(--session-signal);outline-offset:3px;border-color:var(--session-signal);box-shadow:none}
-body.sessionRoute #view-session .currentSessionIdentity{position:relative;z-index:1;margin-top:20px}
-body.sessionRoute #view-session .currentSessionIdentity h3{font-family:var(--font-display);font-size:var(--fs-22);font-stretch:91%;font-weight:var(--fw-semibold);letter-spacing:-.025em}
-body.sessionRoute #view-session .currentSessionIdentity p{margin-top:6px;color:var(--faint);font-size:var(--fs-11)}
-body.sessionRoute #view-session .currentSessionMetrics{grid-template-columns:.9fr 1.2fr 1fr;gap:0;margin-top:14px;padding-top:14px;border-top:1px solid rgb(var(--signal-rgb)/.13)}
-body.sessionRoute #view-session .currentSessionMetric{padding:0 14px;border-left:1px solid rgb(var(--tint-rgb)/.08)}
-body.sessionRoute #view-session .currentSessionMetric:first-child{padding-left:0;border-left:0}
-body.sessionRoute #view-session .currentSessionMetric:last-child{padding-right:0}
-body.sessionRoute #view-session .currentSessionMetric span{color:var(--faint);font-size:var(--fs-11);letter-spacing:.04em}
-body.sessionRoute #view-session .currentSessionMetric b,body.sessionRoute #view-session .currentSessionMetric b.mono{margin-top:6px;color:var(--fg);font-size:var(--fs-readout-sm);font-weight:var(--fw-bold)}
-:is(body.sessionRoute #view-session,.conceptFrame) .currentSessionHero{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:end;gap:8px 24px;margin-top:16px}
-body.sessionRoute #view-session .currentSessionHeroCompare{min-width:0;padding-bottom:4px}
-:is(body.sessionRoute #view-session,.conceptFrame) .currentSessionHeroLabel{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
-:is(body.sessionRoute #view-session,.conceptFrame) .currentSessionHeroValue{display:block;margin-top:4px;color:var(--fg);font-family:var(--font-sans);font-size:var(--fs-readout-lg);font-weight:var(--fw-bold);line-height:1;letter-spacing:-.035em;font-variant-numeric:tabular-nums;white-space:nowrap}
-body.sessionRoute #view-session .currentSessionHero .readoutScale{max-width:280px;margin-top:0}
-body.sessionRoute #view-session .currentSessionContextSpark{--context-tone:var(--session-signal);max-width:98px;height:24px}
-body.sessionRoute #view-session .currentSessionContextBaseline{stroke:rgb(var(--signal-rgb)/.12)}
-body.sessionRoute #view-session .currentSessionContextBar{fill:var(--session-signal);opacity:.52}
-body.sessionRoute #view-session .currentSessionGrip{width:12px;height:16px;fill:var(--session-signal);opacity:.7}
-body.sessionRoute #view-session .currentSessionsEmpty{border-color:rgb(var(--signal-rgb)/.18);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--panel2-rgb)/.95),rgb(var(--bg2-rgb)/.98))}
-body.sessionRoute #view-session .currentSessionsEmpty{position:relative;display:flex;grid-column:1/-1;min-height:390px;overflow:hidden;align-items:center;justify-content:center;padding:36px 24px 36px;text-align:center;background:radial-gradient(ellipse at 50% 48%,rgb(var(--signal-rgb)/.13),transparent 44%),radial-gradient(ellipse at 76% 42%,rgb(var(--aura-rgb)/.08),transparent 36%),linear-gradient(150deg,rgb(var(--panel2-rgb)/.96),rgb(var(--bg-rgb)/.98))}
-body.sessionRoute #view-session .currentSessionsEmpty:after{content:"";position:absolute;right:7%;bottom:-120px;left:7%;height:210px;border-radius:var(--radius-round);background:rgb(var(--signal-rgb)/.07);filter:blur(38px)}
-body.sessionRoute #view-session .currentSessionsEmptyInner{position:relative;z-index:1;width:min(720px,100%)}
-body.sessionRoute #view-session .currentSessionsEmpty h3{margin:0;font-family:var(--font-display);font-size:var(--fs-readout-lg);font-stretch:91%;font-weight:var(--fw-semibold);letter-spacing:-.03em}
-body.sessionRoute #view-session .currentSessionsEmptyCopy{max-width:65ch;margin:8px auto 0;color:var(--dim);font-size:var(--fs-13);line-height:1.55}
-body.sessionRoute #view-session .currentSessionsArrival{width:min(390px,100%);margin:20px auto 28px;padding:14px 16px 14px;border:1px solid rgb(var(--aura-rgb)/.48);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--panel2-rgb)/.98),rgb(var(--bg-lift-rgb)/.98));box-shadow:0 14px 30px rgb(var(--shade-rgb)/.24),0 0 30px rgb(var(--aura-rgb)/.08);text-align:left}
-body.sessionRoute #view-session .currentSessionsArrivalHead{display:flex;align-items:center;gap:8px}
-body.sessionRoute #view-session .currentSessionsArrivalHead:before{content:"";width:7px;height:7px;flex:0 0 auto;border-radius:var(--radius-round);background:var(--session-aura);box-shadow:0 0 12px rgb(var(--aura-rgb)/.72)}
-body.sessionRoute #view-session .currentSessionsArrivalHead strong{font-size:var(--fs-13)}
-body.sessionRoute #view-session .currentSessionsArrivalHead span{margin-left:auto;color:var(--session-aura);font-size:var(--fs-11);font-weight:var(--fw-bold)}
-body.sessionRoute #view-session .currentSessionsArrivalMetrics{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:14px;margin-top:12px;padding-top:12px;border-top:1px solid rgb(var(--signal-hi-rgb)/.14)}
-body.sessionRoute #view-session .currentSessionsArrivalMetric span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-body.sessionRoute #view-session .currentSessionsArrivalMetric strong{display:block;margin-top:4px;font:var(--fw-bold) var(--fs-14)/1.1 var(--font-mono)}
-body.sessionRoute #view-session .currentSessionsHistorySummary{display:flex;align-items:baseline;justify-content:center;gap:14px;margin-bottom:3px}
-body.sessionRoute #view-session .currentSessionsHistorySummary>strong{font-family:var(--font-display);font-size:var(--fs-24);font-weight:var(--fw-semibold);letter-spacing:-.03em}
-body.sessionRoute #view-session .currentSessionsHistorySummary>span{color:var(--dim);font-size:var(--fs-12)}
-body.sessionRoute #view-session .currentSessionsHistorySummary>span b{color:var(--fg);font:var(--fw-bold) var(--fs-12)/1.2 var(--font-mono)}
-body.sessionRoute #view-session .currentSessionsHorizon{position:relative;display:grid;grid-template-columns:repeat(7,minmax(0,1fr));height:92px;margin:0 auto 20px;padding:0 10px}
-body.sessionRoute #view-session .currentSessionsHorizon:before{content:"";position:absolute;right:10px;bottom:25px;left:10px;height:1px;background:linear-gradient(90deg,rgb(var(--signal-rgb)/.14),rgb(var(--signal-hi-rgb)/.7) 72%,rgb(var(--aura-rgb)/.72));box-shadow:0 8px 28px rgb(var(--signal-rgb)/.18)}
-body.sessionRoute #view-session .currentSessionsHistoryDay{position:relative;display:grid;grid-template-rows:1fr auto 24px;justify-items:center;min-width:0}
-body.sessionRoute #view-session .currentSessionsHistoryValue{align-self:end;margin-bottom:6px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.1 var(--font-mono)}
-body.sessionRoute #view-session .currentSessionsHistoryBar{width:clamp(9px,1.5vw,15px);height:var(--activity);min-height:0;align-self:end;border-radius:var(--radius-xs) var(--radius-xs) 0 0;background:linear-gradient(to top,rgb(var(--signal-rgb)/.36),var(--session-signal-hi));box-shadow:0 0 20px rgb(var(--signal-rgb)/.17)}
-body.sessionRoute #view-session .currentSessionsHistoryDay small{align-self:end;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-bold);letter-spacing:.05em;text-transform:uppercase}
-body.sessionRoute #view-session .currentSessionsEmptyActions{display:flex;align-items:center;justify-content:center;gap:20px}
-body.sessionRoute #view-session .currentSessionsEmptyAction{appearance:none;display:inline-flex;align-items:center;gap:6px;padding:2px;border:0;background:transparent;color:var(--session-signal-hi);font:inherit;font-size:var(--fs-12);font-weight:var(--fw-bold);line-height:1.2;text-decoration:none;cursor:pointer}
-body.sessionRoute #view-session .currentSessionsEmptyAction.secondary{color:var(--dim)}
-body.sessionRoute #view-session .currentSessionsEmptyAction:hover{color:var(--fg)}
-body.sessionRoute #view-session .currentSessionsEmptyAction:focus-visible{outline:2px solid var(--session-signal);outline-offset:4px;border-radius:var(--radius-xs)}
-body.sessionRoute #view-session .currentSessionsEmptyAction svg{width:15px;height:15px;fill:none;stroke:currentColor;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round}
-@media(max-width:700px){body.sessionRoute #view-session .currentSessionsEmpty{min-height:0;padding:32px 14px 32px}body.sessionRoute #view-session .currentSessionsEmpty h3{font-size:var(--fs-28)}body.sessionRoute #view-session .currentSessionsArrival{margin:20px auto 24px}body.sessionRoute #view-session .currentSessionsHistorySummary{flex-wrap:wrap;gap:3px 10px}body.sessionRoute #view-session .currentSessionsHistorySummary>strong{font-size:var(--fs-24)}body.sessionRoute #view-session .currentSessionsHistorySummary>span{flex-basis:100%}body.sessionRoute #view-session .currentSessionsHorizon{height:86px;padding:0}body.sessionRoute #view-session .currentSessionsHorizon:before{right:0;left:0}body.sessionRoute #view-session .currentSessionsHistoryValue{visibility:hidden}body.sessionRoute #view-session .currentSessionsHistoryDay small{font-size:0}body.sessionRoute #view-session .currentSessionsHistoryDay small:after{content:attr(data-short);font-size:var(--fs-11)}body.sessionRoute #view-session .currentSessionsEmptyActions{flex-direction:column;gap:14px}}
-body.sessionRoute #view-session #all-session-history{margin-top:2px}
-body.sessionRoute #view-session .allSessionsHead{display:flex;align-items:flex-end;justify-content:space-between;gap:16px;margin:0 0 10px;padding:2px 2px 0}
-body.sessionRoute #view-session .allSessionsHead h2{margin:0;font-family:var(--font-display);font-size:var(--fs-22);font-weight:var(--fw-semibold);letter-spacing:-.025em}
-body.sessionRoute #view-session .allSessionsHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-12)}
-body.sessionRoute #view-session .allSessionsHint{margin-left:auto;color:var(--faint);font-size:var(--fs-11);white-space:nowrap}
-body.sessionRoute #view-session .logsToolbar{margin-top:0}
-body.sessionRoute #view-session .logsToolbarStatus{margin-bottom:8px}
-body.sessionRoute #view-session .logsSummary{display:block;margin:0 0 12px}
-body.sessionRoute #view-session .logsSummary .logKpis{grid-template-columns:repeat(5,minmax(0,1fr));gap:0;border:1px solid rgb(var(--signal-rgb)/.16);border-radius:var(--radius-md);background:linear-gradient(90deg,rgb(var(--signal-rgb)/.055),rgb(var(--signal-hi-rgb)/.025) 62%,rgb(var(--aura-rgb)/.035));box-shadow:var(--shadow-soft)}
-body.sessionRoute #view-session .logsSummary .logStat{min-height:76px;padding:12px 12px;border:0;border-left:1px solid rgb(var(--tint-rgb)/.08);border-radius:0;background:transparent;box-shadow:none}
-body.sessionRoute #view-session .logsSummary .logStat:first-child{border-left:0}
-body.sessionRoute #view-session .logsSummary .logStat.waitStat{grid-column:auto;min-height:76px}
-body.sessionRoute #view-session .logsSummary .logStat .v{font-size:var(--fs-20)}
-body.sessionRoute #view-session .logsSummary .logStat .subline{font-size:var(--fs-11)}
-body.sessionRoute #view-session .historyModels{margin-top:8px;border:1px solid var(--line);border-radius:var(--radius-md);background:linear-gradient(180deg,rgb(var(--panel-rgb)/.8),rgb(var(--bg2-rgb)/.78));box-shadow:var(--shadow-soft)}
-body.sessionRoute #view-session .historyModels>summary{display:flex;align-items:center;gap:8px;min-height:42px;padding:0 12px;cursor:pointer;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-heavy);list-style:none}
-body.sessionRoute #view-session .historyModels>summary::-webkit-details-marker{display:none}
-body.sessionRoute #view-session .historyModels>summary:after{content:"▾";margin-left:auto;color:var(--faint);font-size:var(--fs-11);transition:transform .16s ease}
-body.sessionRoute #view-session .historyModels[open]>summary{border-bottom:1px solid var(--line)}
-body.sessionRoute #view-session .historyModels[open]>summary:after{transform:rotate(180deg)}
-body.sessionRoute #view-session .historyModels>summary:focus-visible{outline:2px solid var(--session-signal);outline-offset:-3px}
-body.sessionRoute #view-session .historyModels .logModelList{padding:2px 12px 10px}
-body.sessionRoute #view-session .historyModels .logModelCount{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium)}
-body.sessionRoute #view-session.sessionDetail .previewRunMeta{gap:6px;margin-bottom:10px;padding:0 2px}
-body.sessionRoute #view-session.sessionDetail .previewRunMeta .badge,body.sessionRoute #view-session.sessionDetail .previewRunMeta .repo,body.sessionRoute #view-session.sessionDetail .previewRunMeta .pill,body.sessionRoute #view-session.sessionDetail .sessionDelete{background:rgb(var(--panel-rgb)/.86)}
-body.sessionRoute #view-session.sessionDetail .previewStartStrip{border-color:rgb(var(--signal-rgb)/.18);background:linear-gradient(100deg,rgb(var(--signal-rgb)/.11),rgb(var(--panel2-rgb)/.92) 46%,rgb(var(--aura-rgb)/.05));box-shadow:none}
-body.sessionRoute #view-session.sessionDetail .previewStartLabel{color:var(--session-signal-hi);font-size:var(--fs-11)}
-body.sessionRoute #view-session.sessionDetail .previewChartSlot #session-chart-module>.card{border-color:rgb(var(--signal-rgb)/.15);border-radius:var(--radius-md);background:radial-gradient(circle at 100% 0,rgb(var(--signal-rgb)/.07),transparent 28%),linear-gradient(160deg,rgb(var(--panel-rgb)/.98),rgb(var(--bg-rgb)/.98));box-shadow:none}
-body.sessionRoute #view-session.sessionDetail .previewChartSlot .chart{border-color:rgb(var(--tint-rgb)/.07);border-radius:var(--radius-sm);background:linear-gradient(180deg,rgb(var(--bg-rgb)/.72),rgb(var(--bg-deep-rgb)/.5))}
-body.sessionRoute #view-session.sessionDetail .previewStatus{padding:18px;border-color:rgb(var(--signal-rgb)/.24);border-radius:var(--radius-md);background:radial-gradient(circle at 96% 5%,rgb(var(--signal-hi-rgb)/.16),transparent 34%),radial-gradient(circle at 8% 100%,rgb(var(--aura-rgb)/.1),transparent 40%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.99),rgb(var(--bg2-rgb)/.99));box-shadow:var(--shadow-soft)}
-body.sessionRoute #view-session.sessionDetail .previewState{color:var(--good);font-size:var(--fs-11)}
-body.sessionRoute #view-session.sessionDetail .previewCost{color:var(--session-signal-hi);font-size:var(--fs-readout-xl);font-weight:var(--fw-bold);letter-spacing:-.02em;white-space:nowrap}
-body.sessionRoute #view-session.sessionDetail .previewCostNote{color:var(--dim)}
-body.sessionRoute #view-session.sessionDetail .previewPressure{border-top-color:rgb(var(--signal-rgb)/.14)}
-body.sessionRoute #view-session.sessionDetail .previewPressureHead{color:var(--dim)}
-body.sessionRoute #view-session.sessionDetail .previewPressureBar{height:8px;border-color:rgb(var(--signal-rgb)/.2);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.72)}
-body.sessionRoute #view-session.sessionDetail .previewPressureBar i{border-radius:inherit;background:linear-gradient(90deg,var(--session-signal),var(--session-signal-mid) 58%,var(--session-signal-hi))}
-body.sessionRoute #view-session.sessionDetail .previewTimes{border-top-color:rgb(var(--signal-rgb)/.12)}
-body.sessionRoute #view-session.sessionDetail .previewTimes span{color:var(--faint);font-size:var(--fs-11)}
-body.sessionRoute #view-session.sessionDetail .previewTimes b{overflow:visible;white-space:pre-line;line-height:1.35}
-body.sessionRoute #view-session.sessionDetail .previewRunBudgetSlot .sessionBudget{padding:18px;border-color:rgb(var(--signal-rgb)/.14);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--panel-rgb)/.96),rgb(var(--bg-rgb)/.98));box-shadow:none}
-body.sessionRoute #view-session.sessionDetail .previewTokenSlot .bar{border-color:rgb(var(--signal-rgb)/.16);background:rgb(var(--bg-rgb)/.7)}
-body.sessionRoute #view-session.sessionDetail .previewKpi.previewSpeed .v{color:var(--session-signal-hi);text-shadow:none}
-@media(max-width:900px){body.sessionRoute #view-session .logsSummary .logKpis{grid-template-columns:repeat(3,minmax(0,1fr))}body.sessionRoute #view-session .logsSummary .logStat:nth-child(4){border-left:0}body.sessionRoute #view-session .logsSummary .logStat:nth-child(n+4){margin-top:8px;padding-top:12px;border-top:1px solid rgb(var(--tint-rgb)/.08)}}
-@media(max-width:700px){body.sessionRoute #view-session .currentSessionMetric{padding:0 8px}body.sessionRoute #view-session .currentSessionMetric b,body.sessionRoute #view-session .currentSessionMetric b.mono{font-size:var(--fs-18)}}
-@media(max-width:520px){body.sessionRoute #view-session .sessionFlowStatus{padding:4px 8px;font-size:var(--fs-11)}body.sessionRoute #view-session .currentDaySummary{grid-template-columns:1fr;gap:10px;padding:10px 12px}body.sessionRoute #view-session .currentDayReadouts{grid-template-columns:repeat(2,minmax(0,1fr))}body.sessionRoute #view-session .currentDayMetric{padding:0 10px}body.sessionRoute #view-session .currentDayMetric:nth-child(3){grid-column:1/-1;margin-top:8px;padding:8px 10px 0;border-top:1px solid rgb(var(--signal-rgb)/.12);border-left:0}body.sessionRoute #view-session .currentDayActions{display:grid;grid-template-columns:1fr}body.sessionRoute #view-session :is(.currentDayMonth,.currentDayLearn){width:100%}body.sessionRoute #view-session .currentSessionsHead{display:grid;grid-template-columns:minmax(0,1fr) auto}body.sessionRoute #view-session .currentSessionRuntimeFilters{width:100%;max-width:none}body.sessionRoute #view-session .currentSessionCard{min-height:224px;padding:16px 14px 12px}body.sessionRoute #view-session .currentSessionIdentity h3{display:-webkit-box;min-height:44px;overflow:hidden;font-size:var(--fs-20);line-height:1.16;white-space:normal;-webkit-box-orient:vertical;-webkit-line-clamp:2}body.sessionRoute #view-session .currentSessionMetrics{margin-top:16px}body.sessionRoute #view-session .currentSessionMetric{padding-right:10px}body.sessionRoute #view-session .currentSessionMetric b,body.sessionRoute #view-session .currentSessionMetric b.mono{font-size:var(--fs-18)}body.sessionRoute #view-session .currentSessionsArrivalMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}body.sessionRoute #view-session.sessionDetail .previewCost{font-size:var(--fs-36)}}
-@media(max-width:520px){body.sessionRoute #view-session .allSessionsHead{display:block}body.sessionRoute #view-session .allSessionsHint{display:block;margin-top:6px}body.sessionRoute #view-session .logsSummary .logKpis{grid-template-columns:1fr}body.sessionRoute #view-session .logsSummary .logStat,body.sessionRoute #view-session .logsSummary .logStat:nth-child(4){margin-top:0;padding:10px 12px;border-top:1px solid rgb(var(--tint-rgb)/.08);border-left:0}body.sessionRoute #view-session .logsSummary .logStat:first-child{border-top:0}}
-@media(max-width:520px){body.sessionRoute #view-session .currentSessionFilterGroups{display:grid;width:100%;max-width:none;overflow:visible}body.sessionRoute #view-session .currentSessionFilterGroup{min-width:0;max-width:100%;overflow-x:auto;overflow-y:hidden;scrollbar-width:thin}}
-@media(prefers-reduced-motion:reduce){body.sessionRoute #view-session .currentSessionCard{transition:none}body.sessionRoute #view-session :is(.sessionFlowStatus i,.currentSessionCard.is-arriving){animation:none!important}}
-.modelCellTip.fieldtip{display:table-cell}
-.modelCellTip>span{display:none}
-.modelKpi:hover,.modelKpi:focus-within{z-index:50}
-.modelKpi:nth-child(n+4) .fieldtip:after{left:auto;right:0}
-.modelHelp:before{content:"i";display:inline-grid;place-items:center;width:13px;height:13px;margin-right:4px;border:1px solid currentColor;border-radius:var(--radius-round);font:var(--fw-heavy) var(--fs-11)/1 var(--font-mono);opacity:.72}
-.modelCoverage.fieldtip{display:block}
-.modelCoverage.fieldtip:after{bottom:auto;top:calc(100% + 7px)}
-.learnSectionHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}
-.learnSectionHead .subline{margin-top:4px;max-width:820px}
-@media(max-width:520px){.learnSectionHead{display:block}.learnSectionHead .tbtn{margin-top:10px}}
-.srOnly{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
-.welcome{position:fixed;inset:0;width:100%;max-width:none;height:100%;max-height:none;margin:0;padding:0;border:0;background:var(--spectrum-page);color:var(--fg);overflow:hidden}
-.welcome[open]{display:grid;grid-template-rows:auto minmax(0,1fr);animation:welcomeFade var(--dur-enter) var(--ease-out)}
-.welcome::backdrop{background:var(--bg-deep)}
-.welcome:before{content:"";position:absolute;inset:0;z-index:-1;pointer-events:none;background-image:var(--page-texture);background-size:var(--page-texture-size);mask-image:linear-gradient(180deg,rgb(var(--shade-rgb)/.9),rgb(var(--shade-rgb)/.28) 52%,transparent)}
-.welcomeTop{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:16px 32px;border-bottom:1px solid var(--line)}
-.welcomeBrand{display:flex;align-items:baseline;gap:12px;min-width:0}
-.welcomeBrand b{color:var(--fg);font-family:var(--font-display);font-size:var(--fs-18);font-weight:var(--fw-semibold);letter-spacing:-.01em}
-.welcomeTopActions{display:flex;align-items:center;gap:12px}
-.welcomeClose{display:grid;place-items:center;width:40px;height:40px;padding:0;border:1px solid var(--line3);border-radius:var(--radius-round);background:rgb(var(--panel-rgb)/.72);color:var(--fg);font-size:var(--fs-16);line-height:1;cursor:pointer;transition:border-color var(--dur-press) var(--ease-out),background var(--dur-press) var(--ease-out),transform var(--dur-press) var(--ease-out)}
-.welcomeClose:hover{border-color:var(--spectrum-edge-hover);background:rgb(var(--signal-rgb)/.16)}
-.welcomeClose:active{transform:scale(.94)}
-:is(.welcomeClose,.welcomeSkip,.deckSkip,.deckStep,.deckPrimary,.leverRow):focus-visible{outline:2px solid var(--signal-hi);outline-offset:2px}
-:is(.welcomeSkip,.deckSkip){padding:8px 4px;border:0;border-radius:var(--radius-sm);background:none;color:var(--dim);font:inherit;font-size:var(--fs-13);font-weight:var(--fw-semibold);cursor:pointer}
-:is(.welcomeSkip,.deckSkip):hover{color:var(--fg)}
-.deckPrimary.tourReturn{position:fixed;right:24px;bottom:24px;z-index:40;display:inline-flex;align-items:center;gap:10px;padding:14px 24px;border-radius:var(--radius-lg);font-size:var(--fs-16);font-weight:var(--fw-heavy);box-shadow:var(--spectrum-glow);animation:tourReturnIn .42s cubic-bezier(.2,.8,.2,1) both,tourReturnPulse 1.6s ease-out .45s 3}
-.tourReturn[hidden]{display:none}
-.tourReturnArrow{display:inline-block;font-size:var(--fs-18);animation:tourReturnNudge 1.6s ease-in-out .45s 3}
-.tourReturn:hover .tourReturnArrow{transform:translateX(-3px)}
-@keyframes tourReturnIn{from{transform:translateY(16px) scale(.94)}to{transform:none}}
-@keyframes tourReturnPulse{0%{box-shadow:var(--spectrum-glow),0 0 0 0 rgb(var(--signal-rgb)/.55)}70%,100%{box-shadow:var(--spectrum-glow),0 0 0 14px rgb(var(--signal-rgb)/0)}}
-@keyframes tourReturnNudge{0%,100%{transform:none}50%{transform:translateX(-5px)}}
-@media(prefers-reduced-motion:reduce){.tourReturn,.tourReturnArrow{animation:none}}
-.deck{display:grid;grid-template-columns:212px minmax(0,1fr);min-width:0;min-height:0}
-.deckInline{min-height:560px;border:1px solid var(--spectrum-border);border-radius:var(--radius-lg);background:rgb(var(--panel-rgb)/.42);overflow:clip}
-.deckInline .deckRail{position:sticky;top:0;align-self:start;max-height:100vh;border-right:0}
-.deckInline .deckMain{border-left:1px solid var(--line)}
-.deckInline .deckStage{overflow:visible}
-.deckInline .deckFoot{position:sticky;bottom:0;z-index:2;background:rgb(var(--panel-rgb)/.94);backdrop-filter:blur(12px)}
-.deckRail{min-height:0;padding:24px 12px 24px 20px;overflow:auto;border-right:1px solid var(--line)}
-.welcome .deckRail{padding-left:28px}
-.deckChapters{display:grid;gap:18px;margin:0;padding:0;list-style:none}
-.deckChapter{display:grid;gap:4px}
-.deckChapter>h3{display:flex;align-items:baseline;gap:8px;margin:0 0 2px;padding-left:8px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.deckChapter[data-state=current]>h3{color:var(--signal-hi)}
-.deckChapter ol{display:grid;gap:2px;margin:0;padding:0;list-style:none}
-.deckStep{display:grid;grid-template-columns:14px minmax(0,1fr);align-items:baseline;gap:8px;width:100%;padding:6px 8px;border:0;border-radius:var(--radius-sm);background:none;color:var(--dim);font:inherit;font-size:var(--fs-13);line-height:1.35;text-align:left;cursor:pointer;transition:background var(--dur-press) var(--ease-out),color var(--dur-press) var(--ease-out)}
-.deckStep>i{color:var(--faint);font-family:var(--font-mono);font-size:var(--fs-11);font-style:normal}
-.deckStep:hover{background:rgb(var(--tint-rgb)/.05);color:var(--fg)}
-.deckStep[data-state=done]>i{color:var(--good)}
-.deckStep[aria-current=step]{background:rgb(var(--signal-rgb)/.12);color:var(--fg);font-weight:var(--fw-semibold)}
-.deckStep[aria-current=step]>i{color:var(--signal-hi)}
-.deckMain{display:grid;grid-template-rows:minmax(0,1fr) auto;min-width:0;min-height:0}
-.deckStage{display:grid;align-items:center;min-height:0;padding:28px 40px;overflow:auto}
-.deckSlide{display:grid;grid-template-columns:minmax(0,5fr) minmax(0,6fr);align-items:center;gap:40px;width:100%;max-width:1080px;margin:0 auto}
-.deckCopy{display:grid;justify-items:start;gap:14px;min-width:0}
-.deckKicker{color:var(--signal-hi);font-size:var(--fs-12);font-weight:var(--fw-heavy);letter-spacing:.06em;text-transform:uppercase}
-.deckCopy h2{margin:0;font-family:var(--font-display);font-size:var(--fs-36);font-weight:var(--fw-semibold);line-height:1.08;letter-spacing:-.02em;text-wrap:balance}
-.deckCopy p{margin:0;max-width:46ch;color:var(--dim);font-size:var(--fs-16);line-height:1.55}
-.deckInline .deckCopy h2{font-size:var(--fs-28)}
-.deckInline .deckCopy p{font-size:var(--fs-14)}
-.deckActions{display:flex;flex-wrap:wrap;align-items:center;gap:10px}
-.deckActions .tbtn{display:inline-flex;align-items:center;gap:6px;padding:8px 14px;font-size:var(--fs-13)}
-.deckVisual{padding:20px}
-.deckFoot{display:grid;grid-template-columns:minmax(0,1fr) auto minmax(0,1fr);align-items:center;gap:16px;padding:14px 40px 18px;border-top:1px solid var(--line)}
-.deckFoot[hidden]{display:none}
-.deckSkip{justify-self:start}
-.deckSkip:disabled{visibility:hidden}
-.deckCount{color:var(--faint);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.deckNav{display:flex;justify-content:flex-end;gap:8px}
-.deckNav .tbtn{min-width:88px;padding:10px 16px;font-size:var(--fs-13)}
-.deckNav .tbtn:disabled{opacity:.4;cursor:default}
-.deckPrimary{display:inline-flex;align-items:center;justify-content:center;gap:8px;min-width:88px;padding:10px 18px;border:0;border-radius:var(--radius-md);background:var(--spectrum-active);box-shadow:var(--spectrum-glow);color:var(--on-accent);font:inherit;font-size:var(--fs-13);font-weight:var(--fw-heavy);cursor:pointer;transition:transform var(--dur-press) var(--ease-out)}
-.deckPrimary:hover{background:var(--spectrum-active-hover)}
-.deckPrimary:active{transform:scale(.97)}
-.deckArrow{width:14px;height:14px;flex:0 0 auto;fill:none;stroke:currentColor;stroke-width:1.8;stroke-linecap:round;stroke-linejoin:round}
-@keyframes welcomeFade{from{opacity:0}to{opacity:1}}
-@keyframes deckRise{from{opacity:0;transform:translateY(8px)}to{opacity:1;transform:none}}
-.deckSlide.deckEnter>*{animation:deckRise var(--dur-enter) var(--ease-out) both}
-.deckSlide.deckEnter>.deckVisual{animation-delay:60ms}
-.deckVisual{min-width:0}
-.deckVisual>.conceptFrame{padding:20px 24px}
-.deckList{display:grid;gap:12px;min-width:0}
-.priceLadder{display:grid;gap:14px}
-.priceRow{display:grid;grid-template-columns:minmax(200px,auto) minmax(0,1fr) 52px 44px 24px;align-items:center;gap:12px;font-size:var(--fs-13)}
-.priceRow>b{text-align:right}
-.priceRow>small{color:var(--faint);font-size:var(--fs-12);text-align:right}
-.priceType{display:inline-flex;align-items:center;gap:8px;color:var(--fg);white-space:nowrap}
-.priceType>i{width:10px;height:10px;border-radius:var(--radius-2xs);background:var(--seg)}
-.leverList{display:grid;gap:8px;margin:0;padding:0;list-style:none}
-.leverRow{display:grid;grid-template-columns:20px minmax(0,1fr) auto 14px;align-items:center;gap:14px;width:100%;padding:14px 16px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.025);color:var(--fg);font:inherit;text-align:left;cursor:pointer;transition:border-color var(--dur-press) var(--ease-out),background var(--dur-press) var(--ease-out)}
-.leverRow:hover{border-color:var(--spectrum-edge-hover);background:rgb(var(--signal-rgb)/.08)}
-.leverRow>.deckArrow{color:var(--signal-hi)}
-.leverIcon{width:20px;height:20px;fill:none;stroke:var(--signal-hi);stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round}
-.leverName{min-width:0}
-.leverName>b{font-size:var(--fs-16);font-weight:var(--fw-semibold)}
-.leverPage{color:var(--faint);font-size:var(--fs-12);white-space:nowrap}
-.menuMock{display:grid;max-width:360px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--bg-deep-rgb)/.6)}
-.menuMockBar{display:flex;align-items:center;justify-content:flex-end;gap:10px;padding:8px 12px;border-bottom:1px solid var(--line);border-radius:var(--radius-md) var(--radius-md) 0 0;background:rgb(var(--tint-rgb)/.06);font-size:var(--fs-13)}
-.menuMockBar>b{color:var(--fg)}
-.menuMockBar>span{color:var(--dim)}
-.menuMockMark{width:12px;height:12px;border:2px solid var(--signal-hi);border-radius:var(--radius-round)}
-.menuMockRows{display:grid;gap:2px;margin:0;padding:8px 12px 10px}
-.menuMockRows>div{display:flex;align-items:center;gap:12px;padding:6px 0;font-size:var(--fs-14)}
-.menuMockRows dt{margin-right:auto;color:var(--dim)}
-.menuMockRows dd{margin:0;color:var(--fg)}
-.teamsRow{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:12px;padding:12px 14px;border:1px dashed var(--line3);border-radius:var(--radius-md)}
-.teamsRow>span{display:flex;align-items:baseline;gap:10px}
-.teamsRow b{font-size:var(--fs-16)}
-.teamsRow>.tbtn{padding:8px 14px;font-size:var(--fs-13);text-decoration:none}
-.chatMock{display:grid;gap:10px}
-.chatMock>p{margin:0;font-size:var(--fs-14);line-height:1.5}
-.chatAsk{justify-self:end;max-width:85%;padding:8px 12px;border-radius:var(--radius-lg) var(--radius-lg) var(--radius-2xs) var(--radius-lg);background:rgb(var(--signal-rgb)/.14);color:var(--fg)}
-.chatTool{color:var(--faint);font-size:var(--fs-12)}
-.chatAnswer{padding:10px 12px;border:1px solid var(--line2);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.04);color:var(--fg)}
-@media(max-width:1180px){.deck{grid-template-columns:200px minmax(0,1fr)}.deckStage{padding:20px 28px}.deckFoot{padding:12px 28px 16px}.deckSlide{grid-template-columns:1fr;gap:20px;max-width:760px}.deckCopy{grid-template-columns:minmax(0,1fr) auto;column-gap:24px;row-gap:8px}.deckCopy>*{grid-column:1}.deckCopy>.deckActions{grid-column:2;grid-row:1/span 3;align-self:end}.deckCopy h2,.deckInline .deckCopy h2{font-size:var(--fs-28)}.deckCopy p,.deckInline .deckCopy p{font-size:var(--fs-14)}}
-@media(max-height:800px){.welcomeTop{padding:10px 32px}.deckStage{padding-top:16px;padding-bottom:16px}.deckSlide{gap:16px}.deckCopy{gap:8px}.deckVisual>.conceptFrame{gap:12px;padding:16px 20px}.deckVisual .frameLegend{gap:6px}.deckVisual .conceptFrame>figcaption{padding-top:10px}}
-@media(max-width:900px){.deck{grid-template-columns:1fr}.deckRail{display:none}.deckFoot{grid-template-columns:auto 1fr}.deckCount{display:none}}
-@media(prefers-reduced-motion:reduce){.welcome[open],.deckSlide.deckEnter>*{animation:none}.welcomeClose,.deckPrimary,.deckStep,.leverRow,:where(.levelBar>i){transition:none}.welcomeClose:active,.deckPrimary:active{transform:none}}
-.globalControls.logsToolbar{grid-template-columns:minmax(260px,1.25fr) repeat(3,minmax(145px,.62fr));padding:14px;border:1px solid var(--line);border-radius:var(--radius-lg);background:linear-gradient(180deg,rgb(var(--panel-rgb)/.8),rgb(var(--bg2-rgb)/.78));box-shadow:var(--shadow-soft)}
-.logsToolbarRow{grid-column:1/-1;display:flex;flex-wrap:wrap;align-items:flex-end;gap:12px 20px;padding-top:12px;border-top:1px solid var(--line)}
-.logsToolbarRow .filterSort{order:1}
-.logsToolbarRow .filterChildren{order:2}
-.logsToolbar .filterClear{order:3;margin-left:auto;min-width:0}
-.logsToolbar .clearFilters{height:32px;padding:0 12px;font-size:var(--fs-12)}
-.logsToolbar .searchbox,.logsToolbar .filterSelect{height:40px}
-.logsToolbar .searchbox{background:rgb(var(--bg-rgb)/.58)}
-.logsToolbar .filterSelect{background:var(--panel)}
-.logsToolbarStatus{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:start;gap:12px;min-height:18px;margin:-3px 0 12px;padding:0 2px}
-.logsToolbarStatus .filterCount{grid-column:2;max-width:min(560px,50vw);white-space:normal;overflow-wrap:anywhere;line-height:1.3}
-.logsSummary .logStat .v{font-size:var(--fs-readout-md)}
-.activeFilters{display:flex;align-items:center;gap:6px;flex-wrap:wrap;margin:0;color:var(--faint);font-size:var(--fs-11)}
-.activeFilters[hidden]{display:none}
-.activeFilters>span{font-weight:var(--fw-bold);text-transform:uppercase}
-.activeFilters button{display:inline-flex;align-items:center;gap:6px;border:1px solid rgb(var(--signal-rgb)/.26);border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.08);color:var(--dim);padding:4px 8px;font:inherit;cursor:pointer}
-.activeFilters button:hover,.activeFilters button:focus-visible{border-color:rgb(var(--signal-rgb)/.55);color:var(--fg);outline:none}
-.activeFilters button b{color:var(--signal-hi);font-size:var(--fs-14);line-height:1}
-.srow:focus-visible{outline:0;border-color:rgb(var(--signal-rgb)/.7);box-shadow:var(--focus-ring),var(--shadow-soft)}
-.badge.app{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
-.badge.app:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:currentColor;box-shadow:0 0 10px currentColor}
-.badge.chatgpt{color:var(--badge-neutral);border-color:rgb(var(--badge-neutral-rgb)/.3);background:rgb(var(--badge-neutral-rgb)/.08)}
-@media(max-width:1120px) and (min-width:901px){.globalControls.logsToolbar{grid-template-columns:minmax(240px,1fr) repeat(2,minmax(150px,.7fr));}.logsToolbar .logSearchControl{grid-column:1/3}}
-@media(max-width:900px){.globalControls.logsToolbar{grid-template-columns:1fr 1fr}.logsToolbar .logSearchControl{grid-column:1/-1}.logsToolbarStatus{grid-template-columns:1fr;gap:6px}.logsToolbarStatus .filterCount{grid-column:1;max-width:none;text-align:left}}
-@media(max-width:520px){.globalControls.logsToolbar{grid-template-columns:1fr}.logsToolbar .logSearchControl{grid-column:1}.srow{padding:10px 10px;gap:8px}.badge.app{font-size:var(--fs-11)}}
-@media(max-width:520px){.sessionBudgetHead,.sessionBudgetMeta{align-items:flex-start;flex-direction:column}.sessionBudgetHead{gap:8px}.sessionBudgetExact{width:100%;justify-content:space-between}.sessionBudgetExact input{width:96px}.sessionBudgetTrack{grid-template-columns:44px minmax(0,1fr) 54px;gap:6px}.sessionBudgetMeta{gap:3px}}
-@media(max-width:520px){.budgetConfigHead{display:grid;grid-template-columns:1fr;gap:8px}.budgetAlertInline{justify-content:flex-start}.budgetSessionDefault{grid-template-columns:1fr}.budgetForm input[type=number],.budgetForm input[type=text]{font-size:var(--fs-16)}.budgetForm .budgetThresholds input[type=number]{width:48px;padding-right:16px;font-size:var(--fs-14)}}
-.modelHead>div:first-child{min-width:0}
-.modelControls{grid-template-columns:minmax(150px,210px) minmax(200px,280px) minmax(130px,160px)}
-.modelControls.deliveryControls{grid-template-columns:minmax(150px,210px) minmax(130px,160px)}
-.modelScopeStatus{margin:-6px 0 10px;padding:6px 10px;border-left:2px solid var(--accent);border-radius:0 var(--radius-sm) var(--radius-sm) 0;background:rgb(var(--signal-rgb)/.055);color:var(--dim);font-size:var(--fs-11)}
-.modelScopeStatus.warn{border-left-color:var(--warn);background:rgb(var(--orange-rgb)/.055);color:var(--warn)}
-.modelScopeStatus:empty{display:none}
-.modelTrendControls #m-metric{white-space:nowrap}
-.modelChartTip{max-width:min(620px,calc(100% - 16px))}
-.modelTipMetrics{grid-template-columns:repeat(7,minmax(0,1fr));gap:6px}
-#m-chart-tip{pointer-events:auto;overscroll-behavior:contain;scrollbar-gutter:stable;scrollbar-color:var(--line2) transparent;cursor:default}
-#m-chart-tip .h{position:sticky;top:0;z-index:1}
-.signalEmpty{min-height:82px;padding:12px}
-@media(max-width:1120px) and (min-width:901px){.modelControls{grid-template-columns:minmax(130px,180px) minmax(170px,230px) minmax(120px,145px)}.modelControls.deliveryControls{grid-template-columns:minmax(130px,180px) minmax(120px,145px)}}
-@media(max-width:900px){.modelControls{grid-template-columns:repeat(3,minmax(0,1fr))}}
-@media(max-width:700px){#m-metric{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));width:100%}.modelTrendControls{display:grid;justify-content:stretch;margin-top:8px}.modelTipMetrics{grid-template-columns:repeat(4,minmax(0,1fr))}}
-@media(max-width:520px){.modelControls{grid-template-columns:1fr}}
-:is(.modelHead,.efficiencyHead).spectrumPageHead{overflow:hidden;z-index:2}
-.spectrumPageHeadFrame:has(.modelControls){z-index:10}
-.modelPickerMenu{max-height:min(360px,calc(100dvh - 136px))}
-.modelPicker.opensUp .modelPickerMenu{top:auto;bottom:calc(100% + 6px)}
-body.spectrumApp .currentSessionCard:hover,body.spectrumApp.sessionRoute #view-session .currentSessionCard:hover{transform:none}
-body.spectrumApp.sessionRoute #view-session .srow:hover{transform:none}
-/* tools-review-workflow-v3 */
-.capStats{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));margin:0 0 12px;padding:0!important;overflow:hidden}
-.capStat{display:grid;min-width:0;min-height:88px;align-content:center;gap:2px;padding:12px 16px;border:0;border-left:1px solid var(--line);background:transparent;color:var(--fg);font:inherit;text-align:left;cursor:pointer}
-.capStat:first-child{border-left:0}
-.capStat:hover{background:rgb(var(--signal-rgb)/.055)}
-.capStat.on{background:linear-gradient(145deg,rgb(var(--signal-rgb)/.13),rgb(var(--signal-mid-rgb)/.045));box-shadow:inset 0 -2px 0 var(--accent)}
-.capStatLabel{color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-heavy)}
-.capStat strong{font:var(--fw-bold) var(--fs-22)/1.15 var(--font-mono)}
-.capStatDetail{overflow-wrap:anywhere;color:var(--faint);font-size:var(--fs-11);line-height:1.35}
-.capReviewQueue{margin:0;overflow:hidden;border-color:rgb(var(--signal-rgb)/.3);background:rgb(var(--panel-rgb)/.94)}
-.capReviewQueue.good{border-color:rgb(var(--green-rgb)/.3)}
-.capReviewQueue.warn{border-color:rgb(var(--orange-rgb)/.42)}
-.capQueueHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px;padding:16px 18px 12px}
-.capQueueHead h2{margin:0;font-size:var(--fs-18)}
-.capQueueDetail{max-width:780px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
-.capQueueCount{flex:none;padding-top:2px;color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.4 var(--font-mono)}
-.capReviewList{display:grid}
-.capQueueLoading,.capQueueEmpty{padding:24px 18px;color:var(--dim);font-size:var(--fs-12)}
-.capQueueEmpty h3{margin:0;color:var(--fg);font-size:var(--fs-16)}
-.capQueueEmpty p{max-width:760px;margin:4px 0 0;line-height:1.5}
-.capQueueEmpty .tbtn{margin-top:12px}
-.capReviewHead,.capReviewItem{display:grid;grid-template-columns:minmax(0,1fr) 84px;align-items:start;gap:0 12px;padding:4px 18px;border-bottom:1px solid var(--line)}
-.capReviewHead{padding-top:8px;padding-bottom:6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
-.capReviewHead>span:last-child{text-align:right}
-.capReviewItem:last-child{border-bottom:0}
-.capReviewItem>.capSelect{justify-self:end}
-.capReviewCols{display:grid;grid-template-columns:12px minmax(0,1fr) 148px 92px 72px 124px;align-items:center;gap:12px;min-width:0}
-.capReviewHead .capReviewCols:before{content:""}
-.capReviewRow{min-width:0}
-.capReviewRow>summary{min-height:36px;border-radius:var(--radius-sm);list-style:none;cursor:pointer}
-.capReviewRow>summary::-webkit-details-marker{display:none}
-.capReviewRow>summary:before{content:"\25B8";color:var(--faint);font-size:var(--fs-11);transition:transform .15s ease}
-.capReviewRow[open]>summary:before{transform:rotate(90deg)}
-.capReviewRow>summary:hover{background:rgb(var(--signal-rgb)/.035)}
-.capReviewRow>summary:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
-.capReviewName{display:flex;align-items:baseline;gap:8px;min-width:0;overflow:hidden;white-space:nowrap}
-.capReviewName strong{overflow:hidden;color:var(--fg);font-size:var(--fs-14);text-overflow:ellipsis}
-.capReviewName span{flex:none;color:var(--faint);font-size:var(--fs-11)}
-.capReviewNum{overflow:hidden;color:var(--fg);font:var(--fw-semibold) var(--fs-12)/1.4 var(--font-mono);font-variant-numeric:tabular-nums;text-overflow:ellipsis;white-space:nowrap}
-.capReviewCols .stateDot{color:var(--dim);font-size:var(--fs-11)}
-.capSelect{display:inline-flex;min-height:36px;align-items:center;gap:6px;padding:0 8px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);color:var(--fg);font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer}
-.capSelect input{width:15px;height:15px;accent-color:var(--warn)}
-.capReviewFacts{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:0;margin:0;border-top:1px solid var(--line);border-bottom:1px solid var(--line)}
-.capReviewFacts>div{padding:10px 12px;border-left:1px solid var(--line)}
-.capReviewFacts>div:first-child{padding-left:0;border-left:0}
-.capReviewFacts dt{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.capReviewFacts dd{margin:4px 0 0;color:var(--fg);font-size:var(--fs-12);line-height:1.4}
-.capReviewImpact{margin:0;color:var(--dim);font-size:var(--fs-12);line-height:1.5}
-.capReviewDisclosureBody{display:grid;gap:6px;margin:4px 0 8px 24px;padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.28);color:var(--dim);font-size:var(--fs-11)}
-.capReviewDisclosureBody b{color:var(--fg)}
-.capReviewMembers{display:flex;flex-wrap:wrap;gap:4px}
-.capReviewMembers span{padding:3px 6px;border:1px solid var(--line);border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.025);color:var(--dim);font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono)}
-.capReviewControl{overflow-wrap:anywhere;color:var(--faint);font:var(--fw-semibold) var(--fs-11)/1.45 var(--font-mono)}
-.capSelectionBar{display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:10px 18px;border-top:1px solid rgb(var(--orange-rgb)/.3);background:rgb(var(--orange-rgb)/.06)}
-.capSelectionBar[hidden]{display:none}
-.capSelectionBar span{margin-right:auto;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.capSelectionBar .tbtn{min-height:36px}
-.capInventory{margin-top:12px;padding:0!important;overflow:hidden}
-.capInventoryHead{display:flex;align-items:center;gap:16px;padding:14px 16px}
-.capInventorySummary{display:grid;gap:2px;min-width:0}
-.capInventorySummary h2{margin:0;font-size:var(--fs-14)}
-.capInventoryCount{margin-left:auto;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.4 var(--font-mono);white-space:nowrap}
-.capInventoryBody{padding:14px 16px 16px;border-top:1px solid var(--line)}
-.capCatalog{display:grid;grid-template-columns:minmax(220px,.42fr) minmax(0,1fr);align-items:center;gap:20px;margin:0 0 12px;padding:0 0 12px;border-bottom:1px solid var(--line)}
-.capCatalogHead{display:grid;gap:2px}
-.capCatalogHead b{font-size:var(--fs-12)}
-.capCatalogHead small{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-medium)}
-.capCatalogHead .subline{margin:3px 0 0}
-.capCatalogBody{min-width:0}
-.capFilterControl{display:grid;gap:4px;min-width:0}
-.capFilterControl>span{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.capFilters{grid-template-columns:minmax(230px,1fr) auto auto minmax(130px,auto);align-items:end;padding:12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--panel-rgb)/.66)}
-.capFilters .searchbox,.capFilters select{width:100%;height:38px;background:rgb(var(--bg-rgb)/.58)}
-.capFilterStatus{display:flex;align-items:flex-start;justify-content:space-between;gap:12px;min-height:18px;margin:-3px 0 10px;padding:0 2px}
-.capFilterStatus .clearFilters{padding:4px 8px}
-.capTableWrap{overflow-x:auto;border:1px solid var(--line);border-radius:var(--radius-md)}
-.capTableWrap .tbl{min-width:940px}
-.capEvidence{display:grid;gap:2px}
-.capEvidence strong{color:var(--fg);font-size:var(--fs-12)}
-.capEvidence small{color:var(--faint);font-size:var(--fs-11);line-height:1.35}
-.stateDot.unknown:before{background:var(--faint)}
-.stateDot.observed:before{background:var(--accent)}
-.capEmpty,.capMore{padding:28px!important;text-align:center;color:var(--faint)}
-.capEmpty button{margin-left:8px}
-.capPath{max-width:280px}
-.capCatalogHead>span:first-child{display:grid;gap:2px}
-@media(max-width:1400px){.capFilters{grid-template-columns:1fr 1fr}.capFilterControl:first-child{grid-column:1/-1}}
-@media(max-width:800px){.capReviewFacts{grid-template-columns:1fr}.capReviewFacts>div,.capReviewFacts>div:first-child{padding:8px 0;border-left:0;border-top:1px solid var(--line)}.capReviewFacts>div:first-child{border-top:0}.capReviewHead{display:none}.capReviewCols{grid-template-columns:12px minmax(0,1fr)}.capReviewCols>:nth-child(n+2){grid-column:2}.capReviewDisclosureBody{margin-left:0}.capInventoryHead{align-items:flex-start}.capCatalog{grid-template-columns:1fr;gap:8px}.capCatalogHead{grid-template-columns:minmax(0,1fr) auto;align-items:start}.capCatalogHead .subline{margin:0}.capFilters{grid-template-columns:1fr;padding:10px}.capFilterControl:first-child{grid-column:1}.capFilters .seg{width:100%}.capFilters .seg button{flex:1}.capTableWrap{overflow:visible;border:0;border-radius:0}.capTableWrap .tbl{display:block;min-width:0}.capTableWrap thead{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}.capTableWrap tbody{display:grid;gap:8px}.capTableWrap tr{display:grid;padding:12px;border:1px solid var(--line);border-radius:var(--radius-md);background:var(--spectrum-card);box-shadow:var(--shadow-soft)}.capTableWrap td{display:grid;grid-template-columns:minmax(92px,.38fr) minmax(0,1fr);gap:10px;padding:6px 0;border-bottom:1px solid rgb(var(--tint-rgb)/.055);overflow-wrap:anywhere}.capTableWrap td:last-child{border-bottom:0}.capTableWrap td:before{content:attr(data-label);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.capTableWrap td.nm{display:block;padding-top:2px;font-size:var(--fs-16)}.capTableWrap td.nm:before{display:block;margin-bottom:4px}.capTableWrap .capPath{max-width:100%;white-space:normal}.capTableWrap .capEmpty{display:block}.capTableWrap .capEmpty:before{display:none}.capFilterStatus{align-items:stretch;flex-direction:column}.capFilterStatus .clearFilters{align-self:flex-start}.capCatalogBody .legend{gap:8px}}
-.capMobileSort{display:none}
-@media(max-width:800px){.capMobileSort{display:grid;grid-template-columns:auto minmax(150px,220px);align-items:center;justify-content:end;gap:8px;margin:10px 0;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.capMobileSort select{height:38px}.capTableWrap .capMore{display:block}.capTableWrap .capMore:before{display:none}}
-@media(max-width:520px){.capStat{min-height:86px;padding:10px 8px}.capStat strong{font-size:var(--fs-20)}.capStatDetail{font-size:var(--fs-11)}.capQueueHead,.capReviewItem,.capQueueEmpty{padding-left:12px;padding-right:12px}.capQueueHead{display:grid}.capQueueCount{padding:0}.capSelect{min-height:44px;justify-content:center}.capSelectionBar{align-items:stretch;flex-wrap:wrap;padding:10px 12px}.capSelectionBar span{width:100%;margin:0}.capSelectionBar .tbtn{min-height:44px;flex:1}.capInventoryHead{padding:12px}.capInventoryBody{padding:12px}.capCatalogHead .subline{display:none}}
-.modelChartTip{max-width:min(440px,calc(100% - 16px))}
-.modelTipMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}
-.spendRangeControls{display:grid;justify-items:end;gap:8px;max-width:100%}
-.spendCustom{display:flex;align-items:flex-end;justify-content:flex-end;gap:8px;flex-wrap:wrap}
-.spendCustom[hidden]{display:none}
-.spendCustom label{display:grid;gap:4px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.spendCustom input{height:36px;min-width:144px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.62);padding:0 8px;color:var(--fg);color-scheme:dark;font:var(--fw-semibold) var(--fs-11)/1 var(--font-mono)}
-.spendCustom input:focus-visible{border-color:var(--accent);outline:2px solid rgb(var(--signal-rgb)/.2);outline-offset:1px}
-.spendCustom #s-range-error{max-width:270px;padding-bottom:8px;color:var(--bad);font-size:var(--fs-11)}
-.spendKpis{display:grid;grid-template-columns:1.25fr repeat(3,minmax(0,1fr));gap:12px}
-.spendKpi{min-width:0;padding:14px 16px}
-.spendKpi .v{margin-top:4px;overflow-wrap:anywhere;font-size:var(--fs-24);letter-spacing:-.02em}
-.spendKpi:first-child .v{font-size:var(--fs-28)}
-.spendKpi .subline{min-height:16px;margin-top:4px;font-size:var(--fs-11)}
-.spendChartCard{margin-top:12px;padding:16px 18px 14px;overflow:hidden}
-.spendChartHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px}
-.spendChartHead h2,.spendPanelHead h2,.spendPlatformCard h2{margin:0;font-size:var(--fs-14)}
-.spendChartHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-12)}
-.spendChartControls{display:grid;justify-items:end;gap:8px}
-.spendChartControls .seg button{padding:4px 12px;font-size:var(--fs-12)}
-.spendChartControls .seg button[aria-disabled=true]{opacity:.42;cursor:not-allowed}
-.spendLegend{display:flex;align-items:center;justify-content:flex-end;gap:12px;flex-wrap:wrap;color:var(--dim);font-size:var(--fs-11)}
-.spendLegend span{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
-.spendLegend i{width:9px;height:9px;border-radius:var(--radius-2xs);background:var(--spend-color)}
-.spendLegend .spendEstimateKey i{border:1px solid rgb(var(--tint-rgb)/.28);background:repeating-linear-gradient(135deg,rgb(var(--tint-rgb)/.38) 0 1px,transparent 1px 4px),rgb(var(--tint-rgb)/.08)}
-.spendLegend .spendPartialKey i{border:1px solid rgb(var(--tint-rgb)/.7)}
-.spendLegend .spendIncompleteKey i{border:1px dashed rgb(var(--tint-rgb)/.5);background:rgb(var(--tint-rgb)/.14)}
-.spendChart{min-height:270px;margin-top:12px;overflow:hidden;display:grid;grid-template-columns:58px minmax(0,1fr);--spend-day-head:22px;--spend-day-foot:24px;--spend-day-gap:3px;--spend-chart-h:260px}
-.spendYAxis{height:var(--spend-chart-h);display:flex;flex-direction:column;justify-content:space-between;padding:calc(var(--spend-day-head) + var(--spend-day-gap)) 8px calc(var(--spend-day-foot) + var(--spend-day-gap)) 0;color:var(--faint);font-size:var(--fs-11);text-align:right}
-.spendPlot{position:relative;min-width:0;overflow:hidden;border-bottom:1px solid var(--line)}
-.spendYAxis span{line-height:0}
-.spendGrid{position:absolute;top:calc(var(--spend-day-head) + var(--spend-day-gap));right:0;left:0;height:calc(var(--spend-chart-h) - var(--spend-day-head) - var(--spend-day-foot) - 2*var(--spend-day-gap));background:repeating-linear-gradient(to bottom,rgb(var(--tint-rgb)/.07) 0 1px,transparent 1px 25%);pointer-events:none}
-.spendChartInner{position:relative;width:100%;height:var(--spend-chart-h);display:flex;align-items:stretch}
-.spendDay{appearance:none;position:relative;display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:var(--spend-day-head) minmax(0,1fr) var(--spend-day-foot);flex:1 1 0;min-width:0;gap:var(--spend-day-gap);border:0;border-radius:var(--radius-sm);background:transparent;padding:0;color:var(--faint);font:inherit;cursor:pointer}
-.spendDay:hover,.spendDay:focus-visible{background:rgb(var(--signal-rgb)/.055);outline:none}
-.spendDay:focus-visible{box-shadow:inset 0 0 0 1px rgb(var(--signal-rgb)/.52)}
-.spendBarValue{overflow:hidden;color:var(--dim);font-size:var(--fs-11);text-align:center;text-overflow:ellipsis;white-space:nowrap;opacity:0}
-.spendDay:hover .spendBarValue{opacity:1}
-.spendDayTrack .spendBarValue{flex:none;max-width:100%;padding-bottom:3px;line-height:1.3}
-.spendChartInner[data-values=shown] .spendBarValue{opacity:1}
-.spendDay[data-peak=true] .spendBarValue{position:relative;z-index:1;max-width:none;overflow:visible;color:var(--fg);font-weight:var(--fw-bold);opacity:1}
-.spendDay[data-peak=true][data-peak-edge=first] .spendBarValue{align-self:flex-start}
-.spendDay[data-peak=true][data-peak-edge=last] .spendBarValue{align-self:flex-end}
-.spendDayTrack{grid-row:2;display:flex;height:100%;min-height:0;flex-direction:column;align-items:center;justify-content:flex-end;border-bottom:1px solid var(--line2)}
-.spendDayStack{display:flex;flex:none;width:min(var(--spend-bar-max,24px),var(--spend-bar-share,64%));min-width:2px;height:var(--spend-height);min-height:0;flex-direction:column-reverse;overflow:hidden;transition:opacity .16s,filter .16s}
-.spendChartInner[data-granularity] .spendDay:is(:hover,:focus-visible) .spendDayStack{filter:brightness(1.18)}
-.spendChartInner[data-dense=true]{--spend-bar-share:52%}
-.spendChartInner[data-granularity=week]{--spend-bar-max:44px}
-.spendChartInner[data-granularity=month]{--spend-bar-max:64px}
-.spendChartInner[data-granularity]:hover .spendDay:not(:hover) .spendDayStack,.spendChartInner[data-granularity]:has(.spendDay:focus-visible) .spendDay:not(:focus-visible) .spendDayStack{opacity:.45}
-.spendDay[data-incomplete=true] .spendDayStack{opacity:.6;outline:1px dashed rgb(var(--tint-rgb)/.5);outline-offset:1px}
-.spendChartInner[data-granularity] .spendDay[data-incomplete=true]:is(:hover,:focus-visible) .spendDayStack{opacity:.85}
-.spendStackSegment{display:block;flex:none;height:var(--segment-share);min-height:1px;background:var(--spend-color)}
-.spendStackSegment[data-estimated=true]{background:repeating-linear-gradient(135deg,rgb(var(--tint-rgb)/.32) 0 1px,transparent 1px 4px),var(--spend-color)}
-.spendStackSegment[data-partial=true]{box-shadow:inset 0 0 0 1px rgb(var(--tint-rgb)/.32)}
-.spendChartInner[data-granularity] .spendStackSegment{opacity:.82;transition:opacity .16s}
-.spendChartInner[data-granularity] .spendStackSegment+.spendStackSegment{border-bottom:1px solid rgb(var(--bg2-rgb)/.9)}
-.spendChartInner[data-granularity] .spendDay:is(:hover,:focus-visible) .spendStackSegment{opacity:1}
-.spendDayLabel{position:absolute;bottom:0;left:50%;width:max-content;max-width:none;transform:translateX(-50%);font-size:var(--fs-11);line-height:20px;text-align:center;white-space:nowrap;pointer-events:none}
-.spendDay[data-axis-edge=first] .spendDayLabel{left:0;transform:none;text-align:left}
-.spendDay[data-axis-edge=last] .spendDayLabel{right:0;left:auto;transform:none}
-.spendAverageLine{position:absolute;z-index:2;right:0;left:0;height:1px;border-top:1px solid rgb(var(--soft-rgb)/.62);pointer-events:none}
-.spendAverageLine[hidden]{display:none}
-.spendAverageLine span{position:absolute;right:3px;bottom:4px;border-radius:var(--radius-xs);background:rgb(var(--bg2-rgb)/.88);padding:1px 4px;color:var(--soft);font-size:var(--fs-11);line-height:1.35}
-.spendChartTip{z-index:8;width:min(250px,calc(100% - 24px));padding:10px 10px;font-size:var(--fs-11);line-height:1.45}
-.spendChartTip[hidden]{display:none}
-.spendTipDate{color:var(--fg);font-weight:var(--fw-heavy)}
-.spendTipTotal{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-top:4px;padding-bottom:6px;border-bottom:1px solid var(--line)}
-.spendTipTotal b{color:var(--fg)}
-.spendTipNote{margin-top:6px;color:var(--warn);font-size:var(--fs-11)}
-.spendTipSpan{margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.spendTipRuntimes{display:grid;margin-top:4px}
-.spendTipRuntime{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:1px 8px;padding:4px 0;border-top:1px solid var(--line)}
-.spendTipRuntime:first-child{border-top:0}
-.spendTipRuntime>span{display:flex;align-items:center;gap:6px;color:var(--fg);font-weight:var(--fw-bold)}
-.spendTipRuntime i{width:8px;height:8px;border-radius:var(--radius-2xs);background:var(--spend-color)}
-.spendTipRuntime b{color:var(--fg)}
-.spendTipRuntime small{grid-column:1/-1;color:var(--faint);font-size:var(--fs-11)}
-.spendTipEmpty{padding:6px 0;color:var(--faint)}
-.spendEvidenceGrid{display:grid;grid-template-columns:minmax(0,1.3fr) minmax(300px,.7fr);align-items:stretch;gap:12px;margin-top:12px}
-.spendLogsCard,.spendPlatformCard{height:360px;display:flex;min-height:0;flex-direction:column;padding:16px 18px}
-.spendPanelHead{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}
-.spendPanelHead>div>span,.spendPanelHead>span{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.spendPanelHead>span{flex:none}
-.spendLogs{display:grid;min-height:0;flex:1;margin-top:6px;overflow-y:auto;overflow-x:hidden;scrollbar-gutter:stable;scrollbar-color:var(--line2) transparent}
-.spendLogRow{height:68px;display:grid;grid-template-columns:28px minmax(0,1fr) auto auto;align-items:center;gap:10px;padding:0;border-top:1px solid var(--line)}
-.spendLogRow:first-child{border-top:0}
-.spendLogRank{width:24px;height:24px;display:grid;place-items:center;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.spendLogMain{min-width:0}
-.spendLogName{overflow:hidden;color:var(--fg);font-weight:var(--fw-bold);text-overflow:ellipsis;white-space:nowrap}
-.spendLogMeta{margin-top:1px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.spendLogTrack{height:4px;margin-top:6px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045)}
-.spendLogTrack i{display:block;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi))}
-.spendLogValue{min-width:84px;text-align:right}
-.spendLogValue strong{display:block;font-size:var(--fs-13)}
-.spendLogValue span{display:block;margin-top:1px;color:var(--faint);font-size:var(--fs-11)}
-.spendLogRow .tbtn{min-height:34px}
-.spendLogEmpty,.spendEmpty{min-height:100%;padding:18px}
-.spendPlatformBody{min-height:0;flex:1;overflow-y:auto;overflow-x:hidden;scrollbar-gutter:stable;scrollbar-color:var(--line2) transparent}
-.spendPlatformRows{display:grid;margin-top:8px}
-.spendPlatformRow{display:grid;grid-template-columns:minmax(78px,.48fr) minmax(72px,1fr) minmax(82px,auto);align-items:center;gap:10px;padding:8px 0;border-top:1px solid var(--line)}
-.spendPlatformRow:first-child{border-top:0}
-.spendPlatformName{display:flex;min-width:0;align-items:center;gap:8px;font-weight:var(--fw-bold)}
-.spendPlatformName i{width:9px;height:9px;flex:none;border-radius:var(--radius-2xs);background:var(--spend-color)}
-.spendPlatformTrack{height:7px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045)}
-.spendPlatformTrack i{display:block;height:100%;border-radius:inherit;background:var(--spend-color)}
-.spendPlatformValue{min-width:82px;text-align:right;font-weight:var(--fw-heavy)}
-.spendPlatformValue span{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-semibold)}
-.spendInsightSection{margin-top:28px}
-.spendInsightHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:10px;padding-top:20px;border-top:1px solid var(--line)}
-.spendInsightHead h2{margin:0;font-size:var(--fs-18)}
-.spendInsightHead p{max-width:760px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.5}
-.spendInsightRange{flex:none;color:var(--faint);font:var(--fw-semibold) var(--fs-11)/1.4 var(--font-mono)}
-.spendInsightGrid{display:grid;grid-template-columns:minmax(290px,.72fr) minmax(0,1.28fr);gap:12px}
-.spendConcentrationCard,.spendShapeCard,.spendScatterCard{padding:16px 18px}
-.spendInsightCardHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
-.spendInsightCardHead h3{margin:0;font-size:var(--fs-14)}
-.spendInsightCardHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.45}
-.spendConcentrationValue{margin-top:18px;color:var(--fg);font:var(--fw-heavy) var(--fs-44)/1 var(--font-mono);letter-spacing:-.035em}
-.spendConcentrationNote{min-height:34px;margin-top:6px;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
-.spendConcentrationBar{height:12px;margin-top:14px;overflow:hidden;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.035)}
-.spendConcentrationBar i{display:block;height:100%;width:0;border-radius:inherit;background:linear-gradient(90deg,var(--signal-hi),var(--accent))}
-.spendConcentrationLegend{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-top:6px;color:var(--faint);font-size:var(--fs-11)}
-.spendImpactList{display:grid;margin-top:14px;border-top:1px solid var(--line)}
-.spendImpactRow{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:10px;width:100%;align-items:center;border:0;border-bottom:1px solid var(--line);background:transparent;padding:8px 0;color:var(--fg);font:inherit;text-align:left;cursor:pointer}
-.spendImpactRow:last-child{border-bottom:0}
-.spendImpactRow:hover .spendImpactName,.spendImpactRow:focus-visible .spendImpactName{color:var(--accent)}
-.spendImpactRow:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:var(--radius-xs)}
-.spendImpactName{min-width:0;overflow:hidden;font-size:var(--fs-12);font-weight:var(--fw-bold);text-overflow:ellipsis;white-space:nowrap}
-.spendImpactValue{text-align:right}
-.spendImpactValue b{display:block;font-size:var(--fs-12)}
-.spendImpactValue small{display:block;margin-top:1px;color:var(--faint);font-size:var(--fs-11)}
-.spendShape{margin-top:10px}
-.spendShapeHeader,.spendShapeRow{display:grid;grid-template-columns:118px 72px minmax(150px,1fr) minmax(280px,.9fr);align-items:center;gap:12px}
-.spendShapeHeader{padding:0 0 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.spendShapeHeader span:last-child{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;text-align:right}
-.spendShapeRow{min-height:62px;border-top:1px solid var(--line)}
-.spendShapeIdentity b{display:block;font-size:var(--fs-12)}
-.spendShapeIdentity small,.spendShapeCoverage{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.spendShapeCoverage{margin:0}
-.spendShapeRail{position:relative;height:22px}
-.spendShapeRail:before{content:"";position:absolute;top:10px;right:0;left:0;height:2px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.09)}
-.spendShapeIqr{position:absolute;top:7px;left:var(--p25);width:calc(var(--p75) - var(--p25));height:8px;border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.3)}
-.spendShapeMedian,.spendShapeMean{position:absolute;top:4px;left:var(--median);width:2px;height:14px;border-radius:var(--radius-2xs);background:var(--accent);transform:translateX(-50%)}
-.spendShapeMean{top:7px;left:var(--mean);width:7px;height:7px;border:1px solid var(--panel);background:var(--signal-hi);transform:translateX(-50%) rotate(45deg)}
-.spendShapeValues{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;text-align:right}
-.spendShapeValues span{min-width:0;overflow:hidden;color:var(--dim);font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono);text-overflow:ellipsis;white-space:nowrap}
-.spendShapeEmpty{min-height:228px}
-.spendScatterCard{position:relative;margin-top:12px;overflow:hidden}
-.spendScatterControls{display:flex;align-items:center;justify-content:flex-end;gap:12px;flex-wrap:wrap}
-.spendScatterCoverage{color:var(--faint);font-size:var(--fs-11)}
-.spendScatterWrap{position:relative;margin-top:10px}
-.spendScatterSvg{display:block;width:100%;height:340px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.28)}
-.spendScatterPoint{cursor:pointer;transition:r .14s ease,stroke-width .14s ease}
-.spendScatterPoint:hover,.spendScatterPoint:focus{r:8;stroke-width:3}
-.spendScatterLink:focus{outline:none}
-.spendScatterLink:focus .spendScatterPoint{r:8;stroke:var(--white);stroke-width:3}
-.spendScatterTip{z-index:8;width:min(270px,calc(100% - 20px));padding:10px 10px;font-size:var(--fs-11);line-height:1.45}
-.spendScatterTip[hidden]{display:none}
-.spendScatterTip b{display:block;overflow:hidden;margin-bottom:4px;color:var(--fg);font-size:var(--fs-12);text-overflow:ellipsis;white-space:nowrap}
-.spendScatterTip span{display:flex;justify-content:space-between;gap:12px}
-.spendScatterTip strong{color:var(--fg);font-weight:var(--fw-bold)}
-.spendScatterLegend{display:flex;align-items:center;gap:12px;margin-top:8px;color:var(--faint);font-size:var(--fs-11)}
-.spendScatterLegend span{display:inline-flex;align-items:center;gap:4px}
-.spendScatterLegend span[hidden]{display:none}
-.spendScatterLegend i{width:8px;height:8px;border-radius:var(--radius-round);background:var(--accent)}
-.spendScatterLegend i.top{border:2px solid var(--signal-hi);background:transparent}
-.spendShapeHeader,.spendShapeRow{grid-template-columns:100px 64px minmax(104px,1fr) minmax(225px,.9fr);gap:8px}
-.spendShapeHeader span:last-child i{font-style:normal}
-.spendScatterLegend i.spendScatterTopDot{border:2px solid var(--signal-hi);background:transparent}
-@media(max-width:900px){.spendRangeControls{width:100%;justify-items:start}.spendKpis{grid-template-columns:repeat(2,minmax(0,1fr))}.spendChartHead{display:grid}.spendLegend{justify-content:flex-start}.spendCustom{justify-content:flex-start}.spendEvidenceGrid,.spendInsightGrid{grid-template-columns:1fr}.spendInsightHead{align-items:flex-start;flex-direction:column}.spendInsightRange{white-space:normal}.spendScatterControls{justify-content:flex-start}}
-@media(max-width:700px){.spendShapeHeader{display:none}.spendShapeRow{grid-template-columns:minmax(0,1fr) auto;gap:8px;padding:10px 0}.spendShapeRail,.spendShapeValues{grid-column:1/-1}.spendShapeValues span{display:grid;gap:2px;text-align:left}.spendShapeValues span:before{content:attr(data-label);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-sans);text-transform:uppercase}.spendScatterSvg{height:300px}}
-@media(max-width:520px){.spendKpis{grid-template-columns:1fr}.spendKpi .v,.spendKpi:first-child .v{font-size:var(--fs-22)}.spendCustom{display:grid;grid-template-columns:1fr 1fr;width:100%}.spendCustom label,.spendCustom input{width:100%;min-width:0}.spendCustom #s-range-error{grid-column:1/-1;padding:0}.spendPlatformRow{grid-template-columns:minmax(0,1fr) auto}.spendPlatformTrack{grid-column:1/-1;grid-row:2}.spendChartCard{padding-inline:12px}.spendChart{grid-template-columns:44px minmax(0,1fr)}.spendYAxis{padding-right:6px;font-size:var(--fs-11)}.spendLogsCard,.spendPlatformCard,.spendConcentrationCard,.spendShapeCard,.spendScatterCard{padding:14px 12px}.spendLogRow{height:86px;grid-template-columns:24px minmax(0,1fr) auto;gap:8px}.spendLogRank{width:22px;height:22px}.spendLogValue{grid-column:2/4;grid-row:2;display:flex;min-width:0;align-items:baseline;justify-content:space-between;gap:10px;text-align:left}.spendLogValue strong,.spendLogValue span{display:block;margin:0}.spendLogRow .tbtn{grid-column:3;grid-row:1;min-height:44px;padding-inline:12px}.spendConcentrationValue{font-size:var(--fs-36)}.spendInsightCardHead{display:grid}.spendScatterControls .seg{width:100%}.spendScatterControls .seg button{flex:1}.spendScatterSvg{height:270px}.spendScatterLegend{align-items:flex-start;flex-direction:column;gap:4px}}
-@media(max-width:900px){.spectrumPageActions .modelControls{display:grid;width:100%;grid-template-columns:repeat(3,minmax(0,1fr));gap:6px}.spectrumPageActions .modelControls .filterControl{min-width:0}.spectrumPageActions .spendRangeControls{display:block;width:100%;min-width:0}}
-@media(max-width:520px){.spectrumPageActions .modelControls{grid-template-columns:repeat(3,minmax(0,1fr))}}
-.currentSessionRuntime:before,.badge.app:before{content:none}
-.runtimeMark{display:block;width:16px;height:16px;flex:0 0 auto;overflow:visible;color:currentColor}
-.runtimeMark path,.runtimeMark circle,.runtimeMark polygon{vector-effect:non-scaling-stroke}
-.currentSessionRuntime .runtimeMark{width:18px;height:18px}
-.efficiencyHeadline{min-height:166px;padding:12px 14px 10px}
-.efficiencySupportItem{min-height:166px;padding:12px 14px 10px}
-.efficiencyHeadline .efficiencyChart{height:56px}
-.efficiencySupportItem .efficiencyChart{height:56px}
-.deliveryOverview{margin-top:14px;padding:0 20px;overflow:hidden;background:linear-gradient(180deg,rgb(var(--panel-rgb)/.98),rgb(var(--bg2-rgb)/.98));box-shadow:var(--shadow-soft)}
-.deliveryOverview:before{content:"";position:absolute;inset:0 0 auto;height:2px;background:linear-gradient(90deg,var(--signal),rgb(var(--signal-hi-rgb)/.58) 42%,transparent 82%)}
-.deliveryOverviewHead{min-height:68px;display:flex;align-items:center;justify-content:space-between;gap:20px;padding:14px 0 12px;border-bottom:1px solid var(--line)}
-.deliveryEyebrow{display:flex;align-items:center;gap:6px;color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono);text-transform:uppercase;letter-spacing:.045em}
-.deliveryOverview h2{display:flex;align-items:baseline;gap:8px;max-width:760px;margin:4px 0 0;color:var(--fg);font-size:var(--fs-20);font-weight:var(--fw-bold);line-height:1.24;letter-spacing:-.018em}
-.deliveryOverview h2 .good{color:var(--good)}
-.deliveryComparisonDivider{color:var(--line3);font-size:var(--fs-16)}
-.deliveryCoverageState{display:inline-flex;flex:none;align-items:center;gap:6px;border:1px solid rgb(var(--green-rgb)/.24);border-radius:var(--radius-pill);background:rgb(var(--green-rgb)/.055);padding:4px 8px;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-bold);white-space:nowrap}
-.deliveryCoverageState:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:var(--good)}
-.deliveryCoverageState.partial{border-color:rgb(var(--orange-rgb)/.24);background:rgb(var(--orange-rgb)/.055)}
-.deliveryCoverageState.partial:before{background:var(--warn)}
-.deliveryMetricGrid{display:grid;grid-template-columns:minmax(0,1.04fr) minmax(0,.94fr) minmax(0,.94fr) minmax(196px,.92fr)}
-.deliveryMetric{min-width:0;padding:14px 20px 12px 0}
-.deliveryMetric+.deliveryMetric{border-left:1px solid var(--line);padding-right:0;padding-left:20px}
-.deliveryMetricLabel{width:max-content;max-width:100%;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase;letter-spacing:.045em}
-.deliveryMetricValue{margin-top:4px;overflow:hidden;color:var(--signal-hi);font:var(--fw-heavy) var(--fs-28)/1 var(--font-mono);letter-spacing:-.035em;text-overflow:ellipsis;white-space:nowrap}
-.deliveryMetric .trendDelta>span{max-width:11ch}
-@media(max-width:1360px){.deliveryMetric .deliveryMetricValue{font-size:var(--fs-24)}}
-.deliveryMetricMeta{min-height:15px;margin-top:6px;color:var(--faint);font-size:var(--fs-11);white-space:nowrap}
-.deliveryMetricMeta b{color:var(--dim);font-weight:var(--fw-bold)}
-.deliveryMetricTop{display:flex;align-items:baseline;justify-content:space-between;gap:12px}
-.deliveryMetricTop strong{color:var(--fg);font:var(--fw-heavy) var(--fs-22)/1 var(--font-mono)}
-.deliveryCoverageBar{height:7px;margin-top:12px;overflow:hidden;border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.045)}
-.deliveryCoverageBar i{display:block;width:calc(var(--delivery-coverage,0)*1%);height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--signal-mid),var(--good));transition:width .28s ease}
-.deliveryCoverageBar.partial i{background:linear-gradient(90deg,var(--signal-mid),var(--warn))}
-.deliveryEvidenceStrip{display:flex;min-height:35px;align-items:center;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11)}
-.deliveryEvidenceItem{display:flex;align-items:baseline;gap:6px;padding:0 18px;border-left:1px solid var(--line)}
-.deliveryEvidenceItem:first-child{padding-left:0;border-left:0}
-.deliveryEvidenceItem strong{color:var(--dim);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.deliveryVisual{margin-top:12px;padding:16px 20px 14px;overflow:hidden;box-shadow:var(--shadow-soft)}
-.deliveryVisualHead,.deliveryProjectHead{display:flex;align-items:center;justify-content:space-between;gap:18px}
-.deliveryVisualHead h2,.deliveryProjectHead h2{margin:0;font-size:var(--fs-14)}
-.deliveryLegend{display:flex;align-items:center;justify-content:flex-end;gap:14px;color:var(--dim);font-size:var(--fs-11)}
-.deliveryLegend span{display:inline-flex;align-items:center;gap:6px;white-space:nowrap}
-.deliveryLegend span[hidden]{display:none}
-.deliveryLegend i{width:12px;height:5px;border-radius:var(--radius-2xs);background:var(--signal)}
-.deliveryLegend .deleted{background:var(--c-deleted)}
-.deliveryLegend .intensity{height:2px;border-radius:0;background:var(--good)}
-.deliveryLegend .typical{height:0;border-top:1px dashed var(--dim);border-radius:0;background:none}
-.deliveryLegend .quiet{width:5px;height:12px;border-radius:var(--radius-2xs);background:var(--warn)}
-.deliveryChartWrap{position:relative;height:270px;margin-top:8px}
-.deliveryChart{display:block;width:100%;height:270px}
-.deliveryChart .grid{stroke:var(--line);stroke-width:1}
-.deliveryChart .separator{stroke:var(--line2);stroke-width:1}
-.deliveryChart .axis{fill:var(--faint);font:var(--fs-11) var(--font-mono)}
-.deliveryChart .added{fill:var(--signal)}
-.deliveryChart .deleted{fill:var(--c-deleted)}
-.deliveryChart .typical{stroke:var(--dim);stroke-width:1;stroke-dasharray:4 4;opacity:.62}
-.deliveryChart .quiet{fill:var(--warn);opacity:.85}
-.deliveryHitGrid{position:absolute;display:grid;grid-template-columns:repeat(var(--delivery-days),1fr)}
-.deliveryHitGrid button{min-width:0;border:0;background:transparent;cursor:crosshair}
-.deliveryHitGrid button:focus-visible{outline:1px solid rgb(var(--signal-hi-rgb)/.52);outline-offset:-2px;border-radius:var(--radius-xs)}
-.deliveryChartTip{z-index:5;min-width:190px;padding:8px 10px;font-size:var(--fs-11);line-height:1.35;transform:translateX(-50%)}
-.deliveryChartTip[hidden]{display:none}
-.deliveryChartTip strong{display:block;margin-bottom:4px;color:var(--fg);font-weight:var(--fw-bold)}
-.deliveryTipRow{display:flex;justify-content:space-between;gap:18px;margin-top:3px}
-.deliveryTipRow b{color:var(--fg);font-family:var(--font-mono);font-weight:var(--fw-bold)}
-.deliveryProjects{margin-top:12px;overflow:hidden;box-shadow:var(--shadow-soft)}
-.deliveryProjectHead{padding:14px 18px 10px}
-.deliveryMobileSort{display:none}
-.deliveryTableWrap{overflow:auto}
-.deliveryTableWrap .tbl{min-width:720px}
-.deliveryTableWrap .tbl th,.deliveryTableWrap .tbl td{padding:10px 16px}
-.deliverySort{display:inline-flex;align-items:center;justify-content:flex-end;gap:4px;width:100%;padding:0;border:0;background:none;color:inherit;font:inherit;font-weight:inherit;text-transform:inherit;letter-spacing:inherit;cursor:pointer}
-.deliveryTableWrap .tbl th:first-child .deliverySort{justify-content:flex-start}
-.deliverySort:hover,.deliverySort:focus-visible{color:var(--fg)}
-.deliverySort:focus-visible{outline:1px solid var(--signal);outline-offset:3px;border-radius:var(--radius-2xs)}
-.deliverySortMark{width:9px;color:var(--signal-hi);font-size:var(--fs-11);text-align:center}
-.deliveryEmpty{min-height:130px;padding:20px}
-.deliveryClearStatus{color:var(--faint);font-size:var(--fs-11)}
-.deliveryVisualHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.4}
-@media(max-width:1180px){.deliveryOverview{padding-inline:18px}.deliveryMetric{padding-right:16px}.deliveryMetric+.deliveryMetric{padding-left:16px}.deliveryMetricValue{font-size:var(--fs-24)}}
-@media(max-width:900px){.deliveryMetricGrid{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryMetric:nth-child(odd){border-left:0;padding-left:0}.deliveryMetric:nth-child(n+3){border-top:1px solid var(--line)}.deliveryVisualHead{display:grid}.deliveryLegend{justify-content:flex-start}.deliveryChartWrap,.deliveryChart{height:260px}}
-@media(max-width:700px){.deliveryMobileSort{display:grid;grid-template-columns:auto minmax(132px,180px);align-items:center;gap:8px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.deliveryMobileSort select{height:32px}.deliveryTableWrap{overflow:visible;padding:0 12px 12px}.deliveryTableWrap .tbl{display:block;min-width:0}.deliveryTableWrap thead{display:none}.deliveryTableWrap tbody{display:grid;gap:8px}.deliveryTableWrap tr{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.018);box-shadow:var(--shadow-soft)}.deliveryTableWrap .tbl td{display:grid;gap:3px;min-width:0;padding:6px 0;border:0;text-align:left;overflow-wrap:anywhere}.deliveryTableWrap .tbl td:before{content:attr(data-label);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}.deliveryTableWrap .tbl td:first-child{grid-column:1/-1;margin-bottom:3px;padding-bottom:8px;border-bottom:1px solid var(--line);color:var(--fg);font-weight:var(--fw-bold)}.deliveryTableWrap .tbl td:first-child:before{display:none}.deliveryTableWrap .tbl td[colspan]{display:block;grid-column:1/-1;margin:0;padding:0;border:0}.deliveryTableWrap .tbl td[colspan]:before{display:none}.deliveryTableWrap .deliveryEmpty{min-height:96px}}
-@media(max-width:520px){#view-git .spectrumPageActions .modelControls{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryOverview{padding-inline:14px}.deliveryOverviewHead{align-items:flex-start;flex-direction:column;gap:8px}.deliveryMetricGrid{grid-template-columns:1fr}.deliveryMetric+.deliveryMetric,.deliveryCoverageMetric{border-top:1px solid var(--line);border-left:0;padding-left:0}.deliveryEvidenceStrip{align-items:flex-start;flex-direction:column;padding-block:8px}.deliveryEvidenceItem,.deliveryEvidenceItem:first-child{padding:4px 0;border:0}.deliveryVisual{padding-inline:14px}.deliveryProjectHead{padding-inline:14px}}
-/* git-delivery-economics-v1 */
-.deliveryInsightSection{margin-top:24px}
-.deliveryInsightHead{display:flex;align-items:flex-end;justify-content:space-between;gap:18px;margin-bottom:10px;padding-top:20px;border-top:1px solid var(--line)}
-.deliveryInsightHead h2{margin:0;font-size:var(--fs-18)}
-.deliveryInsightHead p{max-width:760px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.5}
-.deliveryInsightGrid{display:grid;grid-template-columns:minmax(300px,.78fr) minmax(0,1.22fr);align-items:start;gap:12px}
-.deliverySignalCard,.deliveryShapeCard{padding:16px 18px}
-.deliveryInsightCardHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
-.deliveryInsightCardHead h3{margin:0;font-size:var(--fs-14)}
-.deliveryInsightCardHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.45}
-.deliverySignalCard{display:flex;height:360px;min-height:0;flex-direction:column}
-.deliverySignalList{display:grid;flex:1;min-height:0;margin-top:12px;padding-right:6px;overflow-y:auto;overscroll-behavior:contain;scrollbar-gutter:stable;scrollbar-width:thin;border-top:1px solid var(--line)}
-.deliverySignal{display:grid;grid-template-columns:8px minmax(0,1fr);gap:8px;align-items:start;border-bottom:1px solid var(--line);padding:10px 0}
-.deliverySignal:last-child{border-bottom:0}
-.deliverySignal i{width:7px;height:7px;border-radius:var(--radius-round);margin-top:4px;background:var(--accent)}
-.deliverySignal.warn i{background:var(--warn)}
-.deliverySignal.good i{background:var(--good)}
-.deliverySignalBody b{display:block;color:var(--fg);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.deliverySignalBody span{display:block;margin-top:2px;color:var(--dim);font-size:var(--fs-11);line-height:1.45}
-.deliverySignalEmpty{min-height:150px;padding:16px}
-.deliveryShape{margin-top:10px}
-.deliveryShapeHeader,.deliveryShapeRow{display:grid;grid-template-columns:130px minmax(150px,1fr) minmax(230px,.86fr);align-items:center;gap:12px}
-.deliveryShapeHeader{padding:0 0 6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.deliveryShapeHeader span:last-child{display:grid;grid-template-columns:minmax(0,.78fr) minmax(0,1.44fr) minmax(0,.78fr);gap:8px;text-align:right}
-.deliveryShapeRow{min-height:62px;border-top:1px solid var(--line)}
-.deliveryShapeIdentity b{display:block;font-size:var(--fs-12)}
-.deliveryShapeIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.deliveryShapeRail{position:relative;height:22px}
-.deliveryShapeRail:before{content:"";position:absolute;top:10px;right:0;left:0;height:2px;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.09)}
-.deliveryShapeIqr{position:absolute;top:7px;left:var(--p25);width:calc(var(--p75) - var(--p25));height:8px;border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.3)}
-.deliveryShapeMedian,.deliveryShapeHigh{position:absolute;top:4px;left:var(--median);width:2px;height:14px;border-radius:var(--radius-2xs);background:var(--accent);transform:translateX(-50%)}
-.deliveryShapeHigh{top:7px;left:var(--p90);width:7px;height:7px;border:1px solid var(--panel);background:var(--signal-hi);transform:translateX(-50%) rotate(45deg)}
-.deliveryShapeHigh.beyond{border-color:var(--signal-hi);background:transparent;transform:translateX(-90%) rotate(45deg)}
-.deliveryShapeValues{display:grid;grid-template-columns:minmax(0,.78fr) minmax(0,1.44fr) minmax(0,.78fr);gap:8px;text-align:right}
-.deliveryShapeValues span{min-width:0;overflow:hidden;color:var(--dim);font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono);text-overflow:ellipsis;white-space:nowrap}
-.deliveryShapeEmpty{min-height:212px}
-.deliveryChartViewport{min-width:0}
-.deliveryMobileScrollHint{display:none}
-.deliveryModels{margin-top:12px;overflow:hidden;box-shadow:var(--shadow-soft)}
-.deliveryModelNote{color:var(--faint);font-size:var(--fs-11);text-align:right}
-.deliveryModels .modelName{max-width:280px}
-.deliverySpendShare,.deliveryComposition{display:block;height:4px;margin-top:4px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.06)}
-.deliverySpendShare i{display:block;width:calc(var(--share,0)*1%);height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--signal-mid),var(--signal-hi))}
-.deliveryComposition{display:flex}
-.deliveryComposition i{height:100%;background:var(--signal)}
-.deliveryComposition i.deleted{background:var(--c-deleted)}
-@media(max-width:1180px){.deliveryShapeHeader,.deliveryShapeRow{grid-template-columns:112px minmax(96px,1fr) minmax(240px,.88fr)}}
-@media(max-width:900px){.deliveryInsightGrid{grid-template-columns:1fr}.deliveryInsightHead{align-items:flex-start;flex-direction:column}.deliveryShapeHeader,.deliveryShapeRow{grid-template-columns:minmax(0,1fr) minmax(150px,1fr)}.deliveryShapeHeader span:last-child,.deliveryShapeValues{grid-column:1/-1;grid-row:2}.deliveryShapeRow{padding-bottom:8px}}
-@media(max-width:520px){.deliverySignalCard,.deliveryShapeCard{padding:14px 12px}.deliveryShapeHeader{display:none}.deliveryShapeRow{grid-template-columns:1fr}.deliveryShapeValues{grid-row:auto}.deliveryShapeValues span{display:grid;gap:2px;text-align:left}.deliveryShapeValues span:before{content:attr(data-label);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-sans);text-transform:uppercase}.deliveryMobileScrollHint{display:block;margin:6px 0 2px;color:var(--faint);font-size:var(--fs-11);text-align:right}.deliveryChartViewport{overflow-x:auto;overscroll-behavior-x:contain;scrollbar-width:thin}.deliveryChartWrap{min-width:720px}.deliveryChart .axis{font-size:var(--fs-11)}}
-/* git-evidence-explorer-v2 */
-.deliveryCoverageState{font-family:inherit;cursor:pointer}
-.deliveryCoverageState:after{content:"›";color:var(--faint);font-size:var(--fs-13);line-height:8px;transform:rotate(90deg);transition:transform .15s ease}
-.deliveryCoverageState[aria-expanded=true]:after{transform:rotate(-90deg)}
-.deliveryCoverageState:hover,.deliveryCoverageState:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.5);color:var(--fg);outline:none}
-.deliveryEvidencePanel{margin-top:8px;padding:16px 18px;background:linear-gradient(135deg,rgb(var(--signal-rgb)/.045),rgb(var(--orange-rgb)/.025));box-shadow:var(--shadow-soft)}
-.deliveryEvidencePanel[hidden]{display:none}
-.deliveryEvidenceHead{display:flex;align-items:flex-start;justify-content:space-between;gap:18px}
-.deliveryEvidenceHead h2{margin:0;font-size:var(--fs-14)}
-.deliveryEvidenceHead p{max-width:720px;margin:4px 0 0;color:var(--dim);font-size:var(--fs-11);line-height:1.45}
-.deliveryEvidenceClose{flex:none;width:28px;height:28px;border:1px solid var(--line);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-18);cursor:pointer}
-.deliveryEvidenceClose:hover,.deliveryEvidenceClose:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
-.deliveryEvidenceSummary{display:flex;align-items:baseline;gap:8px;margin-top:14px}
-.deliveryEvidenceSummary strong{color:var(--fg);font:var(--fw-heavy) var(--fs-22)/1 var(--font-mono)}
-.deliveryEvidenceSummary span{color:var(--dim);font-size:var(--fs-11)}
-.deliveryEvidenceChoices{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:12px}
-.deliveryEvidenceChoice{display:grid;grid-template-columns:1fr auto;align-items:center;gap:10px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.018);color:var(--dim);text-align:left;cursor:pointer}
-.deliveryEvidenceChoice:hover,.deliveryEvidenceChoice:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.4);background:rgb(var(--signal-rgb)/.04);outline:none}
-.deliveryEvidenceChoice span{font-size:var(--fs-11);font-weight:var(--fw-bold)}
-.deliveryEvidenceChoice strong{color:var(--fg);font:var(--fw-bold) var(--fs-14)/1 var(--font-mono)}
-.deliveryEvidenceMeta{display:flex;justify-content:space-between;gap:18px;margin-top:10px;padding-top:10px;border-top:1px solid var(--line);color:var(--faint);font-size:var(--fs-11);line-height:1.45}
-.deliveryDayInspector{display:grid;grid-template-columns:minmax(150px,.72fr) minmax(0,1.6fr) auto;align-items:center;gap:18px;margin-top:8px;padding:10px 12px;border:1px solid rgb(var(--signal-rgb)/.24);border-radius:var(--radius-md);background:rgb(var(--signal-rgb)/.035)}
-.deliveryDayInspector[hidden]{display:none}
-.deliveryDayIdentity span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.deliveryDayIdentity strong{display:block;margin-top:3px;color:var(--fg);font-size:var(--fs-12)}
-.deliveryDayIdentity small{display:block;margin-top:2px;color:var(--warn);font-size:var(--fs-11)}
-.deliveryDayMetrics{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:8px}
-.deliveryDayMetric span{font-size:var(--fs-11)}
-.deliveryDayMetric b{margin-top:3px;font-size:var(--fs-11);line-height:1.2}
-.deliveryDayActions{display:flex;align-items:center;gap:4px}
-.deliveryDayActions button{height:28px;padding:0 8px;border:1px solid var(--line);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-11);cursor:pointer}
-.deliveryDayActions button:hover:not(:disabled),.deliveryDayActions button:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
-.deliveryDayActions button:disabled{opacity:.36;cursor:default}
-.deliveryDayActions .deliveryDayClose{width:28px;padding:0;font-size:var(--fs-16)}
-.deliveryProjectControls{display:flex;align-items:center;gap:8px}
-.deliveryEvidenceFilter{display:flex;align-items:center;gap:6px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.deliveryEvidenceFilter select{height:32px;min-width:150px}
-.deliveryTableWrap .tbl{min-width:660px}
-.deliveryProjectLink{padding:0;border:0;background:none;color:var(--fg);font:inherit;font-weight:var(--fw-bold);text-align:left;cursor:pointer}
-.deliveryProjectLink:hover,.deliveryProjectLink:focus-visible{color:var(--accent);outline:none;text-decoration:underline;text-underline-offset:3px}
-.deliverySignal{width:100%;background:none;color:inherit;font:inherit;text-align:left}
-.deliverySignal[data-delivery-signal-action]{grid-template-columns:8px minmax(0,1fr) auto;border:0;border-bottom:1px solid var(--line);cursor:pointer}
-.deliverySignal[data-delivery-signal-action]:after{content:"›";align-self:center;color:var(--faint);font-size:var(--fs-16)}
-.deliverySignal[data-delivery-signal-action]:hover .deliverySignalBody b,.deliverySignal[data-delivery-signal-action]:focus-visible .deliverySignalBody b{color:var(--accent)}
-.deliverySignal[data-delivery-signal-action]:focus-visible{outline:1px solid rgb(var(--signal-hi-rgb)/.4);outline-offset:3px;border-radius:var(--radius-xs)}
-.deliveryEvidenceFilter select,.deliveryMobileSort select{padding-top:4px;padding-bottom:4px}
-@media(max-width:900px){.deliveryEvidenceChoices{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryDayInspector{grid-template-columns:minmax(140px,.7fr) minmax(0,1.3fr)}.deliveryDayActions{grid-column:1/-1;justify-content:flex-end}}
-@media(max-width:700px){.deliveryProjectHead{align-items:flex-start;flex-direction:column}.deliveryProjectControls{width:100%;align-items:flex-end}.deliveryEvidenceFilter{display:grid;grid-template-columns:auto minmax(132px,180px)}}
-@media(max-width:520px){.deliveryEvidencePanel{padding:14px 12px}.deliveryEvidenceChoices{grid-template-columns:1fr}.deliveryChartTip{display:none!important}.deliveryEvidenceMeta{flex-direction:column;gap:4px}.deliveryDayInspector{grid-template-columns:1fr;gap:10px}.deliveryDayMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}.deliveryDayActions{grid-column:auto;justify-content:flex-start}.deliveryProjectControls{align-items:stretch;flex-direction:column}.deliveryEvidenceFilter,.deliveryMobileSort{grid-template-columns:42px minmax(0,1fr)}}
-/* sessions-agent-observability-v1 */
-.agentActivity{margin-top:14px;padding:16px 18px;overflow:hidden}
-.agentActivity[hidden]{display:none}
-.agentActivity:before{content:"";position:absolute;inset:0 0 auto;height:2px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent 72%)}
-.agentActivityHead{display:flex;align-items:flex-start;justify-content:space-between;gap:16px}
-.agentActivityHead h2{margin:1px 0 0;font-size:var(--fs-16)}
-.agentActivityHead p{margin:3px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
-.agentCoverage{max-width:380px;color:var(--faint);font-size:var(--fs-11);text-align:right}
-.agentActivityMetrics{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:12px}
-.agentActivityMetric{padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.025)}
-.agentActivityMetric span{font-size:var(--fs-11)}
-.agentActivityMetric strong{margin-top:3px;font-size:var(--fs-16);line-height:1.2}
-.agentActivityMetric small{margin-top:2px;font-size:var(--fs-11)}
-.agentActivityTree{margin-top:12px;overflow-x:auto;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.24);scrollbar-width:thin}
-.agentTreeHeader,.agentRow{display:grid;grid-template-columns:minmax(220px,1.5fr) minmax(105px,.8fr) 82px repeat(4,minmax(70px,.5fr));align-items:center;gap:8px;min-width:820px}
-.agentTreeHeader{padding:6px 10px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.agentTreeHeader span:not(:first-child){text-align:right}
-.agentTreeHeader .fieldtip{justify-content:flex-end}
-.agentRow{width:100%;min-height:58px;padding:8px 10px;border:0;border-top:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;text-align:left;cursor:pointer}
-.agentRow:hover,.agentRow:focus-visible{background:rgb(var(--signal-rgb)/.045);outline:none}
-.agentRow.selected{background:rgb(var(--signal-rgb)/.07);box-shadow:inset 2px 0 var(--accent)}
-.agentRow.attention{box-shadow:inset 2px 0 var(--warn)}
-.agentRow.selected.attention{box-shadow:inset 2px 0 var(--warn),inset 5px 0 rgb(var(--signal-rgb)/.38)}
-.agentIdentity{min-width:0;padding-left:calc(var(--agent-depth)*18px)}
-.agentIdentity strong{display:flex;align-items:center;gap:6px;min-width:0;color:var(--fg);font-size:var(--fs-12)}
-.agentIdentity strong span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.agentIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.agentMetric{text-align:right;font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono)}
-.agentState{display:inline-flex;align-items:center;gap:4px;justify-content:flex-end;color:var(--dim);font-size:var(--fs-11);text-transform:capitalize}
-.agentState:before{content:"";width:6px;height:6px;border-radius:var(--radius-round);background:var(--faint)}
-.agentState.working:before{background:var(--good);box-shadow:0 0 0 3px rgb(var(--green-rgb)/.1)}
-.agentState.waiting:before{background:var(--warn)}
-.agentAttentionBadge{flex:none;padding:2px 6px;font-weight:var(--fw-heavy);text-transform:uppercase}
-.agentAttentionDetail{margin-top:8px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.018);color:var(--dim);font-size:var(--fs-11);line-height:1.45}
-.agentAttentionDetail b{color:var(--fg)}
-.agentAttentionDetail ul{margin:4px 0 0;padding-left:16px}
-.subagentUsageStat{padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.022);min-width:0}
-.subagentUsageStat span{font-size:var(--fs-11)}
-.subagentUsageStat strong{margin-top:3px;font-size:var(--fs-16);line-height:1.2;overflow:hidden;text-overflow:ellipsis}
-.subagentUsageStat small{margin-top:2px;font-size:var(--fs-11);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentUsageRow{display:grid;grid-template-columns:minmax(170px,1.15fr) minmax(120px,.8fr) repeat(4,minmax(72px,.45fr));align-items:center;gap:10px;min-height:58px;border-bottom:1px solid var(--line);padding:8px 0}
-.subagentUsageIdentity strong{display:block;color:var(--fg);font-size:var(--fs-12)}
-.subagentUsageIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.subagentUsageBar{height:5px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.055)}
-.subagentUsageBar i{display:block;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi))}
-.subagentUsageValue{text-align:right}
-.subagentUsageValue span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
-.subagentUsageValue b{display:block;margin-top:2px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
-.subagentUsageEmpty{padding:24px}
-.subagentExplorerMeta{color:var(--faint);font-size:var(--fs-11);white-space:nowrap}
-.subagentExplorerStat{min-width:0;padding:12px 14px;border-left:1px solid var(--line)}
-.subagentExplorerStat:first-child{border-left:0}
-.subagentExplorerStat span{font-size:var(--fs-11)}
-.subagentExplorerStat strong{margin-top:3px;font-size:var(--fs-20);line-height:1.2}
-.subagentExplorerStat small{margin-top:3px;font-size:var(--fs-11);line-height:1.35}
-.subagentInsight{padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02)}
-.subagentInsight strong{display:flex;align-items:center;justify-content:space-between;gap:10px;color:var(--fg);font-size:var(--fs-12)}
-.subagentInsight strong b{color:var(--warn);font:var(--fw-heavy) var(--fs-14)/1 var(--font-mono)}
-.subagentInsight p{margin:4px 0 0;color:var(--faint);font-size:var(--fs-11);line-height:1.4}
-.subagentInventoryHeader,.subagentInventoryRow{display:grid;grid-template-columns:minmax(230px,1.35fr) minmax(170px,1fr) minmax(125px,.75fr) 95px 105px 105px 90px;gap:10px;align-items:center;min-width:960px}
-.subagentInventoryHeader{padding:8px 14px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.subagentInventoryHeader span:not(:first-child){text-align:right}
-.subagentInventoryRow{width:100%;min-height:64px;padding:8px 14px;border:0;border-top:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;text-align:left;cursor:pointer}
-.subagentInventoryRow:hover,.subagentInventoryRow:focus-visible{background:rgb(var(--signal-rgb)/.045);outline:none}
-.subagentInventoryIdentity{min-width:0}
-.subagentInventoryIdentity strong{display:flex;align-items:center;gap:6px;min-width:0;color:var(--fg);font-size:var(--fs-12)}
-.subagentInventoryIdentity strong>span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentInventoryIdentity small{display:block;margin-top:2px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentInventoryProject{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentInventoryMetric{text-align:right;font:var(--fw-semibold) var(--fs-11)/1.3 var(--font-mono)}
-.subagentInventoryEmpty{padding:32px 16px}
-.subagentInventoryWarning{margin-top:10px;border:1px solid rgb(var(--orange-rgb)/.3);border-radius:var(--radius-md);background:rgb(var(--orange-rgb)/.065);padding:10px 12px;color:var(--warn);font-size:var(--fs-11)}
-.subagentInventoryWarning[hidden]{display:none}
-.subagentCoverageNote{margin-top:10px;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--tint-rgb)/.02);padding:8px 12px;color:var(--dim);font-size:var(--fs-11);line-height:1.45}
-.subagentCoverageNote b{color:var(--fg)}
-.subagentCoverageNote[hidden]{display:none}
-@media(max-width:1100px){.agentActivityMetrics{grid-template-columns:repeat(2,minmax(0,1fr))}.agentActivityHead{align-items:flex-start;flex-direction:column}.agentCoverage{text-align:left}.subagentUsageRow{grid-template-columns:minmax(150px,1fr) minmax(105px,.7fr) repeat(4,minmax(68px,.4fr))}}
-@media(max-width:1100px){.subagentExplorerStat:nth-child(3){border-left:0;border-top:1px solid var(--line)}.subagentExplorerStat:nth-child(4){border-top:1px solid var(--line)}}
-/* subagent-investigation-v2 */
-.subagentFilterPrimary{display:grid;grid-template-columns:minmax(240px,1.4fr) repeat(3,minmax(130px,.72fr)) auto;gap:8px;align-items:end}
-.subagentFilterPrimary .filterControl,.subagentFilterAdvanced .filterControl{min-width:0}
-.subagentFilterPrimary input,.subagentFilterPrimary select,.subagentFilterAdvanced select{width:100%}
-.subagentFilterMore{height:38px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.035);padding:0 12px;color:var(--dim);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);white-space:nowrap;cursor:pointer}
-.subagentFilterMore:hover,.subagentFilterMore:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.48);color:var(--fg);outline:none}
-.subagentFilterMore[aria-expanded=true]{border-color:rgb(var(--signal-rgb)/.38);background:rgb(var(--signal-rgb)/.07);color:var(--fg)}
-.subagentFilterMore span:not(:empty){display:inline-grid;min-width:18px;height:18px;margin-left:4px;place-items:center;border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.16);color:var(--signal-hi);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.subagentFilterAdvanced{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;margin-top:10px;padding-top:10px;border-top:1px solid var(--line)}
-.subagentFilterAdvanced[hidden]{display:none}
-.subagentFilterFooter{display:flex;align-items:center;gap:12px;min-height:34px;margin-top:10px;padding-top:10px;border-top:1px solid var(--line)}
-.subagentActiveFilters{display:flex;flex:1;align-items:center;gap:6px;min-width:0;flex-wrap:wrap}
-.subagentActiveFilters>span{color:var(--faint);font-size:var(--fs-11)}
-.subagentFilterChip{display:inline-flex;align-items:center;gap:6px;max-width:230px;border:1px solid rgb(var(--signal-rgb)/.28);border-radius:var(--radius-pill);background:rgb(var(--signal-rgb)/.065);padding:4px 8px;color:var(--dim);font:inherit;font-size:var(--fs-11);cursor:pointer}
-.subagentFilterChip:hover,.subagentFilterChip:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.58);color:var(--fg);outline:none}
-.subagentFilterChip b{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:var(--fw-bold)}
-.subagentFilterChip i{color:var(--signal-hi);font-style:normal}
-.subagentFilterFooter>.clearFilters{flex:none}
-.subagentInsight{width:100%;color:inherit;font:inherit;text-align:left;cursor:pointer}
-.subagentInsight:hover,.subagentInsight:focus-visible{border-color:rgb(var(--orange-rgb)/.36);background:rgb(var(--orange-rgb)/.04);outline:none}
-.subagentInsight[aria-pressed=true]{border-color:rgb(var(--orange-rgb)/.52);background:rgb(var(--orange-rgb)/.08);box-shadow:inset 2px 0 var(--warn)}
-.subagentInsight p{min-height:27px}
-.subagentInventoryRow.selected{background:rgb(var(--signal-rgb)/.07);box-shadow:inset 2px 0 var(--accent)}
-.subagentInventoryRow.attention.selected{box-shadow:inset 2px 0 var(--warn),inset 5px 0 rgb(var(--signal-rgb)/.38)}
-.subagentEvidence{padding:14px 16px 16px;border-top:1px solid rgb(var(--signal-rgb)/.26);border-bottom:1px solid rgb(var(--signal-rgb)/.18);background:linear-gradient(135deg,rgb(var(--signal-rgb)/.07),rgb(var(--bg2-rgb)/.84) 54%,rgb(var(--aura-rgb)/.04));box-shadow:inset 3px 0 var(--accent)}
-.subagentEvidenceHead{display:flex;align-items:flex-start;justify-content:space-between;gap:14px}
-.subagentEvidenceHead h4{margin:0;color:var(--fg);font-size:var(--fs-14)}
-.subagentEvidenceHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11)}
-.subagentEvidenceClose{flex:none;width:28px;height:28px;border:1px solid var(--line2);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-16);cursor:pointer}
-.subagentEvidenceClose:hover,.subagentEvidenceClose:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
-.subagentEvidenceContext{display:flex;gap:6px;margin-top:10px;flex-wrap:wrap}
-.subagentEvidenceContext span{border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.025);padding:4px 8px;color:var(--dim);font-size:var(--fs-11)}
-.subagentEvidenceGrid{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:6px;margin-top:10px}
-.subagentEvidenceMetric{min-width:0;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.024);padding:8px 10px}
-.subagentEvidenceMetric span{font-size:var(--fs-11)}
-.subagentEvidenceMetric strong{margin-top:3px;overflow:hidden;font-size:var(--fs-12);line-height:1.2;text-overflow:ellipsis;white-space:nowrap}
-.subagentEvidenceSignals{margin-top:10px;padding:10px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.3);color:var(--dim);font-size:var(--fs-11);line-height:1.45}
-.subagentEvidenceSignals strong{color:var(--fg)}
-.subagentEvidenceSignals ul{margin:4px 0 0;padding-left:16px}
-.subagentEvidenceActions{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-top:10px}
-.subagentEvidenceActions p{margin:0;color:var(--faint);font-size:var(--fs-11)}
-.subagentOpenParent{flex:none;border:1px solid rgb(var(--signal-rgb)/.44);border-radius:var(--radius-sm);background:rgb(var(--signal-rgb)/.09);padding:6px 10px;color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer}
-.subagentOpenParent:hover,.subagentOpenParent:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.7);background:rgb(var(--signal-rgb)/.15);color:var(--fg);outline:none}
-@media(max-width:1100px){.subagentFilterPrimary{grid-template-columns:minmax(220px,1.2fr) repeat(2,minmax(125px,.7fr));}.subagentFilterPrimary .filterControl:nth-child(4){grid-column:1/2}.subagentFilterMore{grid-column:3/4}.subagentEvidenceGrid{grid-template-columns:repeat(3,minmax(0,1fr))}}
-@media(max-width:760px){.subagentFilterPrimary,.subagentFilterAdvanced{grid-template-columns:1fr 1fr}.subagentFilterPrimary .filterControl:first-child{grid-column:1/-1}.subagentFilterPrimary .filterControl:nth-child(4),.subagentFilterMore{grid-column:auto}.subagentEvidenceGrid{grid-template-columns:repeat(2,minmax(0,1fr))}.subagentEvidenceActions{align-items:flex-start;flex-direction:column}}
-/* subagent-investigation-v3 */
-body.sessionRoute #view-session.sessionSubagents .currentDaySummary{display:none}
-.subagentCommand{overflow:hidden;padding:0;box-shadow:var(--shadow-soft)}
-.subagentViewTabs{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));border-bottom:1px solid var(--line);background:rgb(var(--bg-rgb)/.26)}
-.subagentViewTabs{grid-template-columns:repeat(2,minmax(0,1fr))}
-#view-subagents .subagentViewTabs{display:none}
-#view-session .subagentViewTabs [data-subagent-view=roles]{display:none}
-.subagentViewTabs button{display:flex;min-height:48px;align-items:center;justify-content:center;gap:8px;border:0;border-right:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;font-size:var(--fs-12);font-weight:var(--fw-heavy);cursor:pointer}
-.subagentViewTabs button:last-child{border-right:0}
-.subagentViewTabs button:hover,.subagentViewTabs button:focus-visible{background:rgb(var(--signal-rgb)/.045);color:var(--fg);outline:none}
-.subagentViewTabs button[aria-selected=true]{background:linear-gradient(180deg,rgb(var(--signal-rgb)/.12),rgb(var(--signal-rgb)/.035));box-shadow:inset 0 -2px var(--accent);color:var(--fg)}
-.subagentViewTabs small{display:inline-grid;min-width:24px;height:20px;place-items:center;border:1px solid var(--line2);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.035);color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.subagentViewTabs button[aria-selected=true] small{border-color:rgb(var(--signal-rgb)/.38);background:rgb(var(--signal-rgb)/.1);color:var(--signal-hi)}
-.subagentCommand .subagentFilterPrimary{padding:12px 12px 0}
-.subagentCommand .subagentFilterAdvanced{margin:10px 12px 0}
-.subagentCommand .subagentFilterFooter{margin:10px 12px 0;padding-bottom:10px}
-.subagentCommand .subagentFilterFooter[hidden]{display:none}
-.subagentCompactSummary{display:flex;align-items:center;gap:8px;margin-top:10px;overflow-x:auto;scrollbar-width:thin}
-.subagentCompactMetric{display:flex;min-width:max-content;align-items:baseline;gap:6px;border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.022);padding:6px 10px;color:var(--faint);font:inherit;font-size:var(--fs-11)}
-.subagentCompactMetric b{color:var(--fg);font:var(--fw-heavy) var(--fs-12)/1 var(--font-mono)}
-.subagentCompactMetric.warn{border-color:rgb(var(--orange-rgb)/.3);background:rgb(var(--orange-rgb)/.055)}
-.subagentCompactMetric.warn b{color:var(--warn)}
-.subagentCompactMetric.dim b{color:var(--dim)}
-.subagentCompactMetric.actionable{cursor:pointer}
-.subagentCompactMetric.actionable:hover,.subagentCompactMetric.actionable:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.52);background:rgb(var(--signal-rgb)/.075);color:var(--fg);outline:none}
-.subagentCompactMetric.actionable[aria-pressed=true]{border-color:rgb(var(--signal-rgb)/.58);background:rgb(var(--signal-rgb)/.13);box-shadow:inset 0 0 0 1px rgb(var(--signal-rgb)/.12);color:var(--signal-hi)}
-.subagentCompactMetric.actionable[aria-pressed=true] b{color:var(--signal-hi)}
-.subagentWorkspace{display:grid;grid-template-columns:minmax(0,1fr) minmax(300px,340px);gap:12px;align-items:start;margin-top:12px}
-.subagentResultsCard{overflow:hidden;box-shadow:var(--shadow-soft)}
-.subagentResultsHead{display:flex;min-height:58px;align-items:center;justify-content:space-between;gap:14px;padding:12px 14px;border-bottom:1px solid var(--line)}
-.subagentResultsHead h3{margin:0;font-size:var(--fs-13)}
-.subagentResultsHead p{margin:2px 0 0;color:var(--faint);font-size:var(--fs-11)}
-.subagentResultsHead>span{flex:none;color:var(--faint);font-size:var(--fs-11)}
-.subagentResultsEmpty{min-height:220px;padding:28px}
-.subagentResultsEmpty strong{display:block;margin-bottom:4px;color:var(--fg);font-size:var(--fs-13)}
-.subagentWorkspace.roleView{grid-template-columns:1fr}
-.subagentWorkspace.roleView .subagentInspector{display:none}
-.subagentModelDistribution{margin-top:12px;padding:12px 14px}
-.subagentModelHead{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-bottom:10px}
-.subagentModelHead h3{margin:0;font-size:var(--fs-12)}
-.subagentModelHead small{color:var(--faint);font-size:var(--fs-11)}
-.subagentModelRows{display:grid;gap:6px}
-.subagentModelRow{display:grid;grid-template-columns:minmax(150px,1fr) minmax(90px,2fr) 52px 90px;align-items:center;gap:12px;color:var(--dim);font-size:var(--fs-11)}
-.subagentModelIdentity{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentModelIdentity strong{color:var(--fg)}
-.subagentModelTrack{height:7px;overflow:hidden;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.07)}
-.subagentModelTrack i{display:block;height:100%;border-radius:inherit;background:linear-gradient(90deg,var(--accent),var(--signal-hi))}
-.subagentModelNumber{text-align:right;font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.subagentModelCost{text-align:right;font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.subagentModelCost small{display:block;margin-top:4px;color:var(--faint);font:var(--fw-medium) var(--fs-11)/1.2 var(--font-sans)}
-.subagentSessionGroup{border-bottom:1px solid var(--line);background:rgb(var(--bg-rgb)/.12)}
-.subagentSessionGroup:last-child{border-bottom:0}
-.subagentSessionGroup>summary{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:center;gap:16px;min-height:70px;padding:10px 14px;list-style:none;cursor:pointer}
-.subagentSessionGroup>summary::-webkit-details-marker{display:none}
-.subagentSessionGroup>summary:hover,.subagentSessionGroup>summary:focus-visible{background:rgb(var(--signal-rgb)/.035);outline:none}
-.subagentSessionGroup[open]>summary{background:linear-gradient(90deg,rgb(var(--signal-rgb)/.065),transparent 72%);box-shadow:inset 2px 0 var(--accent)}
-.subagentSessionGroup.hasAttention>summary{box-shadow:inset 2px 0 var(--warn)}
-.subagentSessionIdentity{min-width:0}
-.subagentSessionIdentity strong{display:flex;align-items:center;gap:6px;color:var(--fg);font-size:var(--fs-12)}
-.subagentSessionIdentity strong span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentSessionIdentity small{display:block;margin-top:3px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentSessionBadge{padding:2px 6px;font-weight:var(--fw-heavy);text-transform:uppercase;white-space:nowrap}
-.subagentSessionMetrics{display:grid;grid-template-columns:repeat(3,minmax(58px,auto));gap:8px;text-align:right}
-.subagentSessionMetric span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
-.subagentSessionMetric b{display:block;margin-top:2px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
-.subagentSessionGroup>summary:after{content:"›";position:absolute;right:9px;color:var(--faint);transform:rotate(90deg)}
-.subagentSessionGroup[open]>summary:after{transform:rotate(-90deg)}
-.subagentChildHeader,.subagentChildRow{display:grid;grid-template-columns:minmax(150px,1.2fr) minmax(92px,.75fr) minmax(72px,.5fr) minmax(68px,.48fr);align-items:center;gap:8px}
-.subagentChildHeader{padding:6px 14px;border-top:1px solid var(--line);background:rgb(var(--shade-rgb)/.12);color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.subagentChildHeader span:not(:first-child){text-align:right}
-.subagentChildRow{width:100%;min-height:58px;padding:8px 14px;border:0;border-top:1px solid var(--line);background:transparent;color:var(--dim);font:inherit;text-align:left;cursor:pointer}
-.subagentChildRow:hover,.subagentChildRow:focus-visible{background:rgb(var(--signal-rgb)/.04);outline:none}
-.subagentChildRow.selected{background:rgb(var(--signal-rgb)/.08);box-shadow:inset 3px 0 var(--accent)}
-.subagentChildRow.attention{box-shadow:inset 2px 0 var(--warn)}
-.subagentChildRow.attention.selected{box-shadow:inset 2px 0 var(--warn),inset 5px 0 rgb(var(--signal-rgb)/.36)}
-.subagentChildIdentity{min-width:0}
-.subagentChildIdentity strong{display:flex;align-items:center;gap:6px;min-width:0;color:var(--fg);font-size:var(--fs-11)}
-.subagentChildIdentity strong>span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.subagentChildIdentity small{display:block;margin-top:2px;overflow:hidden;color:var(--faint);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentChildMetric{text-align:right;font:var(--fw-semibold) var(--fs-11)/1.25 var(--font-mono)}
-.subagentSiblingLink{width:100%;border:0;border-top:1px solid var(--line);background:rgb(var(--signal-rgb)/.025);padding:10px 14px;color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);text-align:left;cursor:pointer}
-.subagentSiblingLink:hover,.subagentSiblingLink:focus-visible{background:rgb(var(--signal-rgb)/.07);color:var(--fg);outline:none}
-.subagentInspector{position:sticky;top:76px;min-height:310px;overflow:hidden;padding:14px;box-shadow:var(--shadow-soft)}
-.subagentInspector:before{content:"";position:absolute;inset:0 0 auto;height:2px;background:linear-gradient(90deg,var(--accent),var(--signal-hi),transparent)}
-.subagentInspectorEmpty{min-height:278px}
-.subagentInspectorEmpty svg{width:34px;height:34px;margin:auto;fill:none;stroke:var(--faint);stroke-width:1.5}
-.subagentInspectorEmpty strong{display:block;margin-top:10px;color:var(--fg);font-size:var(--fs-12)}
-.subagentInspectorEmpty p{max-width:235px;margin:4px auto 0;color:var(--faint);font-size:var(--fs-11);line-height:1.45}
-.subagentInspectorHead{display:flex;align-items:flex-start;justify-content:space-between;gap:10px}
-.subagentInspectorHead h3{margin:0;color:var(--fg);font-size:var(--fs-14);overflow-wrap:anywhere}
-.subagentInspectorHead p{margin:3px 0 0;color:var(--faint);font-size:var(--fs-11)}
-.subagentInspectorClose{flex:none;width:28px;height:28px;border:1px solid var(--line);border-radius:var(--radius-sm);background:transparent;color:var(--dim);font-size:var(--fs-16);cursor:pointer}
-.subagentInspectorClose:hover,.subagentInspectorClose:focus-visible{border-color:var(--line3);color:var(--fg);outline:none}
-.subagentInspectorParent{margin-top:12px;padding:8px 10px;border:1px solid rgb(var(--signal-rgb)/.2);border-radius:var(--radius-sm);background:rgb(var(--signal-rgb)/.045)}
-.subagentInspectorParent span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.subagentInspectorParent strong{display:block;margin-top:3px;overflow:hidden;color:var(--fg);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentInspectorParent small{display:block;margin-top:2px;color:var(--dim);font-size:var(--fs-11)}
-.subagentInspectorTags{display:flex;gap:4px;margin-top:8px;flex-wrap:wrap}
-.subagentInspectorTags span{border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.025);padding:3px 6px;color:var(--dim);font-size:var(--fs-11)}
-.subagentInspectorGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;margin-top:10px}
-.subagentInspectorMetric{min-width:0;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.02);padding:8px 8px}
-.subagentInspectorMetric span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.subagentInspectorMetric b{display:block;margin-top:3px;overflow:hidden;color:var(--fg);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono);text-overflow:ellipsis;white-space:nowrap}
-.subagentInspectorSignals{margin-top:10px;padding:8px 10px;border:1px solid var(--line);border-radius:var(--radius-sm);background:rgb(var(--bg-rgb)/.28);color:var(--dim);font-size:var(--fs-11);line-height:1.45}
-.subagentInspectorSignals>strong{color:var(--fg)}
-.subagentInspectorSignals ul{margin:4px 0 0;padding-left:16px}
-.subagentInspectorSignals p{margin:4px 0 0}
-.subagentInspectorAction{width:100%;margin-top:10px}
-.subagentRoleTable{overflow-x:auto}
-.subagentRoleHeader,.subagentRoleRow{display:grid;grid-template-columns:minmax(170px,1.15fr) repeat(5,minmax(72px,.55fr));align-items:center;gap:10px;min-width:690px}
-.subagentRoleHeader{padding:8px 14px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.subagentRoleHeader span:not(:first-child){text-align:right}
-.subagentRoleRow{min-height:68px;padding:8px 14px;border-top:1px solid var(--line)}
-.subagentRoleIdentity{min-width:0}
-.subagentRoleIdentity strong{display:block;overflow:hidden;color:var(--fg);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentRoleIdentity small{display:block;margin-top:2px;color:var(--faint);font-size:var(--fs-11)}
-.subagentRoleMetric{text-align:right}
-.subagentRoleMetric span{display:block;color:var(--faint);font-size:var(--fs-11);text-transform:uppercase}
-.subagentRoleMetric b{display:block;margin-top:2px;color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
-.subagentRoleMetric.warn b{color:var(--warn)}
-.subagentSessionMetrics{grid-template-columns:repeat(4,minmax(58px,auto))}
-.subagentRoleHeader,.subagentRoleRow{grid-template-columns:minmax(170px,1.15fr) repeat(6,minmax(72px,.55fr));min-width:780px}
-.subagentRoleEconomics{padding:12px}
-.subagentRoleKpis{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}
-.subagentRoleKpi{min-width:0;padding:10px 12px;border:1px solid var(--line);border-radius:var(--radius-md);background:linear-gradient(145deg,rgb(var(--tint-rgb)/.03),rgb(var(--bg-rgb)/.18))}
-.subagentRoleKpi span{font-size:var(--fs-11)}
-.subagentRoleKpi strong{margin-top:4px;overflow:hidden;font-size:var(--fs-18);line-height:1.15;text-overflow:ellipsis;white-space:nowrap}
-.subagentRoleKpi small{margin-top:3px;overflow:hidden;font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentRoleKpi.good strong{color:var(--good)}
-.subagentRoleKpi.warn strong{color:var(--warn)}
-.subagentRoleTrendHead{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:14px 2px 6px}
-.subagentRoleTrendHead h4{margin:0;color:var(--fg);font-size:var(--fs-12)}
-.subagentRoleTrendHead p{margin:2px 0 0;color:var(--faint);font-size:var(--fs-11)}
-.subagentRoleChartModes{flex:none}
-.subagentRoleChartModes button{padding:4px 8px;font-size:var(--fs-11)}
-.subagentRoleTrendList{overflow:hidden;border:1px solid var(--line);border-radius:var(--radius-md);background:rgb(var(--bg-rgb)/.2)}
-.subagentRoleTrendRow{display:grid;grid-template-columns:minmax(175px,1.05fr) minmax(88px,.5fr) minmax(180px,1fr) minmax(150px,.8fr) auto;align-items:center;gap:14px;min-height:82px;padding:10px 12px;border-top:1px solid var(--line)}
-.subagentRoleTrendRow:first-child{border-top:0}
-.subagentRoleIdentity{min-width:0}
-.subagentRoleIdentity strong{display:block;overflow:hidden;color:var(--fg);font-size:var(--fs-11);text-overflow:ellipsis;white-space:nowrap}
-.subagentRoleIdentity small{display:block;margin-top:3px;color:var(--faint);font-size:var(--fs-11);line-height:1.35}
-.subagentRolePrimary span,.subagentRoleMeta span{display:block;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);text-transform:uppercase}
-.subagentRolePrimary b{display:block;margin-top:3px;color:var(--fg);font:var(--fw-bold) var(--fs-13)/1.2 var(--font-mono)}
-.subagentRolePrimary small{display:block;margin-top:3px;color:var(--dim);font-size:var(--fs-11)}
-.subagentRolePrimary.good small{color:var(--good)}
-.subagentRolePrimary.warn small{color:var(--warn)}
-.subagentRoleSpark{min-width:0;height:48px}
-.subagentRoleSpark svg{display:block;width:100%;height:48px;overflow:visible}
-.subagentRoleSparkEmpty{display:flex;height:48px;align-items:center;color:var(--faint);font-size:var(--fs-11)}
-.subagentRoleMeta{display:flex;align-items:center;gap:6px;flex-wrap:wrap}
-.subagentRoleMeta>span:first-child{margin-right:3px}
-.subagentRoleMeta b{color:var(--dim);font:var(--fw-bold) var(--fs-11)/1.2 var(--font-mono)}
-.subagentRoleSignal{border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.025);padding:3px 6px;color:var(--dim);font-size:var(--fs-11);font-weight:var(--fw-bold)}
-.subagentRoleSignal.warn{border-color:rgb(var(--orange-rgb)/.34);background:rgb(var(--orange-rgb)/.065);color:var(--warn)}
-.subagentRoleInspect{justify-self:end;border:1px solid rgb(var(--signal-rgb)/.34);border-radius:var(--radius-sm);background:rgb(var(--signal-rgb)/.065);padding:6px 8px;color:var(--signal-hi);font:inherit;font-size:var(--fs-11);font-weight:var(--fw-bold);cursor:pointer;white-space:nowrap}
-.subagentRoleInspect:hover,.subagentRoleInspect:focus-visible{border-color:rgb(var(--signal-hi-rgb)/.68);background:rgb(var(--signal-rgb)/.12);color:var(--fg);outline:none}
-.subagentRoleEconomicsFoot{margin:8px 2px 0;color:var(--faint);font-size:var(--fs-11)}
-.subagentRoleAnalyticsEmpty{margin:12px;border:1px solid rgb(var(--orange-rgb)/.28);border-radius:var(--radius-md);background:rgb(var(--orange-rgb)/.05);padding:12px;color:var(--dim)}
-.subagentRoleAnalyticsEmpty strong{display:block;color:var(--fg);font-size:var(--fs-11)}
-.subagentRoleAnalyticsEmpty p{margin:4px 0 0;font-size:var(--fs-11)}
-.subagentRoleAnalyticsEmpty+.subagentRoleTable{border-top:1px solid var(--line)}
-.subagentSessionGroup>summary{position:relative;padding-right:24px}
-@media(max-width:1180px){.subagentWorkspace{grid-template-columns:minmax(0,1fr) 300px}.subagentSessionMetrics{gap:8px}.subagentChildHeader,.subagentChildRow{grid-template-columns:minmax(130px,1fr) minmax(82px,.7fr) minmax(68px,.48fr) minmax(62px,.44fr)}}
-@media(max-width:1100px){.subagentCommand .subagentFilterPrimary .filterControl:nth-child(4){grid-column:1/3}.subagentRoleTrendRow{grid-template-columns:minmax(160px,1fr) minmax(82px,.5fr) minmax(150px,.9fr) auto}.subagentRoleMeta{grid-column:1/4}.subagentRoleInspect{grid-column:4;grid-row:1/3}}
-@media(max-width:900px){.subagentWorkspace{grid-template-columns:1fr}.subagentInspector{position:relative;top:auto}.subagentFilterPrimary{grid-template-columns:repeat(2,minmax(0,1fr))}.subagentFilterPrimary .filterControl:first-child{grid-column:1/-1}.subagentFilterPrimary .filterControl:nth-child(4),.subagentFilterMore{grid-column:auto}.subagentSessionGroup>summary{grid-template-columns:1fr}.subagentSessionMetrics{text-align:left}.subagentSessionMetric{display:inline-flex;align-items:baseline;gap:4px}.subagentSessionMetric span,.subagentSessionMetric b{display:inline}.subagentChildHeader,.subagentChildRow{grid-template-columns:minmax(140px,1fr) minmax(80px,.7fr) minmax(66px,.45fr) minmax(62px,.42fr)}}
-.subagentCostHeat{position:relative;display:block;min-width:0;padding-bottom:8px;color:var(--cost-heat);font-weight:var(--fw-bold)}
-.subagentCostHeat:after{content:"";position:absolute;right:0;bottom:1px;width:var(--cost-fill);height:3px;max-width:100%;border-radius:var(--radius-xs);background:linear-gradient(90deg,var(--session-signal),var(--cost-heat))}
-.subagentCostHeat[style=""]{color:inherit}
-.subagentRoleKpi span{font-size:var(--fs-11)}
-.subagentRoleKpi strong{font-size:var(--fs-22)}
-.subagentRoleKpi small{font-size:var(--fs-11);line-height:1.35}
-.subagentRoleTrendHead h4{font-size:var(--fs-16)}
-.subagentRoleTrendHead p{font-size:var(--fs-11)}
-.subagentRoleChartModes button{font-size:var(--fs-11)}
-.subagentRoleTrendRow{min-height:116px}
-.subagentRoleIdentity strong{font-size:var(--fs-12)}
-.subagentRoleIdentity small{font-size:var(--fs-11);line-height:1.4}
-.subagentRolePrimary span,.subagentRoleMeta span{font-size:var(--fs-11)}
-.subagentRolePrimary b{font-size:var(--fs-16)}
-.subagentRolePrimary small{font-size:var(--fs-11)}
-.subagentRoleMeta b{font-size:var(--fs-11)}
-.subagentRoleSignal{font-size:var(--fs-11)}
-.subagentRoleInspect{font-size:var(--fs-11)}
-.subagentRoleEconomicsFoot{font-size:var(--fs-11);line-height:1.4}
-.subagentRoleSpark{display:flex;height:83px;flex-direction:column;justify-content:center}
-.subagentRoleSpark svg{height:62px;flex:none}
-.subagentRoleSparkDates{display:flex;justify-content:space-between;gap:8px;margin-top:3px;color:var(--faint);font:var(--fw-bold) var(--fs-11)/1 var(--font-mono)}
-.subagentRoleSparkDates span:last-child{text-align:right}
-.subagentRoleHeader,.subagentRoleRow{grid-template-columns:minmax(170px,1.2fr) repeat(5,minmax(82px,.56fr));min-width:750px}
-.subagentResultsHead h3{font-size:var(--fs-16)}
-.subagentResultsHead p{font-size:var(--fs-11);line-height:1.4}
-.subagentSessionIdentity strong{font-size:var(--fs-13)}
-.subagentSessionIdentity small{font-size:var(--fs-11)}
-.subagentSessionMetric span{font-size:var(--fs-11)}
-.subagentSessionMetric b{font-size:var(--fs-12)}
-.subagentChildHeader{font-size:var(--fs-11)}
-.subagentChildIdentity strong{font-size:var(--fs-12)}
-.subagentChildIdentity small{font-size:var(--fs-11)}
-.subagentChildMetric{font-size:var(--fs-11)}
-.subagentInspectorHead h3{font-size:var(--fs-16)}
-.subagentInspectorMetric span{font-size:var(--fs-11)}
-.subagentInspectorMetric b{font-size:var(--fs-12)}
-.subagentInspectorEmpty p{font-size:var(--fs-11)}
-#view-subagents .subagentExplorerMeta{font-size:var(--fs-12);font-weight:var(--fw-semibold);color:var(--dim)}
-#view-subagents .subagentWorkspace.roleView .subagentResultsHead{display:none}
-#view-subagents .subagentRoleEconomics{padding:18px}
-#view-subagents .subagentRoleKpis{gap:0;overflow:hidden;border:1px solid var(--line2);border-radius:var(--radius-lg);background:linear-gradient(105deg,rgb(var(--signal-rgb)/.055),rgb(var(--tint-rgb)/.015) 52%,rgb(var(--signal-hi-rgb)/.03))}
-#view-subagents .subagentRoleKpi{border:0;border-left:1px solid var(--line);border-radius:0;background:none;padding:14px 18px}
-#view-subagents .subagentRoleKpi:first-child{border-left:0}
-#view-subagents .subagentRoleKpi strong{font-size:var(--fs-24)}
-#view-subagents .subagentRoleTrendHead{margin-top:20px;margin-bottom:10px}
-#view-subagents .subagentRoleTrendRow{min-height:108px}
-#view-subagents .subagentRoleIdentity strong{font-size:var(--fs-13)}
-#view-subagents .subagentRoleEconomicsFoot{margin-top:10px}
-#view-subagents .subagentCompactSummary{margin-top:8px}
-#view-subagents .subagentWorkspace{margin-top:10px}
-#view-subagents .subagentCommand .subagentFilterPrimary{padding-bottom:12px}
-#view-subagents .subagentCommand .subagentFilterFooter{margin-top:0}
-@media(max-width:1100px){#view-subagents .subagentRoleKpi{padding:12px}#view-subagents .subagentRoleKpi strong{font-size:var(--fs-20)}}
-/* models-leaderboard-v1 */
-#view-models .modelSpend{padding:16px 16px 14px}
-:is(#view-models,.conceptFrame) .modelSpendHead{display:flex;align-items:baseline;justify-content:space-between;gap:14px;margin-bottom:10px}
-:is(#view-models,.conceptFrame) .modelSpendHead h2{font-size:var(--fs-16);margin:0}
-:is(#view-models,.conceptFrame) .modelSpendTotal{font:var(--fw-heavy) var(--fs-16)/1.2 var(--font-mono);color:var(--fg);white-space:nowrap}
-:is(#view-models,.conceptFrame) .modelSpendBar{display:flex;gap:2px;height:38px;border-radius:var(--radius-md);overflow:hidden;background:rgb(var(--tint-rgb)/.04)}
-:is(#view-models,.conceptFrame) .modelSpendSeg{display:flex;align-items:center;justify-content:space-between;gap:8px;min-width:4px;padding:0 10px;border:0;color:var(--on-accent-deep);font:inherit;font-size:var(--fs-12);cursor:default;overflow:hidden;white-space:nowrap}
-#view-models button.modelSpendSeg{cursor:pointer}
-#view-models button.modelSpendSeg:hover,#view-models button.modelSpendSeg:focus-visible{filter:brightness(1.12);outline:none}
-:is(#view-models,.conceptFrame) .modelSpendSeg span{font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis}
-:is(#view-models,.conceptFrame) .modelSpendSeg b{font-weight:var(--fw-heavy)}
-#view-models .modelSpendEmpty{display:flex;align-items:center;padding:0 12px;color:var(--faint);font-size:var(--fs-12)}
-:is(#view-models,.conceptFrame) .modelSpendLegend{display:flex;flex-wrap:wrap;gap:6px 8px;margin-top:10px}
-:is(#view-models,.conceptFrame) .modelSpendChip{display:inline-flex;align-items:center;gap:6px;max-width:100%;padding:4px 8px;border:1px solid var(--line);border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.03);color:var(--dim);font:inherit;font-size:var(--fs-12)}
-#view-models button.modelSpendChip{cursor:pointer}
-#view-models button.modelSpendChip:hover,#view-models button.modelSpendChip:focus-visible{border-color:var(--accent);color:var(--fg);outline:none}
-:is(#view-models,.conceptFrame) .modelSpendChip i{width:9px;height:9px;border-radius:var(--radius-xs);flex:0 0 auto}
-:is(#view-models,.conceptFrame) .modelSpendChipName{color:var(--fg);font-weight:var(--fw-bold);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:190px}
-#view-models .modelSpendChip small{color:var(--faint);font-size:var(--fs-11)}
-:is(#view-models,.conceptFrame) .modelSpendChip b{color:var(--fg);font-size:var(--fs-12)}
-:is(#view-models,.conceptFrame) .modelSpendChip em{font-style:normal;color:var(--faint)}
-#view-models .modelSpendNote{margin:8px 0 0;color:var(--faint);font-size:var(--fs-11)}
-#view-models .modelSpendNote:empty{display:none}
-#view-models .modelLinkBtn{border:0;background:none;padding:0;color:var(--accent);font:inherit;cursor:pointer;text-decoration:underline}
-#view-models .modelMixCard .modelChart,#view-models .modelSpeedCard .modelChart{height:250px}
-#view-models .modelSpeedCard .modelTrendControls{align-items:flex-end;flex-wrap:nowrap}
-#view-models .modelSpeedCard .modelPicker{width:260px}
-#view-models .modelSpeedLegend{display:flex;flex-wrap:wrap;gap:6px 14px;margin-top:8px;color:var(--dim);font-size:var(--fs-12)}
-#view-models .modelSpeedChip{display:inline-flex;align-items:center;gap:6px;max-width:320px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-#view-models .modelSpeedChip i{width:14px;height:3px;border-radius:var(--radius-2xs);flex:0 0 auto}
-#view-models .modelSpeedChip small{color:var(--faint)}
-#view-models .modelTableWrap{max-height:none;overflow-x:auto}
-#m-table.modelBoard{min-width:0}
-#m-table.modelBoard th{vertical-align:bottom;white-space:normal;line-height:1.25}
-#m-table .modelSortBtn{display:inline-flex;align-items:center;gap:4px;border:0;background:none;padding:0;color:inherit;font:inherit;text-transform:inherit;letter-spacing:inherit;cursor:pointer}
-#m-table th.num .modelSortBtn{justify-content:flex-end}
-#m-table .modelSortBtn:after{content:"";width:8px;color:var(--faint);font-size:var(--fs-11)}
-#m-table .modelSortBtn.fieldtip{cursor:pointer}
-#m-table .modelSortBtn:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:var(--radius-xs)}
-#m-table .modelSortBtn.on{color:var(--fg)}
-#m-table .modelSortBtn.on[data-direction=desc]:after{content:"\25BE"}
-#m-table .modelSortBtn.on[data-direction=asc]:after{content:"\25B4"}
-#m-table .modelRankCol{width:30px;color:var(--faint);text-align:right;padding-right:4px}
-#m-table td.num{white-space:nowrap}
-#m-table .modelNameCell{min-width:210px}
-#m-table .modelName{max-width:230px}
-#m-table .modelRuntime{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:250px}
-#m-table .modelNameLine{gap:0}
-#m-table .modelExpand,#m-table .modelExpandSpacer{display:inline-flex;align-items:center;justify-content:center;width:18px;height:18px;margin-right:4px;flex:0 0 auto}
-#m-table .modelExpand{border:1px solid var(--line2);border-radius:var(--radius-xs);background:rgb(var(--tint-rgb)/.04);color:var(--dim);font-size:var(--fs-11);cursor:pointer;padding:0}
-#m-table .modelExpand:hover,#m-table .modelExpand:focus-visible{border-color:var(--accent);color:var(--fg);outline:none}
-#m-table .modelRuntime{padding-left:20px}
-#m-table .modelSpendCell{min-width:170px}
-#m-table .modelSpendCell .modelSpendTrack{display:inline-block;width:72px;height:7px;margin-right:8px;vertical-align:middle;border-radius:var(--radius-pill);background:rgb(var(--tint-rgb)/.06);overflow:hidden}
-#m-table .modelSpendCell .modelSpendTrack i{display:block;height:100%;border-radius:var(--radius-pill)}
-#m-table .modelSpendCell b{display:inline-block;min-width:66px;font-size:var(--fs-13);color:var(--fg)}
-#m-table .modelSpendCell small{display:inline-block;min-width:34px;margin-left:6px;color:var(--faint);font-size:var(--fs-11)}
-#m-table .modelMuted{color:var(--faint)}
-#m-table .modelVariantRow td{background:rgb(var(--tint-rgb)/.018);padding-top:6px;padding-bottom:6px;font-size:var(--fs-12)}
-#m-table .modelVariantName{padding-left:44px;color:var(--dim);font-weight:var(--fw-bold)}
-#m-table .modelVariantName small{margin-left:8px;color:var(--faint);font-weight:var(--fw-medium)}
-#m-table .modelVariantRow .modelSpendCell b{font-size:var(--fs-12);color:var(--dim)}
-#view-models .modelDiagnostics{margin-top:12px;padding:0}
-#view-models .modelDiagnostics>summary{display:flex;align-items:baseline;gap:12px;padding:14px 16px;cursor:pointer;list-style:none}
-#view-models .modelDiagnostics>summary::-webkit-details-marker{display:none}
-#view-models .modelDiagnostics>summary:before{content:"\25B8";color:var(--faint);font-size:var(--fs-11);transition:transform .15s ease}
-#view-models .modelDiagnostics[open]>summary:before{transform:rotate(90deg)}
-#view-models .modelDiagnostics>summary span{font-size:var(--fs-14);font-weight:var(--fw-heavy);color:var(--fg)}
-#view-models .modelDiagnostics>summary:focus-visible{outline:2px solid var(--accent);outline-offset:-3px;border-radius:var(--radius-md)}
-#view-models .modelDiagHero{grid-template-columns:repeat(3,minmax(0,1fr));padding:0 16px}
-#view-models .modelDiagTrend{padding:4px 16px 16px;margin-top:4px}
-@media(max-width:1180px){#m-table .modelSpendCell{min-width:0}#m-table .modelSpendCell .modelSpendTrack{width:40px;margin-right:6px}#m-table .modelSpendCell b{min-width:0}#m-table .modelSpendCell small{display:none}#m-table .modelNameCell{min-width:180px}#m-table .modelName{max-width:170px}#m-table td,#m-table th{padding-left:4px;padding-right:4px}#m-table .modelHelp:before{display:none}#m-table th{font-size:var(--fs-11)}#m-table td.num{font-size:var(--fs-12)}#m-table .modelRuntime{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:200px}#view-models .modelSpeedCard .modelPicker{width:210px}}
-#view-models .modelKpi .modelValueQual{display:block;margin-top:3px;color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-bold);line-height:1.2;letter-spacing:0}
-.goalsSection{margin:18px 0}
-.goalsPrevious{margin-top:14px}
-.goalsPrevious summary{cursor:pointer;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold);margin-bottom:10px}
-.goalsHead{display:flex;align-items:flex-end;justify-content:space-between;gap:16px;margin-bottom:12px}
-.goalsHead h2{font-size:var(--fs-18);margin:0 0 4px}
-.goalsHead p{margin:0;color:var(--dim);font-size:var(--fs-12)}
-.goalsNotice{margin:0 0 12px;padding:10px 12px;border:1px solid var(--line2);border-radius:var(--radius-md);color:var(--dim);font-size:var(--fs-12)}
-.goalsNotice.tone-warn{border-color:var(--warn)}
-.goalsNotice[hidden],.goalsCustom[hidden],.goalsDates[hidden],.goalsFormError[hidden],.goalsRepeat[hidden],.goalsStep[hidden],.goalsList[hidden]{display:none}
-.goalActions button:disabled{opacity:.5;cursor:not-allowed}
-.goalsDialog{width:min(920px,calc(100vw - 28px));max-height:calc(100vh - 40px);overflow:auto}
-.goalsForm{display:grid;gap:16px}
-.goalsFormBody{display:grid;grid-template-columns:minmax(0,1fr) minmax(260px,300px);gap:24px;align-items:start;padding:0 20px}
-.goalsFields{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px 12px;min-width:0}
-.goalsSpan2{grid-column:span 2}
-.goalsModelSearch{display:grid;gap:4px;padding:4px 4px 8px;border-bottom:1px solid var(--line);margin-bottom:6px}
-.goalsModelSearch input{box-sizing:border-box;width:100%;min-height:32px;border:1px solid var(--line2);border-radius:var(--radius-md);background:var(--panel);color:var(--fg);font:var(--fs-13) var(--font-sans);padding:6px 10px}
-.goalPreview{position:sticky;top:16px;display:grid;gap:12px;min-width:0;padding:16px;border:1px solid var(--line2);border-radius:var(--radius-md);background:linear-gradient(160deg,var(--panel2),var(--bg2))}
-.goalPreviewKicker{color:var(--faint);font-size:var(--fs-11);font-weight:var(--fw-heavy);letter-spacing:.04em;text-transform:uppercase}
-.goalPreview h4{margin:0 0 4px;font-size:var(--fs-16);overflow-wrap:anywhere}
-.goalPreview .goalMeta{margin:0}
-.goalPreviewLedger{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px;padding-top:12px;border-top:1px solid var(--line)}
-.goalPreviewReadout strong{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.goalPreview .readoutScale,.goalPreview .readoutCaption{margin-top:0}
-.goalPreviewNote{display:block}
-.goalsForm h3{margin:0;padding:20px 20px 0;font-size:var(--fs-18)}
-.goalsStep{display:grid;gap:6px;min-width:0;margin:0;padding:0;border:0;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.goalsStep legend{padding:0;margin-bottom:6px}
-.goalsWide{grid-column:1/-1}
-.goalsHelp{margin:0;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-medium);line-height:1.45}
-.goalsDates{display:grid;grid-template-columns:1fr 1fr;gap:8px}
-.goalsStep input:not([type=checkbox]){box-sizing:border-box;width:100%;min-height:38px;border:1px solid var(--line2);border-radius:var(--radius-md);background:var(--panel);color:var(--fg);font:var(--fs-13) var(--font-sans);padding:8px 10px;color-scheme:dark}
-.goalsRepeat{display:flex;align-items:center;align-self:end;gap:6px;min-height:38px;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-semibold)}
-.goalsOptions{display:flex;flex-wrap:wrap;gap:8px}
-.goalOption{border:1px solid var(--line2);border-radius:var(--radius-md);background:var(--panel);color:var(--fg);font:var(--fw-bold) var(--fs-12) var(--font-sans);padding:8px 12px;cursor:pointer;text-align:left}
-.goalOption small{display:block;color:var(--dim);font-weight:var(--fw-semibold)}
-.goalOption[aria-pressed=true]{border-color:var(--accent);background:rgb(var(--signal-rgb)/.12)}
-.goalOption:focus-visible{outline:none;box-shadow:var(--focus-ring)}
-.goalsCustom{display:grid;grid-template-columns:minmax(0,160px) minmax(0,1fr);gap:8px;margin-top:8px}
-.goalsFormError{flex:1;min-width:0;padding:6px 10px;border:1px solid var(--warn);border-radius:var(--radius-md);color:var(--warn);font-size:var(--fs-12)}
-.goalsFormActions{position:sticky;bottom:0;display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:14px 20px;border-top:1px solid var(--line);background:var(--panel2)}
-.goalsList{display:grid;grid-template-columns:repeat(auto-fill,minmax(320px,1fr));gap:12px}
-.goalsEmpty{grid-column:1/-1}
-.goalCard{display:grid;gap:10px;align-content:start;padding:16px;min-width:0;transition:border-color .3s,box-shadow .3s}
-.goalCard.is-saved{border-color:var(--accent);box-shadow:var(--focus-ring)}
-.goalCardHead{display:flex;justify-content:space-between;gap:10px;align-items:flex-start}
-.goalCard h4{margin:0;font-size:var(--fs-14);overflow-wrap:anywhere}
-.goalCard .goalMeta{margin:0}
-.goalStatus{flex:none;font-weight:var(--fw-heavy)}
-.goalStatus.on_track,.goalStatus.met{color:var(--good);border-color:currentColor}
-.goalStatus.at_risk{color:var(--warn);border-color:currentColor}
-.goalStatus.missed{color:var(--bad);border-color:currentColor}
-.goalStatus.no_result{color:var(--faint);border-style:dashed}
-.goalStatus.ended{color:var(--faint)}
-.goalMeta{margin:4px 0 10px;color:var(--dim);font-size:var(--fs-12)}
-.goalNumbers{display:flex;align-items:baseline;gap:10px;flex-wrap:wrap}
-.goalNumbers strong{font-size:var(--fs-20)}
-.goalNumbers span,.goalDetail{color:var(--dim);font-size:var(--fs-12)}
-.goalNumbers .goalConfidence{margin-left:auto;color:var(--faint)}
-.goalDetail{margin:0}
-.goalFoot{display:flex;align-items:center;gap:10px;min-height:28px}
-.goalFoot>:first-child{flex:1;min-width:0}
-.goalCard .readoutScale,.goalFoot .readoutCaption{margin-top:0}
-.goalFoot .goalActions{margin:0;align-items:center}
-.goalDots{display:flex;gap:4px}
-.goalDots i{width:8px;height:8px;border-radius:var(--radius-round);background:currentColor}
-.goalMenu{position:relative}
-.goalMenu>summary{list-style:none;padding:4px 8px;font-size:var(--fs-12);line-height:1;cursor:pointer}
-.goalMenu>summary::-webkit-details-marker{display:none}
-.goalMenuList{width:160px;display:grid;gap:2px}
-.goalMenuList button{border:0;border-radius:var(--radius-sm);background:none;color:var(--fg);font:var(--fw-semibold) var(--fs-12) var(--font-sans);text-align:left;padding:8px 10px;cursor:pointer}
-.goalMenuList button:hover,.goalMenuList button:focus-visible{outline:none;background:var(--line)}
-.goalMenuList .goalMenuDanger{color:var(--bad)}
-.goalSparkLine{fill:none;stroke:var(--accent);stroke-width:1.6;vector-effect:non-scaling-stroke}
-.goalSparkTarget{stroke:var(--faint);stroke-width:1;stroke-dasharray:3 3;vector-effect:non-scaling-stroke}
-.goalHistory{display:flex;flex-wrap:wrap;gap:6px;margin-top:8px}
-.goalActions{display:flex;gap:8px;margin-top:10px}
-.goalActions button{font-size:var(--fs-11);padding:4px 8px}
-#view-efficiency.goalDetailOpen>:not(#efficiency-goals){display:none}
-.goalDetailView{display:grid;gap:14px}
-.goalDetailView[hidden]{display:none}
-.goalDetailHead{display:flex;align-items:flex-start;gap:14px}
-.goalDetailTitle{flex:1;min-width:0}
-.goalDetailHead h3{margin:0 0 4px;font-size:var(--fs-20);overflow-wrap:anywhere}
-.goalDetailHead .goalMeta{margin:0}
-.goalDetailSummary{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px}
-.goalDetailMetric{padding:14px 16px}
-.goalDetailCard{padding:16px 18px;min-width:0}
-.goalDetailCard h4{margin:0 0 10px;font-size:var(--fs-14)}
-.goalDetailCard h5{margin:12px 0 6px;color:var(--dim);font-size:var(--fs-12);font-weight:var(--fw-bold)}
-.goalDetailGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}
-.goalTrend{display:block;width:100%;height:160px}
-.goalTrendTip{white-space:normal;width:max-content;max-width:calc(100% - 16px)}
-.goalTrendAxis{display:flex;justify-content:space-between;gap:12px;margin-top:6px;color:var(--faint);font-size:var(--fs-11)}
-.goalDriverRow{display:grid;grid-template-columns:minmax(0,1.4fr) minmax(0,1fr) auto;gap:10px;align-items:center;padding:4px 0;font-size:var(--fs-12)}
-.goalDriverRow span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-.goalDriverRow b{font-family:var(--font-mono);font-weight:var(--fw-bold);color:var(--fg)}
-.goalDriverBar{height:8px;border-radius:var(--radius-sm);background:rgb(var(--tint-rgb)/.07);overflow:hidden}
-.goalDriverBar i{display:block;height:100%;background:var(--accent)}
-.goalDriverNote{margin:8px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
-.goalCoachTip{padding:12px 0;border-top:1px solid var(--line)}
-.goalCoachTip:first-of-type{border-top:0;padding-top:0}
-.goalCoachTip h5{margin:0 0 4px;color:var(--fg);font-size:var(--fs-13)}
-.goalCoachTip p{margin:4px 0 0;color:var(--dim);font-size:var(--fs-12);line-height:1.45}
-.goalCoachTip .goalCoachSaving{color:var(--good);font-weight:var(--fw-bold)}
-.goalCoachSaving small{display:block;margin-top:2px;color:var(--dim);font-weight:var(--fw-medium)}
-.goalTitleLink{color:inherit;text-decoration:none}
-.goalTitleLink:hover{color:var(--accent)}
-@media(max-width:1200px){.goalDetailSummary{grid-template-columns:repeat(2,minmax(0,1fr))}.goalDetailGrid{grid-template-columns:minmax(0,1fr)}}
-
-/* Concept frames show real dashboard components with sample values; these rules only fit them to the frame and keep them still. */
-:where(.conceptFrame) :is(.currentSessionCard,.capReviewQueue,.subagentRoleTrendList,.spendPlot,.efficiencyHeadline){overflow:visible}
-:where(.conceptFrame) .currentSessionCard{min-height:0;cursor:default}
-:where(.conceptFrame) .currentSessionCard:hover{transform:none;border-color:color-mix(in srgb,var(--harness) 48%,var(--line));box-shadow:var(--shadow-soft)}
-:where(.conceptFrame) .currentSessionContextSpark{max-width:96px;height:22px}
-:where(.conceptFrame) .spendChartInner{height:132px}
-:where(.conceptFrame) .spendDayTrack{background:repeating-linear-gradient(to top,transparent 0 44px,rgb(var(--tint-rgb)/.035) 44px 45px)}
-:where(.conceptFrame) .spendDay{cursor:default}
-:where(.conceptFrame) .spendDay:hover{background:transparent}
-:where(.conceptFrame) .spendChart{min-height:0;margin-top:0;grid-template-columns:minmax(0,1fr)}
-:where(.conceptFrame) .budgetSpend{display:grid;justify-content:normal;gap:4px}
-:where(.conceptFrame) .budgetSpendValue{font-size:var(--fs-readout-md);letter-spacing:-.02em}
-:where(.conceptFrame) .budgetProgress{margin-top:4px}
-:where(.conceptFrame) .budgetMeterFoot>span:last-child{display:inline-flex;align-items:center;gap:8px;color:var(--fg);font-weight:var(--fw-semibold)}
-:where(.conceptFrame) .efficiencyHeadline{min-height:0;padding:16px 18px 12px}
-:where(.conceptFrame) .efficiencyValueRow{display:flex;align-items:center;gap:20px}
-:where(.conceptFrame) .efficiencyHeadline .efficiencyChart{height:88px;cursor:default}
-:where(.conceptFrame) .capReviewHead,:where(.conceptFrame) .capReviewItem{grid-template-columns:minmax(0,1fr)}
-:where(.conceptFrame) .capReviewCols{grid-template-columns:0 minmax(0,1fr) 92px 168px}
-:where(.conceptFrame) .capReviewRow{min-height:40px;display:grid;align-items:center}
-:where(.conceptFrame) .capReviewHead>span:last-child{text-align:left}
-:where(.conceptFrame) .capReviewNum{display:inline-flex;align-items:center;gap:6px;overflow:visible}
-:where(.conceptFrame) .subagentRoleTrendRow{grid-template-columns:minmax(0,1fr) auto minmax(0,1.1fr);min-height:0;padding:14px 16px}
-:where(.conceptFrame) .compareCardTitle{overflow:hidden;font-size:var(--fs-13);text-overflow:ellipsis;white-space:nowrap}
-:where(.conceptFrame) .compareBreakdownRow b{display:inline-flex;align-items:center;justify-content:flex-end;gap:8px}
-:where(.conceptFrame) .compareSection{padding:14px 16px}
-</style></head><body class=spectrumApp>
-<!--
-THESIS: Sessions are live instruments, not a generic grid of dark cards.
-OWN-WORLD: Token Meter ink, cyan and sky light, restrained violet and orange accents, Tektur display type, and layered operational gradients.
-STORY: Find the active run, read cost, context, and speed, then open one task and follow its evidence without losing orientation.
-FIRST VIEWPORT: A layered spectrum header leads into a two-column instrument grid; detail replaces the generic title with the task and pairs its main chart with a luminous cost-and-context gauge.
-FORM: Spectrum Instrument Field — user-pinned Neo-Mirai, 1 of 1 grounded forms; concept-roll seed a5c0fdde; returned to Token Meter's original palette.
-FINISH: unreviewed and undocumented is unfinished; this build ends with the finish review, the verdict, and specs/DESIGN.md
--->
-<div class=wrap>
- <div class=top aria-label="Token Meter navigation">
-  <div class=brand><div class=logo role=img aria-label="Splunk by Cisco"><img src="/assets/brand/logo-splunk-by-cisco-rgb-w.png" alt=""></div><span class=brandCopy><span class=brandName>Token Meter</span></span></div>
-	  <nav class=tabs aria-label="Primary navigation">
-	   <div class=navPrimary>
-	   <button class="tab on" id=tab-session data-label=Sessions aria-label=Sessions title=Sessions><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h16M4 12h16M4 17h16"/><path d="M7 5v4M14 10v4M18 15v4"/></svg><span class=tabLabel>Sessions</span></button>
-	   <button class=tab id=tab-daily data-label=Spend aria-label=Spend title=Spend><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="4" y="5" width="16" height="15" rx="2"/><path d="M8 3v4M16 3v4M4 9h16M8 13h3M8 17h7"/></svg><span class=tabLabel>Spend</span></button>
-	   <button class=tab id=tab-models data-label=Models aria-label=Models title=Models><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 18l5-5 4 2 7-8"/><path d="M16 7h4v4M4 20h16"/></svg><span class=tabLabel>Models</span></button>
-	   <button class=tab id=tab-subagents data-label=Subagents aria-label=Subagents title=Subagents><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><circle cx="12" cy="7" r="3"/><circle cx="6" cy="17" r="2"/><circle cx="18" cy="17" r="2"/><path d="M12 10v3M6 15v-2h12v2"/></svg><span class=tabLabel>Subagents</span></button>
-	   <button class=tab id=tab-efficiency data-label=Efficiency aria-label=Efficiency title=Efficiency><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M5 19V9M12 19V5M19 19v-7"/><path d="M3 19h18"/></svg><span class=tabLabel>Efficiency</span></button>
-	   <button class=tab id=tab-work data-label=Work aria-label=Work title=Work hidden><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="3" y="7" width="18" height="13" rx="2"/><path d="M9 7V5a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2M3 13h18"/></svg><span class=tabLabel>Work</span></button>
-	   <button class=tab id=tab-git data-label=Git aria-label=Git title=Git><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 16l5-5 4 3 7-8"/><path d="M15 6h5v5M4 20h16"/></svg><span class=tabLabel>Git</span></button>
-	   <a class=tab id=tab-performance href=/performance data-label=Performance aria-label=Performance title=Performance><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="5" y="4" width="14" height="16" rx="2"/><path d="M8 15v-3M12 15V9M16 15v-5M8 18h8"/></svg><span class=tabLabel>Performance</span></a>
-	   </div>
-	   <div class=navSecondary>
-	   <button class=tab id=tab-read data-label=Read aria-label="Read about Enterprise Tokenomics" title="Read about Enterprise Tokenomics · Opens a Splunk search in a new tab"><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M14 3h7v7M10 14 21 3M21 14v5a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5"/></svg><span class=tabLabel>Read</span></button>
-	   <button class=tab id=tab-learn data-label=Learn aria-label=Learn title=Learn><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 5.5A3.5 3.5 0 0 1 7.5 2H11v17H7.5A3.5 3.5 0 0 0 4 22zM20 5.5A3.5 3.5 0 0 0 16.5 2H13v17h3.5A3.5 3.5 0 0 1 20 22z"/></svg><span class=tabLabel>Learn</span></button>
-	   <button class=tab id=tab-capabilities data-label=Tools aria-label=Tools title=Tools><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M14 6a4 4 0 0 0-5 5L4 16l4 4 5-5a4 4 0 0 0 5-5l-3 3-3-3z"/></svg><span class=tabLabel>Tools</span></button>
-	   <button class=tab id=tab-settings data-label=Settings aria-label=Settings title=Settings><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h10M18 7h2M4 17h3M11 17h9M14 4v6M7 14v6"/></svg><span class=tabLabel>Settings</span></button>
-	   </div>
-	  </nav>
-  <div class=spacer></div>
- </div>
-
- <div id=session-depot hidden>
-  <div class=sessionhead>
-   <span class=badge id=s-provider>source</span>
-   <span class=repo id=s-repo>--</span>
-   <span class="sessid mono" id=s-id></span>
-   <span class=pill id=s-pricing></span>
-   <span class=spacer></span>
-  </div>
-  <div class=sessionStart id=session-start hidden><span>Started with</span><strong id=session-start-text></strong></div>
-
-  <div class="session-panel on" id=panel-summary>
-  <div class=agentDiscovery id=agent-discovery hidden>
-   <div class=agentDiscoveryMain><div class=agentDiscoveryTitle>Ask about this run from Codex or Claude</div><div class=agentDiscoveryText>Get a read-only verdict on cost, context, tool output, and whether to continue&mdash;without sharing prompts or tool content.</div></div>
-   <button class=tbtn id=agent-discovery-open type=button>Connect agent</button>
-   <button class=agentDiscoveryClose id=agent-discovery-close type=button aria-label="Dismiss agent access suggestion">&times;</button>
-  </div>
-  <div class=hero>
-   <div class="card costcard" tabindex=0>
-    <div>
-     <div class="label fieldtip" tabindex=0 title="Estimated cost for the selected local log/thread using the configured model rates. Executions are the individual model turns inside it." data-tip="Estimated cost for the selected local log/thread using the configured model rates. Executions are the individual model turns inside it.">Session cost</div>
-     <div class="meter mono" id=cost>$0.00</div>
-     <div class=subline id=sub></div>
-    </div>
-    <div class=costtip id=cost-tip></div>
-    <div class=costmeta>
-     <div><div class="label fieldtip" tabindex=0 title="Local timestamp for the first observed event in this log/thread." data-tip="Local timestamp for the first observed event in this log/thread.">Started</div><div class="v mono" id=cost-start>--</div><div class=sm>local time</div></div>
-     <div><div class="label fieldtip" tabindex=0 id=cost-end-label title="Local timestamp for the newest observed event in this log/thread." data-tip="Local timestamp for the newest observed event in this log/thread.">Last activity</div><div class="v mono" id=cost-end>--</div><div class=sm>local time</div></div>
-    </div>
-    <div class=frozen id=frozen>pinned log - frozen view</div>
-   </div>
-   <div class=statgrid>
-    <div class=stat><div class="label fieldtip" tabindex=0 title="Total model input tokens, including uncached input, cache reads, and cache writes." data-tip="Total model input tokens, including uncached input, cache reads, and cache writes.">Input</div><div class="v mono" id=input-tok>0</div><div class=sm id=input-toksm></div></div>
-	    <div class=stat><div class="label fieldtip" tabindex=0 title="Includes trace-reported reasoning and thinking output. Excludes input, cache, and external tool-result tokens. Completed speed is weighted across every attributable completed sample; active speed uses completed checkpoints." data-tip="Includes trace-reported reasoning and thinking output. Excludes input, cache, and external tool-result tokens. Completed speed is weighted across every attributable completed sample; active speed uses completed checkpoints.">Output</div><div class=outputPair><div class="v mono" id=output-tok>0</div><div class=outputRate><strong class=mono id=output-tps>--</strong><span>tok/s</span></div></div><div class=sm id=output-toksm></div></div>
-    <div class=stat><div class="label fieldtip" tabindex=0 title="Cumulative wall-clock time from a user prompt until the completed response. Reasoning and tool use count because you are still waiting; gaps between prompts do not." data-tip="Cumulative wall-clock time from a user prompt until the completed response. Reasoning and tool use count because you are still waiting; gaps between prompts do not.">Wait time</div><div class="v mono" id=ov-duration>--</div><div class=sm id=ov-idle></div></div>
-    <div class=stat><div class="label fieldtip" tabindex=0 title="Latest execution input/context tokens, shown against the model window when known." data-tip="Latest execution input/context tokens, shown against the model window when known.">Context in use</div><div class="v mono" id=ov-context>0</div><div class=sm id=ov-contextsm></div></div>
-   </div>
-  </div>
-
-  <div id=session-efficiency-home>
-   <section class="card sessionEfficiency" id=session-efficiency aria-labelledby=session-efficiency-title>
-    <div class=sessionEfficiencyIntro><div class=label id=session-efficiency-title>Efficiency</div><div class=sm>This run</div></div>
-    <div class="sessionEfficiencyMetric metric"><div class=label>Output / $</div><strong class=mono id=session-output-dollar>--</strong><span id=session-output-dollar-note>unavailable</span></div>
-    <div class="sessionEfficiencyMetric metric"><div class=label>Reasoning ratio</div><strong class=mono id=session-reasoning-ratio>--</strong><span id=session-reasoning-ratio-note>unavailable</span></div>
-   </section>
-  </div>
-
-  <div id=session-budget-home>
-  <div class="card sessionBudget" id=session-budget-control>
-   <div class=sessionBudgetHead>
-    <div><div class="label fieldtip" tabindex=0 title="Saved cost cap for this session. Token Meter alerts when the live session crosses it." data-tip="Saved cost cap for this session. Token Meter alerts when the live session crosses it.">Session budget</div></div>
-    <label class=sessionBudgetExact><span>Cap $</span><input id=budget type=number min=0.5 step=0.5 value=10 aria-label="Exact session budget in USD"></label>
-   </div>
-   <div class=sessionBudgetTrack>
-    <span class=mono id=budget-slider-min>$0.50</span>
-    <input id=budget-slider type=range min=0.5 max=100 step=0.5 value=10 aria-label="Session budget slider">
-    <span class=mono id=budget-slider-max>$100.00</span>
-   </div>
-   <div class=sessionBudgetMeta><span id=session-budget-spend>Session spend $0.00</span><span id=session-budget-status role=status aria-live=polite></span></div>
-  </div>
-  </div>
-
-  <details class=usageDetails id=usage-details>
-  <summary><span>Usage details</span></summary>
-  <div class=usageDetailsBody>
-  <div id=session-token-split-home>
-  <div class="card pad usageSplit" id=session-token-split-module>
-   <div class=splithead><div class="label fieldtip" tabindex=0 title="Semantic split of where the current log's tokens went." data-tip="Semantic split of where the current log's tokens went.">Where tokens go</div><span class=hint id=semhint></span></div>
-   <div class=bar id=sembar></div>
-   <div class=legend>
-    <span class=fieldtip tabindex=0 title="Tokens associated with model reasoning or thinking output." data-tip="Tokens associated with model reasoning or thinking output."><i class=dot style=background:var(--reason)></i>reasoning</span>
-    <span class=fieldtip tabindex=0 title="Regular assistant output tokens." data-tip="Regular assistant output tokens."><i class=dot style=background:var(--output)></i>output</span>
-    <span class=fieldtip tabindex=0 title="Approximate tokens returned by tool results." data-tip="Approximate tokens returned by tool results."><i class=dot style=background:var(--retrieval)></i>retrieval</span>
-    <span class=fieldtip tabindex=0 title="Tokens and cost attributed to subagent or coordination executions." data-tip="Tokens and cost attributed to subagent or coordination executions."><i class=dot style=background:var(--coord)></i>coordination</span>
-   </div>
-  </div>
-  </div>
-  <div class="statgrid usageDetailGrid">
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Output tokens attributed to reasoning or thinking events when the provider reports them." data-tip="Output tokens attributed to reasoning or thinking events when the provider reports them.">Thinking</div><div class="v mono" id=think-tok>0</div><div class=sm id=think-toksm></div></div>
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Approximate tokens returned from tool results, based on captured output size." data-tip="Approximate tokens returned from tool results, based on captured output size.">Tool results</div><div class="v mono" id=toolcall-tok>0</div><div class=sm id=toolcall-toksm></div></div>
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Estimated spend per active execution minute. Idle gaps are excluded and overlapping execution windows are counted once." data-tip="Estimated spend per active execution minute. Idle gaps are excluded and overlapping execution windows are counted once.">Burn / min</div><div class="v mono" id=burn>$0</div><div class=sm id=burnsm>active execution time</div></div>
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Estimated average cost per completed task or turn completion." data-tip="Estimated average cost per completed task or turn completion.">Cost / task</div><div class="v mono" id=cpt>$0</div><div class=sm id=cptsm></div></div>
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Share of input tokens that were cached or cache-related instead of uncached input." data-tip="Share of input tokens that were cached or cache-related instead of uncached input.">Cache rate</div><div class="v mono" id=cache-hit>0%</div><div class=sm id=cache-hitsm></div></div>
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Total input tokens served from or written to the provider prompt cache." data-tip="Total input tokens served from or written to the provider prompt cache.">Cache tokens</div><div class="v mono" id=cache-tok>0</div><div class=sm id=cache-toksm></div></div>
-   <div class=stat><div class="label fieldtip" tabindex=0 title="Estimated savings from cache reads versus charging those tokens at the normal input rate." data-tip="Estimated savings from cache reads versus charging those tokens at the normal input rate.">Cache saved</div><div class="v mono" id=cache-saved>$0</div><div class=sm id=cache-savedsm></div></div>
-  </div>
-
-  <div class=section-h><h2><span class=fieldtip tabindex=0 title="High-level metrics for the current log/thread. Executions are individual model turns." data-tip="High-level metrics for the current log/thread. Executions are individual model turns.">Execution Overview</span></h2><span class=hint id=exec-hint></span></div>
-  <div class=overview>
-   <div class="card ov"><div class="label fieldtip" id=ov-loaded-label tabindex=0 title="Runtime-advertised catalog entries when available; otherwise observed tool types. Catalog entries may be default/read-only and are not an optimization denominator." data-tip="Runtime-advertised catalog entries when available; otherwise observed tool types. Catalog entries may be default/read-only and are not an optimization denominator.">Catalog advertised</div><div class="v mono" id=ov-loaded>0</div><div class=sm id=ov-loadedsm></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Number of priced model executions observed in this log/thread." data-tip="Number of priced model executions observed in this log/thread.">Executions</div><div class="v mono" id=ov-exec>0</div><div class=sm id=ov-model></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Estimated log/thread cost divided by execution count." data-tip="Estimated log/thread cost divided by execution count.">Avg cost</div><div class="v mono" id=ov-avg>$0</div><div class=sm></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Total tool calls observed in this log/thread." data-tip="Total tool calls observed in this log/thread.">Tool calls</div><div class="v mono" id=ov-tools>0</div><div class=sm id=ov-tooltok></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Highest observed input/context token count in this log/thread." data-tip="Highest observed input/context token count in this log/thread.">Context peak</div><div class="v mono" id=ov-peak>0</div><div class=sm></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Most expensive single execution in this log/thread." data-tip="Most expensive single execution in this log/thread.">Priciest</div><div class="v mono" id=ov-big>$0</div><div class=sm id=ov-bigsm></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded." data-tip="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded.">Skills used</div><div class="v mono" id=ov-skills>--</div><div class=sm id=ov-skillssm></div></div>
-   <div class="card ov"><div class="label fieldtip" tabindex=0 title="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded." data-tip="Distinct skills activated and MCP servers called, out of those the runtime recorded as loaded for this session. — means the runtime does not record what was loaded.">MCP servers used</div><div class="v mono" id=ov-mcp>--</div><div class=sm id=ov-mcpsm></div></div>
-  </div>
-  <div class="capHero currentCapHero" aria-label="Session tool activity and removable capability optimization">
-   <div class="card pad"><div class="label fieldtip" tabindex=0 title="Unique tool identities observed in this selected log. Default tools and result-only instrumentation are included here as activity, not as removal candidates." data-tip="Unique tool identities observed in this selected log. Default tools and result-only instrumentation are included here as activity, not as removal candidates.">Tool activity</div><div class="meter mono" id=ov-activity-tools>0</div><div class=subline id=ov-activity-note></div></div>
-   <div class="card pad"><div class="label fieldtip" tabindex=0 title="Enabled user-installed skill packs this runtime can disable. Any skill activation marks its whole pack used. Default tools and MCP servers are read-only evidence." data-tip="Enabled user-installed skill packs this runtime can disable. Any skill activation marks its whole pack used. Default tools and MCP servers are read-only evidence.">Optional capability use</div><div class="meter mono" id=ov-optional-use>0/0</div><div class=capStatBar id=ov-optional-bar role=progressbar aria-label="Optional capability use in this session" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0><i></i></div><div class=subline id=ov-optional-note></div></div>
-   <div class="card pad"><div class="label fieldtip" tabindex=0 title="Enabled user-installed skill packs with no observed activation in this session. MCP servers and read-only capabilities are excluded." data-tip="Enabled user-installed skill packs with no observed activation in this session. MCP servers and read-only capabilities are excluded.">Unused skill packs</div><div class="meter mono" id=ov-unused-packs>0</div><div class=subline id=ov-unused-packs-note></div></div>
-  </div>
-
-  <div id=session-chart-home>
-  <section class=sessionChartModule id=session-chart-module>
-  <div class=section-h><h2>Execution Profile</h2><span class=hint id=exec-profile-hint>per execution or request</span></div>
-  <div class="card pad">
-   <div class=chartbar>
-    <div class=label>Chart</div>
-    <div class=seg id=chart-mode>
-     <button class=fieldtip data-chart=tokens title="Show input, cached input, and output tokens for each execution." data-tip="Show input, cached input, and output tokens for each execution.">Tokens</button>
-     <button class=fieldtip data-chart=cost title="Show estimated USD cost for each execution." data-tip="Show estimated USD cost for each execution.">Cost</button>
-     <button class=fieldtip data-chart=context title="Show input/context pressure as a share of the model context window." data-tip="Show input/context pressure as a share of the model context window.">Context</button>
-     <button class=fieldtip data-chart=tools title="Show the number of tool calls observed in each execution." data-tip="Show the number of tool calls observed in each execution.">Tools</button>
-     <button class=fieldtip data-chart=steps title="Show how many executions happened after each captured user message." data-tip="Show how many executions happened after each captured user message.">Steps</button>
-     <button class=fieldtip data-chart=wait title="Show prompt-to-completed-response wall-clock wait for each user request." data-tip="Show prompt-to-completed-response wall-clock wait for each user request.">Wait</button>
-    </div>
-    <div class=seg id=scale>
-     <button class=fieldtip data-scale=linear title="Use a normal proportional token scale." data-tip="Use a normal proportional token scale.">Linear</button>
-     <button class=fieldtip data-scale=cumulative title="Show running estimated cost or token totals through each execution." data-tip="Show running estimated cost or token totals through each execution.">Cumulative</button>
-    </div>
-   </div>
-   <div class=chartwrap>
-    <svg class=chart id=iochart viewBox="0 0 1040 244" preserveAspectRatio=none></svg>
-    <div class="charttip chartTip" id=chart-tip></div>
-   </div>
-   <div class=legend id=chart-legend></div>
-  </div>
-  </section>
-  </div>
-  </div>
-  </details>
-  </div>
-
-	  <div class=foot>Local-only</div>
- </div>
-
- <div class="view on" id=view-session>
-  <div class=sessionBackRow id=session-back-row data-current-detail><button class="tbtn sessionBack" id=session-back type=button aria-label="Back to Current sessions"><span aria-hidden=true>←</span><span id=session-back-label>Current sessions</span></button></div>
-  <div class=banner id=banner data-current-detail>
-   <span class=msg id=banner-msg></span>
-   <span class=budgetadd id=budget-add-row>
-    <label>Add $<input id=budget-add type=number min=0.5 step=0.5 value=5></label>
-    <button class=tbtn id=budget-add-btn type=button>Add budget</button>
-   </span>
-  </div>
-  <div class="banner monthlyBudgetBanner" id=current-budget-warning role=status aria-live=polite data-current-detail>
-   <span class=msg id=current-budget-warning-msg></span>
-   <button class=tbtn id=current-budget-settings type=button>Open monthly budget</button>
-  </div>
-  <div class="spectrumPageHeadFrame hasPageActions" data-session-flow=unavailable>
-   <div class="previewHead spectrumPageHead sessionFlowHead" id=session-flow-head data-page-signal=sessions data-session-flow=unavailable>
-    <div class="previewHeadCopy spectrumPageHeadCopy">
-     <h1 id=session-page-title>Sessions</h1>
-     <p class=spectrumPageSubtitle id=current-description>Last 30 minutes</p>
-    </div>
-   </div>
-   <div class=spectrumPageActions><div class=sessionFlowStatus role=status aria-live=polite><i aria-hidden=true></i><span id=session-flow-label>Waiting for evidence</span></div></div>
-  </div>
-
-  <div class="tabs sessionScopeTabs" id=session-scope-tabs role=tablist aria-label="Sessions view">
-   <button class=tab id=session-scope-current type=button role=tab aria-selected=true aria-controls=current-sessions-overview data-session-scope=current><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h16M4 12h16M4 17h16"/><path d="M7 5v4M14 10v4M18 15v4"/></svg><span class=tabLabel>Current sessions</span></button>
-   <button class=tab id=session-scope-all type=button role=tab aria-selected=false aria-controls=all-session-history data-session-scope=all><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="4" y="4" width="16" height="16" rx="2"/><path d="M8 8h8M8 12h8M8 16h5"/></svg><span class=tabLabel>All sessions</span></button>
-   <button class=tab id=session-scope-compare type=button role=tab aria-selected=false aria-controls=session-compare data-session-scope=compare><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><rect x="3" y="5" width="7" height="14" rx="1.5"/><rect x="14" y="5" width="7" height="14" rx="1.5"/><path d="M6.5 9v6M17.5 12v3"/></svg><span class=tabLabel>Compare</span><span class=compareTabCount id=compare-tab-count hidden></span></button>
-   <button class=tab id=session-scope-subagents type=button role=tab aria-selected=false aria-controls=subagent-explorer data-session-scope=subagents><svg class=tabIcon viewBox="0 0 24 24" aria-hidden=true><path d="M12 4v5M5 12h14M5 12v6M12 12v6M19 12v6"/><circle cx="12" cy="3" r="1"/><circle cx="5" cy="19" r="1"/><circle cx="12" cy="19" r="1"/><circle cx="19" cy="19" r="1"/></svg><span class=tabLabel>Subagents</span></button>
-  </div>
-
-  <div class=previewSurface id=preview-surface-sessions>
-   <section class=currentDaySummary aria-label="Today's usage summary">
-    <div class=currentDayReadouts>
-     <div class=currentDayMetric><span class=currentDayMetricLabel>Spend today</span><strong class="currentDayMetricValue mono" id=current-day-spend>--</strong><small class=currentDayMetricNote id=current-day-spend-note></small></div>
-     <div class=currentDayMetric><span class=currentDayMetricLabel>Sessions today</span><strong class="currentDayMetricValue mono" id=current-day-sessions>--</strong><small class=currentDayMetricNote id=current-day-sessions-note></small></div>
-     <div class=currentDayMetric><span class=currentDayMetricLabel>Vs yesterday</span><strong class="currentDayMetricValue mono" id=current-day-vs-yesterday>--</strong><small class=currentDayMetricNote id=current-day-vs-yesterday-note></small></div>
-    </div>
-    <div class=currentDayActions><button class="tbtn currentDayMonth" id=current-month-spend type=button>View month spend</button><a class="tbtn currentDayLearn" href="https://www.splunk.com/en_us/products/tokenomics.html" target=_blank rel="noopener noreferrer" aria-label="Get Enterprise Tokenomics from Splunk (opens in a new tab)">Get Enterprise Tokenomics<svg class=currentDayLearnIcon viewBox="0 0 16 16" aria-hidden=true><path d="M8.5 3.5h4v4M12.5 3.5l-6 6"/><path d="M10.5 8.5v4h-7v-7h4"/></svg></a></div>
-   </section>
-   <section id=current-sessions-overview role=tabpanel aria-labelledby=session-scope-current>
-    <div class=currentSessionsHead>
-     <div class=currentSessionFilterGroups>
-      <div class=currentSessionFilterGroup id=current-session-runtime-filter-group hidden><span class=currentSessionFilterLabel>App</span><div class="seg currentSessionRuntimeFilters" id=current-session-runtime-filters role=group aria-label="Filter current sessions by runtime"></div></div>
-      <div class=currentSessionFilterGroup id=current-session-activity-filter-group hidden><span class=currentSessionFilterLabel>Status</span><div class="seg currentSessionActivityFilters" id=current-session-activity-filters role=group aria-label="Filter current sessions by activity"><button type=button data-current-activity-filter=all aria-pressed=true>All</button><button type=button data-current-activity-filter=working aria-pressed=false>Working</button><button type=button data-current-activity-filter=recent aria-pressed=false>Recent</button></div></div>
-     </div>
-     <span class=currentSessionsCount id=current-session-count-label>Waiting</span>
-    </div>
-    <div class=currentSessionGrid id=current-session-grid aria-label="Recent sessions. Drag cards or use Option and arrow keys to reorder."></div>
-    <div class=currentSessionOrderStatus id=current-session-order-status role=status aria-live=polite></div>
-   </section>
-   <section id=all-session-history role=tabpanel aria-labelledby=session-scope-all hidden>
-    <div class=allSessionsHead>
-     <h2 class=workSrOnly>All sessions</h2>
-     <span class=allSessionsHint id=g-hint>Recent activity</span>
-    </div>
-    <div class="globalControls logsToolbar">
-     <label class="filterControl logSearchControl"><span>Search</span><input class=searchbox id=g-search type=search placeholder="Title, project, or model"></label>
-     <label class=filterControl><span>App</span><select class=filterSelect id=g-app aria-label="App filter"><option value="">All apps</option></select></label>
-     <label class=filterControl><span>Projects</span><select class=filterSelect id=g-project aria-label="Projects filter"><option value="">All projects</option></select></label>
-     <label class=filterControl><span>Time range</span><select class=filterSelect id=g-time aria-label="Time range filter"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7d>7 days</option><option value=30d selected>30 days</option><option value=90d>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
-     <div class=logsToolbarRow>
-     <div class="filterControl filterSort filterChildren"><span>Subagent runs</span><div class="seg sortseg" id=g-children aria-label="Subagent run visibility">
-      <button type=button aria-pressed=true data-gchildren=hide class=on title="Hide subagent runs as rows. Their spend is still counted in totals and shown under each parent session.">Under parent</button>
-      <button type=button aria-pressed=false data-gchildren=show title="Also list subagent runs as their own rows.">As rows</button>
-     </div></div>
-     <div class=filterClear><button class="tbtn clearFilters" id=g-clear type=button title="Clear search, app, project, and time filters.">Clear filters</button></div>
-     <div class="filterControl filterSort"><span>Sort</span><div class="seg sortseg" id=g-sort>
-      <button data-gsort=recent title="Newest activity first.">Recent</button>
-      <button data-gsort=cost title="Highest cost first.">Cost</button>
-      <button data-gsort=tokens title="Most tokens first.">Tokens</button>
-      <button data-gsort=executions title="Most executions first.">Execs</button>
-      <button data-gsort=wait title="Most cumulative prompt-to-response wait first.">Wait</button>
-     </div></div>
-     </div>
-    </div>
-    <div class=logsToolbarStatus><div class=activeFilters id=g-active-filters hidden aria-live=polite></div><div class="globalMeta filterCount" id=g-count></div></div>
-    <div class=logsSummary id=logs-summary>
-     <div class=logKpis>
-      <div class="logStat metric"><div class=label>Filtered cost</div><div class="v mono" id=lf-cost>$0</div><div class=subline id=lf-cost-note></div></div>
-      <div class="logStat metric"><div class="label fieldtip" tabindex=0 aria-description="Fresh and cached input in the filtered sessions." data-tip="Fresh and cached input in the filtered sessions.">Input tokens</div><div class="v mono" id=lf-input>0</div></div>
-      <div class="logStat metric"><div class="label fieldtip" tabindex=0 aria-description="Trace-reported or clearly labeled locally estimated output in the filtered sessions." data-tip="Trace-reported or clearly labeled locally estimated output in the filtered sessions.">Output tokens</div><div class="v mono" id=lf-output>0</div></div>
-      <div class="logStat metric"><div class=label>Executions</div><div class="v mono" id=lf-executions>0</div><div class=subline id=lf-executions-note></div></div>
-      <div class="logStat metric waitStat"><div class="label fieldtip" tabindex=0 title="Cumulative prompt-to-completed-response wall-clock time in the filtered sessions." data-tip="Cumulative prompt-to-completed-response wall-clock time in the filtered sessions.">Wait time</div><div class="v mono" id=lf-wait>--</div><div class=subline id=lf-wait-note></div></div>
-     </div>
-     <details class=historyModels id=history-models>
-      <summary><span>By model</span><span class=logModelCount id=lf-model-count></span></summary>
-      <div class=logModelList id=lf-models></div>
-     </details>
-    </div>
-    <div class=slist id=slist></div>
-    <div class=compareTray id=compare-tray role=region aria-label="Sessions selected for comparison" hidden></div>
-   </section>
-   <section id=session-compare role=tabpanel aria-labelledby=session-scope-compare hidden>
-    <div class=allSessionsHead>
-     <div><h2>Compare sessions</h2><p>Up to four sessions side by side.</p></div>
-     <div class=compareHeadActions><button class=tbtn id=compare-pick type=button>Add from All sessions</button><button class="tbtn compareClear" id=compare-clear type=button>Clear</button></div>
-    </div>
-    <div id=compare-body aria-live=polite></div>
-   </section>
-   <section id=subagent-explorer role=tabpanel aria-labelledby=session-scope-subagents hidden>
-    <div class="card subagentCommand">
-     <div class=subagentViewTabs id=subagent-view-tabs role=tablist aria-label="Subagent workspace view">
-      <button id=subagent-tab-roles type=button role=tab data-subagent-view=roles aria-selected=true aria-controls=subagent-results-panel><span>Roles</span><small id=subagent-view-roles-count>--</small></button>
-      <button id=subagent-tab-sessions type=button role=tab data-subagent-view=sessions aria-selected=false aria-controls=subagent-results-panel><span>Sessions</span><small id=subagent-view-sessions-count>--</small></button>
-      <button id=subagent-tab-issues type=button role=tab data-subagent-view=issues aria-selected=false aria-controls=subagent-results-panel><span>Issues</span><small id=subagent-view-issues-count>--</small></button>
-     </div>
-     <div class=subagentFilterPrimary>
-      <label class="filterControl logSearchControl"><span>Search</span><input class=searchbox id=subagent-filter-search type=search placeholder="Role, nickname, model, or project"></label>
-      <label class=filterControl><span>App</span><select class=filterSelect id=subagent-filter-app><option value="">All apps</option></select></label>
-      <label class=filterControl><span>Project</span><select class=filterSelect id=subagent-filter-project><option value="">All projects</option></select></label>
-      <label class=filterControl><span>Time range</span><select class=filterSelect id=subagent-filter-time><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7d>7 days</option><option value=30d selected>30 days</option><option value=90d>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
-      <button class=subagentFilterMore id=subagent-filter-more type=button aria-expanded=false aria-controls=subagent-filter-advanced>More filters <span id=subagent-filter-more-count></span></button>
-     </div>
-     <div class=subagentFilterAdvanced id=subagent-filter-advanced hidden>
-      <label class=filterControl><span>Model</span><select class=filterSelect id=subagent-filter-model><option value="">All models</option></select></label>
-      <label class=filterControl><span>Status</span><select class=filterSelect id=subagent-filter-status><option value=all>All statuses</option><option value=working>Working</option><option value=incomplete>Incomplete</option><option value=complete>Complete</option><option value=waiting>Waiting</option><option value=recent>Recent</option><option value=unknown>Unknown</option></select></label>
-      <label class=filterControl><span>Signal</span><select class=filterSelect id=subagent-filter-signal><option value=all>All signals</option><option value=attention>Any cost/retry signal</option><option value=peer_cost_outlier>Peer cost outlier</option><option value=active_cost_concentration>Active cost concentration</option><option value=retry_pressure>Retry pressure</option></select></label>
-      <label class=filterControl><span>Sort</span><select class=filterSelect id=subagent-filter-sort><option value=recent>Recent</option><option value=cost>Cost</option><option value=tokens>Tokens</option><option value=work>Work time</option><option value=name>Agent name</option></select></label>
-     </div>
-     <div class=subagentFilterFooter id=subagent-filter-footer hidden>
-      <div class=subagentActiveFilters id=subagent-active-filters aria-live=polite></div>
-      <button class="tbtn clearFilters" id=subagent-filter-clear type=button>Clear all</button>
-     </div>
-    </div>
-    <div class=subagentCompactSummary id=subagent-compact-summary aria-live=polite></div>
-    <div class=subagentInventoryWarning id=subagent-inventory-warning hidden></div>
-    <div class=subagentCoverageNote id=subagent-coverage-note hidden></div>
-    <section class="card subagentModelDistribution" id=subagent-model-distribution aria-label="Model distribution of matching child runs" hidden></section>
-    <div class=subagentWorkspace id=subagent-workspace>
-     <section class="card subagentResultsCard" id=subagent-results-panel role=tabpanel aria-labelledby=subagent-tab-roles tabindex=0>
-      <div class=subagentResultsHead><div><h3 id=subagent-results-title>Role comparison</h3><p id=subagent-results-description>Provider-reported roles compared across the current filters.</p></div><span id=subagent-results-count></span></div>
-      <div class=subagentResults id=subagent-results></div>
-     </section>
-     <aside class="card subagentInspector" id=subagent-inspector aria-label="Agent inspector"></aside>
-    </div>
-   </section>
-  </div>
-
-  <div class=previewRunMeta data-current-detail>
-   <span class="badge app" id=preview-provider>source</span>
-   <span class=repo id=preview-project>--</span>
-   <span class=pill id=preview-model>--</span>
-   <span class=workTags id=preview-work-tags hidden></span>
-   <button class=sessionModelAssign id=session-model-identity-action type=button hidden>Add model</button>
-   <span class=spacer></span>
-   <a class="tbtn sessionDesktopLink" id=session-desktop-link hidden aria-label="Open this session in the Codex desktop app">Open in Codex</a>
-   <button class=sessionDelete id=session-delete type=button hidden>Delete session</button>
-  </div>
-  <section class="card previewStartStrip" data-current-detail>
-   <div class=previewStartLabel>Started with</div>
-   <div class=previewStartText id=preview-start>No user message captured.</div>
-  </section>
-  <div class="previewSurface on" id=preview-surface-run>
-  <div class=previewRunGrid>
-   <div class=previewChartColumn>
-    <div class=previewChartSlot id=preview-run-chart-slot></div>
-    <div class=previewTokenSlot id=preview-token-split-slot></div>
-   </div>
-   <aside class=previewDecision>
-    <div class=section-h><h2>Session cost</h2><span class=hint>estimate</span></div>
-    <section class="card previewStatus" id=preview-status-card>
-     <div class=previewStatusTop><span class=previewState id=preview-state>Live</span><span class="previewIdle mono" id=preview-idle>--</span></div>
-     <div class="previewCost mono" id=preview-cost>$0.00</div>
-     <div class=previewCostNote id=preview-cost-note>Waiting for live cost evidence.</div>
-     <div class=previewRunEfficiencySlot id=preview-run-efficiency-slot></div>
-     <div class=previewPressure>
-      <div class=previewPressureHead><span>Context pressure</span><b class=mono id=preview-context-pct>--</b></div>
-      <div class=previewPressureBar role=progressbar aria-label="Session context pressure" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0 id=preview-context-bar><i></i></div>
-     </div>
-     <div class=previewTimes>
-      <div><span>Started</span><b class=mono id=preview-started-at>--</b></div>
-      <div><span id=preview-last-label>Last activity</span><b class=mono id=preview-last-at>--</b></div>
-     </div>
-    </section>
-    <div class=previewRunBudgetSlot id=preview-run-budget-slot></div>
-   </aside>
-  </div>
-  <div class=previewKpis aria-label="Live run metrics">
-   <div class="card previewKpi metric previewSpeed"><div class="label fieldtip" tabindex=0 aria-description="Output tokens per second from timing evidence." data-tip="Output tokens per second from timing evidence.">Output speed</div><div class="v mono" id=preview-speed>--</div><div class=sm id=preview-speed-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Wall-clock time from each prompt to its completed response." data-tip="Wall-clock time from each prompt to its completed response.">Wait time</div><div class="v mono" id=preview-wait>--</div><div class=sm id=preview-wait-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Input/context tokens in the latest execution." data-tip="Input/context tokens in the latest execution.">Context in use</div><div class="v mono" id=preview-context>--</div><div class=sm id=preview-context-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Model turns in this session." data-tip="Model turns in this session.">Executions</div><div class="v mono" id=preview-executions>0</div><div class=sm id=preview-executions-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Tool calls observed in this session." data-tip="Tool calls observed in this session.">Tool calls</div><div class="v mono" id=preview-tools>0</div><div class=sm id=preview-tools-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated tokens of text returned by tools." data-tip="Estimated tokens of text returned by tools.">Tool-result tokens</div><div class="v mono" id=preview-tool-results>--</div><div class=sm id=preview-tool-results-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Share of input served from the prompt cache." data-tip="Share of input served from the prompt cache.">Cache rate</div><div class="v mono" id=preview-cache-rate>--</div><div class=sm id=preview-cache-rate-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated spend avoided by cache reads." data-tip="Estimated spend avoided by cache reads.">Cache saved</div><div class="v mono" id=preview-cache-saved>--</div><div class=sm id=preview-cache-saved-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated spend per minute while the run is active." data-tip="Estimated spend per minute while the run is active.">Burn / minute</div><div class="v mono" id=preview-burn>--</div><div class=sm id=preview-burn-note></div></div>
-   <div class="card previewKpi metric"><div class="label fieldtip" tabindex=0 aria-description="Estimated cost per accepted task." data-tip="Estimated cost per accepted task.">Cost / task</div><div class="v mono" id=preview-cost-task>--</div><div class=sm id=preview-cost-task-note></div></div>
-  </div>
-  <section class="card agentActivity" id=agent-activity aria-labelledby=agent-activity-title hidden>
-   <div class=agentActivityHead><div><h2 id=agent-activity-title>Agent activity</h2><p id=agent-activity-context></p></div><div class=agentCoverage id=agent-activity-coverage></div></div>
-   <div class=agentActivityMetrics id=agent-activity-metrics></div>
-   <div class=agentActivityTree id=agent-activity-tree role=tree aria-label="Agent activity hierarchy"></div>
-   <div class=agentAttentionDetail id=agent-attention-detail aria-live=polite></div>
-  </section>
-  <div class=foot>Local-only</div>
-  </div>
- </div>
-
-	 <div class=view id=view-subagents>
-	  <div class="spectrumPageHeadFrame hasPageActions">
-	   <div class="spectrumPageHead subagentPageHead" data-page-signal=subagents>
-	    <div class=spectrumPageHeadCopy><h1>Subagents</h1><p class=spectrumPageSubtitle>Track the cost of your custom agents.</p></div>
-	   </div>
-	   <div class=spectrumPageActions><span class=subagentExplorerMeta id=subagent-explorer-meta hidden></span></div>
-	  </div>
-	  <div id=subagent-page-home></div>
-	 </div>
-
-	 <div class=view id=view-models>
-	  <div class="spectrumPageHeadFrame hasPageActions">
-	   <div class="modelHead spectrumPageHead" data-page-signal=models>
-	    <div class=spectrumPageHeadCopy><h1>Models</h1></div>
-	   </div>
-	   <div class=spectrumPageActions><div class=modelControls>
-	    <label class=filterControl><span>Project</span><select class=filterSelect id=m-project aria-label="Model performance project filter"><option value="">All projects</option></select></label>
-	    <div class=filterControl><span>Models</span><details class=modelPicker id=m-model-picker><summary aria-label="Choose models to compare"><span id=m-model-summary>All models</span></summary><div class=modelPickerMenu id=m-model-options role=group aria-label="Models to compare"></div></details></div>
-	    <label class=filterControl><span>History</span><select class=filterSelect id=m-range aria-label="Models history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
-	   </div></div>
-	  </div>
-	  <div class=modelScopeStatus id=m-project-status aria-live=polite></div>
-	  <section class="card modelSpend" id=m-spend aria-labelledby=m-spend-title>
-   <div class=modelSpendHead><h2 id=m-spend-title>Where your spend goes</h2><span class=modelSpendTotal id=m-spend-total>--</span></div>
-   <div class=modelSpendBar id=m-spend-bar role=group aria-label="Estimated spend share by model"></div>
-   <div class=modelSpendLegend id=m-spend-legend></div>
-   <p class=modelSpendNote id=m-spend-note></p>
-  </section>
-  <div class="card modelTrendCard modelMixCard">
-   <div class=modelTrendHead><div><h2>Model mix over time</h2><p id=m-mix-note></p></div><div class=modelTrendControls><div class=seg id=m-mix-metric><button data-model-mix=cost>Cost</button><button data-model-mix=output>Output</button><button data-model-mix=executions>Executions</button></div></div></div>
-   <div class=modelChartWrap><svg class=modelChart id=m-mix viewBox="0 0 1040 250" preserveAspectRatio="none" role=img aria-label="Daily model mix"></svg><div class="modelChartTip chartTip" id=m-mix-tip tabindex=0 aria-label="Model mix for hovered day"></div></div>
-  </div>
-  <div class="card modelTrendCard modelSpeedCard" id=m-speedchart>
-   <div class=modelTrendHead><div><h2 class=fieldtip tabindex=0 aria-description="3-calendar-day weighted average of output tokens per second. By default, the top models by spend that have timing evidence." data-tip="3-calendar-day weighted average of output tokens per second. By default, the top models by spend that have timing evidence.">Speed over time</h2><p id=m-speedchart-note></p></div><div class=modelTrendControls><div class=filterControl><span>Models</span><details class=modelPicker id=m-speedchart-picker><summary aria-label="Choose models for the speed chart"><span id=m-speedchart-summary>Top 5 by spend</span></summary><div class=modelPickerMenu id=m-speedchart-options role=group aria-label="Models in the speed chart"></div></details></div><button class=tbtn id=m-speedchart-reset type=button>Reset to top 5</button></div></div>
-   <div class=modelSpeedLegend id=m-speedchart-legend></div>
-   <div class=modelChartWrap><svg class=modelChart id=m-speedchart-svg viewBox="0 0 1040 250" preserveAspectRatio="none" role=img aria-label="Smoothed daily output speed by model"></svg><div class="modelChartTip chartTip" id=m-speedchart-tip tabindex=0 aria-label="Model speed for hovered day"></div></div>
-  </div>
-  <div class="card pad modelTableWrap"><table class="tbl modelBoard" id=m-table><thead><tr><th class=modelRankCol>#</th><th><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=model data-tip="One model in one runtime. The same model can appear more than once when it ran through Claude Code, Claude Desktop, Claude-3P, Codex, or Cursor. Reasoning-effort variants are grouped under it; expand a row to see them. The log count covers all recorded history and does not change with the History filter." aria-description="One model in one runtime. The same model can appear more than once when it ran through Claude Code, Claude Desktop, Claude-3P, Codex, or Cursor. Reasoning-effort variants are grouped under it; expand a row to see them. The log count covers all recorded history and does not change with the History filter."><span>Model runtime</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=cost data-tip="Estimated cost in the selected window from local pricing. Bars are scaled to the top model; the percentage is its share of all estimated spend shown. * marks partial cost coverage." aria-description="Estimated cost in the selected window from local pricing. Bars are scaled to the top model; the percentage is its share of all estimated spend shown. * marks partial cost coverage."><span>Spend</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=cost_per_exec data-tip="Estimated cost divided by priced model executions in the window. * marks partial cost coverage." aria-description="Estimated cost divided by priced model executions in the window. * marks partial cost coverage."><span>$/exec</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=cache data-tip="Cache-read tokens divided by cache-covered input tokens. Higher usually means cheaper repeated context." aria-description="Cache-read tokens divided by cache-covered input tokens. Higher usually means cheaper repeated context."><span>Cache hit</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=executions data-tip="Trace-reported model response cycles in the selected history window. A single user turn can contain multiple model calls." aria-description="Trace-reported model response cycles in the selected history window. A single user turn can contain multiple model calls."><span>Executions</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=output data-tip="Trace-reported model output, or a Cursor estimate from model-authored text persisted in local bubbles; local token proxies are not comparable with trace-reported totals." aria-description="Trace-reported model output, or a Cursor estimate from model-authored text persisted in local bubbles; local token proxies are not comparable with trace-reported totals."><span>Output</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=speed data-tip="Average output speed in tokens per second: timed model output divided by timed generation seconds. Tool-free timing is preferred; otherwise end-to-end timing is used. Diagnostic, not a model verdict." aria-description="Average output speed in tokens per second: timed model output divided by timed generation seconds. Tool-free timing is preferred; otherwise end-to-end timing is used. Diagnostic, not a model verdict."><span>Speed</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=wait data-tip="Median prompt-to-completed-response wait. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded." aria-description="Median prompt-to-completed-response wait. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded."><span>Typical wait</span></button></th><th class=num><button class="modelSortBtn fieldtip modelHelp" type=button data-model-sort=pushback data-tip="Estimated from Work insights' local labels: how often your next prompt pushed back on this model's answer. Each request is credited to the model that answered it. Lower is better. * marks fewer than 20 labeled follow-ups." aria-description="Estimated from Work insights' local labels: how often your next prompt pushed back on this model's answer. Each request is credited to the model that answered it. Lower is better. * marks fewer than 20 labeled follow-ups."><span>Pushback</span></button></th></tr></thead><tbody></tbody></table></div>
-  <details class="card modelDiagnostics" id=m-diagnostics>
-   <summary><span>Speed &amp; timing diagnostics</span></summary>
-   <div class="modelHero modelDiagHero">
-	   <div class="card modelKpi metric"><div class="label fieldtip modelHelp" id=m-speed-label tabindex=0 aria-description="Observed model output divided by attributable timing. Tool-free samples are preferred, but Claude traces do not expose time to first token, so cross-runtime output pace remains diagnostic rather than a model verdict." data-tip="Observed model output divided by attributable timing. Tool-free samples are preferred, but Claude traces do not expose time to first token, so cross-runtime output pace remains diagnostic rather than a model verdict.">Observed output pace</div><div class="v mono" id=m-speed>--</div><div class=subline id=m-speed-note>waiting for timing evidence</div><div class="modelCoverage fieldtip" id=m-coverage tabindex=0 role=progressbar aria-label="Output timing coverage" aria-description="The share of selected output backed by attributable timing. Low coverage means observed tok/s may not represent the full history." aria-valuemin=0 aria-valuemax=100 aria-valuenow=0 data-tip="The share of selected output backed by attributable timing. Low coverage means observed tok/s may not represent the full history."><i id=m-coverage-bar></i></div></div>
-	   <div class="card modelKpi metric"><div class="label fieldtip modelHelp" id=m-change-label tabindex=0 aria-description="Pairwise end-to-end pace after matching completed turns on peak context, cumulative input, output, cache-read share, model calls, tool shape, and recency. A ratio above 1 favors the named faster runtime; a confidence interval crossing 1 means the evidence cannot separate them. Requires at least 20 matched pairs and 30% coverage of the smaller history." data-tip="Pairwise end-to-end pace after matching completed turns on peak context, cumulative input, output, cache-read share, model calls, tool shape, and recency. A ratio above 1 favors the named faster runtime; a confidence interval crossing 1 means the evidence cannot separate them. Requires at least 20 matched pairs and 30% coverage of the smaller history.">Matched pace</div><div class="v mono" id=m-change>--</div><div class="subline modelDelta" id=m-change-note>Select 2 models</div></div>
-	   <div class="card modelKpi metric"><div class="label fieldtip modelHelp" id=m-wait-label tabindex=0 aria-description="Median prompt-to-completed-response wait for timed requests. Lower is better. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded. The median is primary because the average can be pulled upward by a few very long turns." data-tip="Median prompt-to-completed-response wait for timed requests. Lower is better. Reasoning and tool use are included; trace-visible pauses waiting for human input are excluded. The median is primary because the average can be pulled upward by a few very long turns.">Typical wait</div><div class="v mono" id=m-wait>--</div><div class=subline id=m-wait-note>Timing unavailable</div></div>
-   </div>
-  <div class="modelTrendCard modelDiagTrend">
-	   <div class=modelTrendHead><div><h2 class=fieldtip id=m-trend-title tabindex=0 aria-description="In this chart, bars show output; lines show the selected metric, including observed tok/s for output pace." data-tip="In this chart, bars show output; lines show the selected metric, including observed tok/s for output pace.">Model trends</h2><p id=m-trend-note></p></div><div class=modelTrendControls><div class=seg id=m-metric><button data-model-metric=speed>Output pace</button><button data-model-metric=wait>Output wait</button><button data-model-metric=avg_input>Avg input</button><button data-model-metric=avg_output>Avg output</button></div></div></div>
-	   <div class=modelChartWrap><svg class=modelChart id=m-chart viewBox="0 0 1040 270" preserveAspectRatio="none" role=img aria-label="Daily model trends and output token volume"></svg><div class="modelChartTip chartTip" id=m-chart-tip tabindex=0 aria-label="Model details for hovered day"></div></div>
-	  </div>
-  </details>
-	 </div>
-
-	 <div class=view id=view-daily>
-	  <div class="spectrumPageHeadFrame hasPageActions">
-	   <div class="dailyHead spectrumPageHead" data-page-signal=spend>
-	    <div class=spectrumPageHeadCopy><h1>Spend</h1></div>
-	   </div>
-	   <div class=spectrumPageActions><div class=spendRangeControls>
-	    <label class=filterControl><span>History</span><select class=filterSelect id=s-range aria-label="Spend history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option><option value=custom>Custom</option></select></label>
-	    <div class=spendCustom id=s-custom hidden><label><span>From</span><input id=s-from type=date></label><label><span>To</span><input id=s-to type=date></label><span id=s-range-error role=status aria-live=polite></span></div>
-	   </div></div>
-	  </div>
-	  <section class=spendBudgetSection id=spend-budgets aria-label="Monthly budget">
-	  <div class=budgetDashboard>
-	   <section class="card budgetLead">
-	    <div class=budgetLeadTop>
-	     <div class=budgetLeadTitle><h2 class=fieldtip tabindex=0 aria-description="Set a budget for each runtime; Token Meter adds them for the current calendar month. Partial coverage is shown as at least spend." data-tip="Set a budget for each runtime; Token Meter adds them for the current calendar month. Partial coverage is shown as at least spend.">Monthly budget</h2><span class=budgetMonth id=budget-month>This month</span><span class=budgetMeta id=budget-spend-note></span></div>
-	     <div class=budgetLeadHeadActions><span class="agentAccessBadge chip" id=budget-state>Not configured</span><button class=tbtn id=budget-plan-jump type=button aria-expanded=false aria-controls=budget-config>Set budgets</button></div>
-	    </div>
-    <div class=discountCue id=discount-cue role=status hidden></div>
-	    <div class=budgetLeadBody>
-	     <div class=budgetSpend>
-	      <div class=budgetFigure>
-	       <span class="label fieldtip" tabindex=0 title="Observed or locally estimated cost in the current local calendar month." data-tip="Observed or locally estimated cost in the current local calendar month.">Spent this month</span>
-	       <div class=budgetFigureLine><span class=budgetQualifier id=budget-spend-qualifier hidden>At least</span><span class="budgetSpendValue mono" id=budget-spend>$0</span><span class=budgetOf><span class=fieldtip tabindex=0 title="The sum of the registered runtime budgets." data-tip="The sum of the registered runtime budgets.">of</span> <b class=mono id=budget-total>Not set</b></span><span class=budgetTotalNote id=budget-total-note></span></div>
-	      </div>
-	      <div class=budgetProgress id=budget-progress role=progressbar aria-label="Monthly budget used" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0><i></i><span class=budgetProgressMarkers id=budget-progress-markers aria-hidden=true></span></div>
-	      <div class=budgetMeterFoot><span id=budget-current-note>Waiting for spend data.</span><span class=budgetCoverage id=budget-coverage></span></div>
-	     </div>
-	     <dl class=budgetStats>
-	      <div><dt class=fieldtip tabindex=0 title="Budget minus observed spend. Partial coverage means this is not a guaranteed safe remainder." data-tip="Budget minus observed spend. Partial coverage means this is not a guaranteed safe remainder.">Remaining</dt><dd class=mono id=budget-remaining>--</dd><dd class=budgetStatNote id=budget-remaining-note></dd></div>
-	      <div><dt class=fieldtip tabindex=0 title="Straight-line projection based on elapsed calendar days, shown after at least three active spend days." data-tip="Straight-line projection based on elapsed calendar days, shown after at least three active spend days.">Projected month</dt><dd class=mono id=budget-projected>--</dd><dd class=budgetStatNote id=budget-projected-note></dd></div>
-	     </dl>
-	    </div>
-	   </section>
-	  </div>
-	  <div class=spendBudgetEditor>
-	    <section class="card pad budgetRuntimeCard budgetConfig" id=budget-config hidden>
-		     <form class="budgetForm budgetInlineForm" id=budget-form>
-		      <div class=budgetConfigHead>
-		       <div><h2 class=fieldtip tabindex=0 aria-description="Runtime budgets are added to calculate the monthly total." data-tip="Runtime budgets are added to calculate the monthly total.">Set budgets</h2><div class=subline id=budget-allocation-note></div></div>
-		       <div class=budgetAlertInline role=group aria-label="Monthly budget alerts">
-		        <span class=budgetAlertTitle>Alerts at</span>
-		        <div class=budgetThresholds aria-label="Alert thresholds">
-		         <label><input id=budget-input-threshold-early data-budget-threshold type=number min=1 max=100 step=1 value=80 required aria-label="Early alert threshold"><span aria-hidden=true>%</span></label>
-		         <label><input id=budget-input-threshold-mid data-budget-threshold type=number min=1 max=100 step=1 value=90 required aria-label="Mid alert threshold"><span aria-hidden=true>%</span></label>
-		         <label><input id=budget-input-threshold-full data-budget-threshold type=number min=1 max=100 step=1 value=100 required aria-label="Final alert threshold"><span aria-hidden=true>%</span></label>
-		        </div>
-		        <label class=budgetNotifySwitch title="Toggle monthly budget alerts"><input id=budget-input-notifications type=checkbox checked aria-label="Enable monthly budget alerts"><span class=sw aria-hidden=true></span></label>
-		       </div>
-		      </div>
-		      <fieldset class=budgetFormGroup>
-		       <legend>Session defaults</legend>
-		       <div class=budgetSessionDefault>
-		        <label><span>Default session budget (USD)</span><input id=budget-input-session-default type=number min=0.5 max=100000000 step=0.5 value=10 required></label>
-		       </div>
-		      </fieldset>
-	      <fieldset class="budgetFormGroup budgetRuntimeFields">
-	       <legend>Runtime budgets · current spend</legend>
-	       <div class=budgetRuntimeList id=budget-runtimes>
-	        <div class=budgetRuntimeHead aria-hidden=true><span>Runtime</span><span>Spent this month</span><span>Budget (USD)</span></div>
-	        <div class=budgetRuntime id=budget-runtime-claude data-runtime-id=claude>
-	         <span class=budgetRuntimeName>Claude</span>
-	         <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-claude>$0.00</b><small id=budget-runtime-share-claude>0% of spend</small></span>
-	         <span class=budgetRuntimeTrack id=budget-runtime-track-claude><i></i></span>
-	         <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-claude aria-label="Claude budget" type=number min=0 max=100000000 step=any value=0></label>
-	        </div>
-	        <div class=budgetRuntime id=budget-runtime-codex data-runtime-id=codex>
-	         <span class=budgetRuntimeName>Codex</span>
-	         <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-codex>$0.00</b><small id=budget-runtime-share-codex>0% of spend</small></span>
-	         <span class=budgetRuntimeTrack id=budget-runtime-track-codex><i></i></span>
-	         <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-codex aria-label="Codex budget" type=number min=0 max=100000000 step=any value=0></label>
-	        </div>
-	        <div class=budgetRuntime id=budget-runtime-cursor data-runtime-id=cursor>
-	         <span class=budgetRuntimeName>Cursor</span>
-	         <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-cursor>$0.00</b><small id=budget-runtime-share-cursor>0% of spend</small></span>
-	         <span class=budgetRuntimeTrack id=budget-runtime-track-cursor><i></i></span>
-           <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-cursor aria-label="Cursor budget" type=number min=0 max=100000000 step=any value=0></label>
-	       </div>
-	       <div class=budgetRuntime id=budget-runtime-opencode data-runtime-id=opencode>
-	        <span class=budgetRuntimeName>OpenCode</span>
-	        <span class=budgetRuntimeValue><b class=mono id=budget-runtime-spend-opencode>$0.00</b><small id=budget-runtime-share-opencode>0% of spend</small></span>
-	        <span class=budgetRuntimeTrack id=budget-runtime-track-opencode><i></i></span>
-	        <label class=budgetRuntimeInput><span>Budget</span><input id=budget-input-opencode aria-label="OpenCode budget" type=number min=0 max=100000000 step=any value=0></label>
-	       </div>
-	       </div>
-	      </fieldset>
-	      <div class=budgetActions><button class=tbtn id=budget-save type=submit>Save budgets</button><span class=settingsStatus id=budget-settings-status></span></div>
-	     </form>
-	    </section>
-    <section class="card pad budgetRuntimeCard discountCard settingsPricing" id=spend-discounts hidden aria-labelledby=discount-title>
-     <div class=budgetConfigHead><div><h2 id=discount-title class=fieldtip tabindex=0 aria-description="Spend and budgets use public list prices. Add the rate you actually pay and every cost is recalculated. Spend, budgets, and goals use your discount. Amounts a provider already billed are never discounted. Saved on this computer; updates and reinstalls keep your discounts." data-tip="Spend and budgets use public list prices. Add the rate you actually pay and every cost is recalculated. Spend, budgets, and goals use your discount. Amounts a provider already billed are never discounted. Saved on this computer; updates and reinstalls keep your discounts.">Discounts</h2></div><span class="agentAccessBadge chip" id=discount-badge>List prices</span></div>
-     <div class=modelPriceTabs id=discount-tabs role=tablist aria-label="Discounts by provider"></div>
-     <div class=modelPriceTableWrap><table class="tbl modelPriceTable"><thead><tr><th>Models from</th><th>Billed by</th><th class=num>Discount</th><th>From</th><th>Until</th><th>Note</th><th>Set by</th></tr></thead><tbody id=discount-rows></tbody></table></div>
-     <div class="modelPriceAdd discountAdd" id=discount-form role=group aria-label="Add a discount">
-      <label><span>Models from</span><select id=d-list><option value=anthropic>Anthropic</option><option value=openai>OpenAI</option><option value=cursor>Cursor</option><option value=kiro>Kiro</option><option value=opencode>OpenCode</option></select></label>
-      <label><span>Billed by</span><select id=d-channel><option value=direct>The provider</option><option value=bedrock>AWS Bedrock</option><option value=vertex>Google Vertex</option><option value=azure>Microsoft Azure</option><option value=any>Anyone</option></select></label>
-      <label><span>Discount %</span><input id=d-pct type=number min=0.01 max=99.99 step=0.01 placeholder=30></label>
-      <label><span>From <i class=hint>blank = all past usage</i></span><input id=d-start type=date></label>
-      <label><span>Until <i class=hint>blank = no end</i></span><input id=d-end type=date></label>
-      <label><span>Note</span><input id=d-note maxlength=60 placeholder="e.g. Company agreement"></label>
-      <button class=tbtn type=button id=d-add>Add discount</button>
-     </div>
-     <div class=modelPricingFooter><span class=settingsStatus id=discount-status></span><span class="settingsStatus warn" id=discount-invalid hidden></span></div>
-     <details class=discountMore>
-      <summary>How Claude apps are billed</summary>
-      <p>Claude Code and Claude Desktop don't record who bills them. Token Meter detects it; change it here if detection is wrong.</p>
-      <div class=discountApps>
-       <label><span>Claude Code</span><select id=d-claude-code data-runtime-channel=claude_code aria-label="Claude Code billed by"><option value=auto selected>Detect automatically</option><option value=direct>Anthropic</option><option value=bedrock>AWS Bedrock</option><option value=vertex>Google Vertex</option></select></label>
-       <label><span>Claude Desktop</span><select id=d-claude-desktop data-runtime-channel=claude_desktop aria-label="Claude Desktop billed by"><option value=auto selected>Detect automatically</option><option value=direct>Anthropic</option><option value=bedrock>AWS Bedrock</option><option value=vertex>Google Vertex</option></select></label>
-      </div>
-     </details>
-     <details class=discountMore>
-      <summary>Let other tools set discounts</summary>
-      <p>A tool on this computer, such as your company's contract or billing sync, can read and change discounts through Token Meter's local API at <code>/api/v1/cost-discounts</code>, using the token in <code>~/.token-meter/api-token</code>. Its changes appear in the table with the tool's name.</p>
-      <button class=tbtn type=button id=discount-rotate>Issue a new token</button>
-     </details>
-    </section>
-	  </div>
-   </section>
-	  <div class=spendKpis>
-	   <div class="card spendKpi metric"><div class=label>Selected-period spend</div><div class="v mono" id=s-total>--</div><div class=subline id=s-total-note></div></div>
-	   <div class="card spendKpi metric"><div class=label>Daily average</div><div class="v mono" id=s-average>--</div><div class=subline id=s-average-note></div></div>
-	   <div class="card spendKpi metric"><div class=label>Top platform</div><div class="v mono" id=s-top-runtime>--</div><div class=subline id=s-top-runtime-note></div></div>
-	   <div class="card spendKpi metric"><div class=label>Highest day</div><div class="v mono" id=s-highest-day>--</div><div class=subline id=s-highest-day-note></div></div>
-	  </div>
-	  <section class=goalsSection id=spend-goals aria-labelledby=spend-goals-heading><div class=goalsHead><h2 id=spend-goals-heading tabindex=-1>Spend goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=spend-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div></section>
-	  <section class="card spendChartCard">
-	   <div class=spendChartHead><div><h2>Spend trend</h2><p id=s-chart-note>Line = average</p></div><div class=spendChartControls><div class=seg id=s-granularity role=group aria-label="Group spend by"><button type=button class=on aria-pressed=true data-spend-granularity=day>Day</button><button type=button aria-pressed=false data-spend-granularity=week>Week</button><button type=button aria-pressed=false data-spend-granularity=month>Month</button></div><div class=spendLegend id=s-legend></div></div></div>
-	   <div class=spendChart id=s-chart aria-label="Spend trend"><div class="spendYAxis mono" id=s-y-axis aria-hidden=true></div><div class=spendPlot><div class=spendGrid aria-hidden=true></div><div class=spendChartInner id=s-chart-inner></div><div class=spendAverageLine id=s-average-line hidden aria-hidden=true><span class=mono></span></div></div></div>
-	   <div class="spendChartTip chartTip" id=s-chart-tip tabindex=0 hidden aria-live=polite></div>
-	  </section>
-	  <div class=spendEvidenceGrid>
-	   <section class="card spendLogsCard"><div class=spendPanelHead><div><h2>Highest-cost logs</h2><span id=s-log-day></span></div><span id=s-log-count></span></div><div class=spendLogs id=s-logs></div></section>
-	   <section class="card spendPlatformCard"><h2>Platform split</h2><div class=spendPlatformBody id=s-platforms></div></section>
-	  </div>
-	  <section class=spendInsightSection aria-labelledby=s-insight-title>
-	   <div class=spendInsightHead><div><h2 id=s-insight-title>Session economics</h2><p>Concentration, typical sessions, and outliers.</p></div><div class=spendInsightRange id=s-insights-range></div></div>
-	   <div class=spendInsightGrid>
-	    <section class="card spendConcentrationCard"><div class=spendInsightCardHead><div><h3>Spend concentration</h3><p>Top 10% of cost-covered sessions.</p></div></div><div class=spendConcentrationValue id=s-concentration>--</div><div class=spendConcentrationNote id=s-concentration-note>Loading range evidence…</div><div class=spendConcentrationBar id=s-concentration-bar role=progressbar aria-label="Share of spend from the top ten percent of sessions" aria-valuemin=0 aria-valuemax=100 aria-valuenow=0><i></i></div><div class=spendConcentrationLegend><span>Top decile</span><span>Remaining sessions</span></div><div class=spendImpactList id=s-concentration-sessions></div></section>
-	    <section class="card spendShapeCard"><div class=spendInsightCardHead><div><h3 class=fieldtip tabindex=0 aria-description="Period cost · other measures are full-session totals." data-tip="Period cost · other measures are full-session totals.">Session shape</h3></div></div><div class=spendShape id=s-shape><div class="spendShapeEmpty emptyState">Loading session distributions…</div></div></section>
-	   </div>
-	   <section class="card spendScatterCard" id=s-scatter><div class=spendInsightCardHead><div><h3>Cost and input by active time</h3></div><div class=spendScatterControls><span class=spendScatterCoverage id=s-scatter-coverage></span><div class=seg id=s-scatter-metric aria-label="Outlier map metric"><button data-scatter-metric=cost>Spend</button><button data-scatter-metric=input>Processed input</button></div></div></div><div class=spendScatterWrap><svg class=spendScatterSvg id=s-scatter-svg viewBox="0 0 1040 340" preserveAspectRatio=none role=img aria-label="Session spend by active time"></svg><div class="spendScatterTip chartTip" id=s-scatter-tip hidden></div></div><div class=spendScatterLegend><span><i></i>Session</span><span><i class=spendScatterTopDot></i>Top-decile spend</span><span id=s-scatter-missing hidden>Requires active-time and selected-metric evidence.</span></div></section>
-	  </section>
-	 </div>
-
-	 <div class=view id=view-efficiency>
-	  <div class="spectrumPageHeadFrame hasPageActions">
-	   <div class="efficiencyHead spectrumPageHead" data-page-signal=efficiency>
-	    <div class=spectrumPageHeadCopy><h1>Efficiency</h1></div>
-	   </div>
-	   <div class=spectrumPageActions><div class=modelControls>
-	    <label class=filterControl><span>Project</span><select class=filterSelect id=e-project aria-label="Efficiency project filter"><option value="">All projects</option></select></label>
-	    <div class=filterControl><span>Models</span><details class=modelPicker id=e-model-picker><summary aria-label="Choose models for efficiency"><span id=e-model-summary>All models</span></summary><div class=modelPickerMenu id=e-model-options role=group aria-label="Models for efficiency"></div></details></div>
-	    <label class=filterControl><span>History</span><select class=filterSelect id=e-range aria-label="Efficiency history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option></select></label>
-	   </div></div>
-	  </div>
-	  <div class=efficiencyHero aria-label="Mechanical efficiency">
-	   <section class="card efficiencyHeadline"><div class=efficiencyEyebrow>Output / $</div><div class="efficiencyValueRow valueWithDelta"><div class="v mono" id=e-output-dollar>--</div><div class=trendDelta id=e-output-dollar-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-output-dollar-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily output per covered dollar"></svg><div class="efficiencyChartTip chartTip" id=e-output-dollar-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-output-dollar-status aria-live=polite></span></div><div class=efficiencyCoverage id=e-output-dollar-coverage>Waiting for covered cost and output.</div></section>
-	   <section class="card efficiencyHeadline reasoning"><div class=efficiencyEyebrow>Reasoning ratio</div><div class="efficiencyValueRow valueWithDelta"><div class="v mono" id=e-reasoning-ratio>--</div><div class=trendDelta id=e-reasoning-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-reasoning-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily reasoning ratio"></svg><div class="efficiencyChartTip chartTip" id=e-reasoning-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-reasoning-status aria-live=polite></span></div><div class=efficiencyCoverage id=e-reasoning-coverage>Reasoning coverage unavailable.</div></section>
-	  </div>
-	  <div class=efficiencySupport>
-	   <section class="card efficiencySupportItem"><div class=label>Context load</div><div class="efficiencySupportValueRow valueWithDelta"><div class="v mono" id=e-context-load>--</div><div class=trendDelta id=e-context-load-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-context-load-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily context load"></svg><div class="efficiencyChartTip chartTip" id=e-context-load-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-context-load-status aria-live=polite></span></div><div class=subline id=e-context-load-note>input tokens per output token</div></section>
-	   <section class="card efficiencySupportItem"><div class=label>Cache hit ratio</div><div class="efficiencySupportValueRow valueWithDelta"><div class="v mono" id=e-cache-hit>--</div><div class=trendDelta id=e-cache-hit-change data-direction=""><strong>No comparable prior period</strong><span></span></div></div><div class=efficiencyChartWrap><svg class=efficiencyChart id=e-cache-hit-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="Daily cache hit ratio"></svg><div class="efficiencyChartTip chartTip" id=e-cache-hit-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=e-cache-hit-status aria-live=polite></span></div><div class=subline id=e-cache-hit-note>cache-read share of input</div></section>
-	  </div>
-	  <section class=goalsSection id=efficiency-goals aria-labelledby=goals-heading>
-	   <div id=goals-overview>
-	   <div class=goalsHead><h2 id=goals-heading tabindex=-1>Efficiency goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=efficiency-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div>
-	   </div>
-	   <div class=goalDetailView id=goal-detail aria-live=polite hidden></div>
-	  </section>
-	  <section class="card efficiencyModelCard">
-	   <div class=efficiencyModelHead><h2 class=fieldtip tabindex=0 aria-description="Statistics only · Compare similar work · no quality judgment." data-tip="Statistics only · Compare similar work · no quality judgment.">By model</h2><div class=efficiencyModelMeta id=e-model-meta></div></div>
-	   <div class=efficiencyTableWrap><table class=tbl id=e-model-table><thead><tr><th aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=model>Model<span class=efficiencySortMark aria-hidden=true></span></button></th><th>App</th><th>Reasoning effort</th><th class=num aria-sort=descending><button class=efficiencySort type=button data-efficiency-sort=cost>Spend<span class=efficiencySortMark aria-hidden=true>↓</span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=output_per_dollar>Output / $<span class=efficiencySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=reasoning_ratio>Reasoning<span class=efficiencySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=context_load>Context load<span class=efficiencySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=efficiencySort type=button data-efficiency-sort=cache_hit_ratio>Cache hit<span class=efficiencySortMark aria-hidden=true></span></button></th></tr></thead><tbody></tbody></table></div>
-		  </section>
-	 </div>
-	 <div class=view id=view-work>
-	  <div class="spectrumPageHeadFrame hasPageActions">
-	   <div class="efficiencyHead spectrumPageHead" data-page-signal=work>
-	    <div class=spectrumPageHeadCopy><h1>Work</h1><p class=spectrumPageSubtitle>What the spend went into.</p></div>
-	   </div>
-	   <div class=spectrumPageActions><div class=modelControls>
-	    <label class=filterControl><span>Project</span><select class=filterSelect id=w-project aria-label="Work project filter"><option value="">All projects</option></select></label>
-	    <label class=filterControl><span>App</span><select class=filterSelect id=w-runtime aria-label="Work app filter"><option value="">All apps</option></select></label>
-	    <label class=filterControl><span>History</span><select class=filterSelect id=w-months aria-label="Work history range"><option value=1d>1 day</option><option value=7d>1 week</option><option value=30d>1 month</option><option value=month>Month</option><option value=3>3 months</option><option value=6 selected>6 months</option><option value=12>12 months</option><option value=0>All history</option></select></label>
-	   </div></div>
-	  </div>
-	  <section class="card workStatus" id=w-status aria-live=polite>
-	   <div class=workStatusMain><span class=workStatusPill id=w-state data-state=disabled>Off</span><div class=workStatusText><strong id=w-status-title>Work insights are off</strong><span id=w-status-detail>Turn on local classification in Settings to label sessions.</span><ol class=workSetupSteps id=w-setup-steps hidden aria-label="Setup steps"><li data-step=ollama>Ollama</li><li data-step=model>Download the model</li><li data-step=prepare>Prepare</li><li data-step=label>Label</li></ol><div class=workSetupBar id=w-setup-bar hidden role=progressbar aria-label="Setup progress" aria-valuemin=0 aria-valuemax=100><i></i></div></div></div>
-	   <div class=workStatusActions>
-	    <label class=workPause hidden id=w-pause-wrap><span class=workSrOnly>Pause work insights</span><select class=filterSelect id=w-pause aria-label="Pause work insights"><option value="">Pause…</option><option value=1h>Pause for 1 hour</option><option value=tomorrow>Pause until tomorrow</option><option value=indefinite>Pause until resumed</option></select></label>
-	    <button class=tbtn id=w-resume type=button hidden>Resume</button>
-    <button class=tbtn id=w-setup-retry type=button hidden>Retry setup</button>
-	    <button class="tbtn go" id=w-turn-on type=button hidden>Turn on Work insights</button>
-    <button class=tbtn id=w-open-settings type=button>Settings</button>
-	   </div>
-	  </section>
-  <section class="card emptyState workProgressNote" id=w-progress-note hidden><strong id=w-progress-title></strong><p id=w-progress-detail></p></section>
-  <section class="card workSizing" id=w-module-sizing>
-   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Spend by request complexity, split by model tier and reasoning effort. Savings are estimates." data-tip="Spend by request complexity, split by model tier and reasoning effort. Savings are estimates.">Right-sizing</h2><div class=subline>Savings · est.</div></div></div>
-   <div class=workSuggestCards id=w-suggest-cards></div>
-   <div class=workEffortModels id=w-effort-models aria-labelledby=w-effort-models-title>
-    <div class=workSubhead><h3 id=w-effort-models-title>Pushback by reasoning effort</h3><label class=filterControl><span>Model</span><select class=filterSelect id=w-effort-model aria-label="Model for pushback by reasoning effort"></select></label></div>
-    <div class=workEffortGrid id=w-effort-grid role=table aria-label="Pushback by complexity and reasoning effort"></div>
-    <p class=workEffortDetail id=w-effort-detail aria-hidden=true></p>
-    <ul class=workEffortVerdicts id=w-effort-verdicts></ul>
-    <p class=workEffortNote id=w-effort-note></p>
-   </div>
-   <details class=workTableToggle id=w-sizing-tables><summary>View as tables</summary>
-    <div class=workTableWrap><table class=workIssues id=w-opportunities></table></div>
-    <div class="workSplit workMixSplit">
-     <div><div class=workSubhead><h3>Model tier</h3><span>share of spend</span></div><div class=workMix id=w-tier-mix></div></div>
-     <div><div class=workSubhead><h3>Reasoning effort</h3><span>share of spend</span></div><div class=workMix id=w-effort-mix></div></div>
-    </div>
-    <div class=workSizingGrid id=w-sizing role=table aria-label="Right-sizing grid"></div>
-    <div class=workTableWrap><table class=tbl id=w-effort-table></table></div>
-   </details>
-  </section>
-	  <section class=goalsSection id=work-goals aria-labelledby=work-goals-heading><div class=goalsHead><h2 id=work-goals-heading tabindex=-1>Work goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=work-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div></section>
-	  <section class="card workBreakdown" id=w-module-breakdown>
-	   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="One row per kind of work. Spend is each request's share of its session's cost. Task outcomes count tasks with a labeled follow-up: accepted, recovered after pushback, ended on pushback, or unclear. Agent : human is model calls (agent turns) per message you typed (human turn). Pushback is how often your next message pushed back. Best and worst model have the least and most pushback among models with 20 or more labeled follow-ups and 3 sessions. Labels are local-model estimates. Select a heading to sort, a row to open its sessions." data-tip="One row per kind of work. Spend is each request's share of its session's cost. Task outcomes count tasks with a labeled follow-up: accepted, recovered after pushback, ended on pushback, or unclear. Agent : human is model calls (agent turns) per message you typed (human turn). Pushback is how often your next message pushed back. Best and worst model have the least and most pushback among models with 20 or more labeled follow-ups and 3 sessions. Labels are local-model estimates. Select a heading to sort, a row to open its sessions.">Work breakdown</h2><div class=subline id=w-breakdown-note></div></div>
-	    <label class=filterControl><span>Model</span><select class=filterSelect id=w-breakdown-model aria-label="Work breakdown model"><option value="">All models</option></select></label></div>
-	   <div class=workTableWrap><table class="tbl workBreakdownTable" id=w-breakdown-table></table></div>
-	   <div class=workFootnote id=w-breakdown-foot></div>
-	  </section>
-	  <section class="card workRhythm" id=w-module-rhythm>
-	   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="When sessions started in this period, in this Mac's local time, and how often follow-ups pushed back at each time of day." data-tip="When sessions started in this period, in this Mac's local time, and how often follow-ups pushed back at each time of day.">When you work</h2><div class=subline id=w-rhythm-note></div></div></div>
-	   <div class=workSplit>
-	    <div><div class=workSubhead><h3>Session starts</h3><span>local time</span></div><div class=workHeat id=w-heat role=img aria-label="Session starts by weekday and hour"></div></div>
-	    <div><div class=workSubhead><h3>Pushback by time of day</h3><span>share of follow-ups</span></div><div class=workBandList id=w-bands></div><div class=workFootnote id=w-band-note></div></div>
-	   </div>
-	  </section>
-	  <div class=workTrendPair>
-	  <section class="card workRework" id=w-module-rework>
-	    <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Share of labeled follow-up turns where you pushed back on the previous work, per week (per day for short ranges). Hollow points have fewer than 20 labeled turns." data-tip="Share of labeled follow-up turns where you pushed back on the previous work, per week (per day for short ranges). Hollow points have fewer than 20 labeled turns.">Pushback over time</h2><div class=subline id=w-rework-note></div></div>
-	     <label class=filterControl><span>Model</span><select class=filterSelect id=w-rework-model aria-label="Pushback trend model"><option value="">All models</option></select></label></div>
-	    <div class=workTrendWrap><svg class=workTrend id=w-rework-trend viewBox="0 0 560 330" role=img aria-label="Pushback rate over time"></svg></div>
-	  </section>
-	   <section class="card workRework" id=w-module-agent-trend>
-	    <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Agent turns (model calls) per human turn (message you typed), per week (per day for short ranges). Only apps that split model calls by request count. Hollow points have fewer than 20 human turns. Not a score." data-tip="Agent turns (model calls) per human turn (message you typed), per week (per day for short ranges). Only apps that split model calls by request count. Hollow points have fewer than 20 human turns. Not a score.">Agent : human over time</h2><div class=subline id=w-agent-note></div></div>
-	     <label class=filterControl><span>Model</span><select class=filterSelect id=w-agent-model aria-label="Agent : human trend model"><option value="">All models</option></select></label></div>
-	    <div class=workTrendWrap><svg class=workTrend id=w-agent-trend viewBox="0 0 560 260" role=img aria-label="Agent turns per human turn over time"></svg></div>
-	   </section>
-	  </div>
-	  <section class="card workFit" id=w-module-fit>
-   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Faded pushback meters have fewer than 20 labeled follow-up turns." data-tip="Faded pushback meters have fewer than 20 labeled follow-up turns.">Model choices</h2><div class=subline>Top models by spend</div></div></div>
-   <div class=workTableWrap><table class=workScore id=w-scorecard></table></div>
-   <details class=workTableToggle><summary>By kind of work</summary><div class=workTableWrap><table class=tbl id=w-fit-table></table></div></details>
-  </section>
-	  <section class="card workTagsCard" id=w-module-tags>
-	   <div class=workCardHead><div><h2 class=fieldtip tabindex=0 aria-description="Tags are worked out from each session's cost, active time, subagents, labels, and how it ended. A session can have several. Select a tag to open its sessions." data-tip="Tags are worked out from each session's cost, active time, subagents, labels, and how it ended. A session can have several. Select a tag to open its sessions.">Session tags</h2><div class=subline id=w-tags-note></div></div></div>
-	   <div class=workTagGrid id=w-tags></div>
-	  </section>
-  <div class=efficiencyEvidence><span class=fieldtip tabindex=0 aria-description="Sessions started in this period. Session text goes only to Ollama on this machine; Token Meter stores only labels and counts. Select any bar or row to open its sessions." data-tip="Sessions started in this period. Session text goes only to Ollama on this machine; Token Meter stores only labels and counts. Select any bar or row to open its sessions.">Labels are local estimates · text goes only to local Ollama</span></div>
-	 </div>
-	 <div class=view id=view-git>
-	  <div class="spectrumPageHeadFrame hasPageActions">
-	   <div class="efficiencyHead spectrumPageHead" data-page-signal=git>
-	    <div class=spectrumPageHeadCopy><h1>Git</h1><p class=spectrumPageSubtitle>Pushed code &times; covered spend &middot; <span class=fieldtip id=d-caveat tabindex=0 aria-description="Local Git only: hashed keys and line counts, never filenames or messages. Spend is estimated. Few lines make ratios noisy. Not a quality score." data-tip="Local Git only: hashed keys and line counts, never filenames or messages. Spend is estimated. Few lines make ratios noisy. Not a quality score.">local Git only</span></p></div>
-	   </div>
-	   <div class=spectrumPageActions><div class="modelControls deliveryControls">
-	    <label class=filterControl><span>Project</span><select class=filterSelect id=d-project aria-label="Git project filter"><option value="">All projects</option></select></label>
-	    <label class=filterControl><span>History</span><select class=filterSelect id=d-range aria-label="Git history range"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option></select></label>
-	   </div></div>
-	  </div>
-	  <section class="card deliveryOverview" aria-label="Git overview">
-	   <div class=deliveryOverviewHead>
-	    <div><div class=deliveryEyebrow><span id=d-period-label>7 days</span></div><h2 id=d-comparison>No comparable prior period</h2></div>
-	    <button class="deliveryCoverageState partial" id=d-coverage type=button aria-live=polite aria-expanded=false aria-controls=d-evidence-panel>Scanning local Git</button>
-	   </div>
-	   <div class=deliveryMetricGrid>
-	    <div class=deliveryMetric><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Text lines added plus deleted in successful pushes. Binary files excluded." data-tip="Text lines added plus deleted in successful pushes. Binary files excluded.">Pushed lines</div><div class=valueWithDelta><div class=deliveryMetricValue id=d-code-pushed>--</div><div class=trendDelta id=d-code-pushed-change data-direction="" hidden><strong>No comparable prior period</strong><span></span></div></div><div class=deliveryMetricMeta><b id=d-added>--</b> added <span aria-hidden=true>&middot;</span> <b id=d-deleted>--</b> deleted</div></div>
-	    <div class=deliveryMetric><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Covered spend per 1,000 pushed lines, same projects and period." data-tip="Covered spend per 1,000 pushed lines, same projects and period.">Spend / 1K</div><div class=valueWithDelta><div class=deliveryMetricValue id=d-spend-lines>--</div><div class=trendDelta id=d-spend-lines-change data-direction="" hidden><strong>No comparable prior period</strong><span></span></div></div><div class=deliveryMetricMeta id=d-spend-note>Waiting for coverage.</div></div>
-	    <div class=deliveryMetric><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Pushed lines per 1K covered output tokens, same projects and period. Output includes reasoning where reported." data-tip="Pushed lines per 1K covered output tokens, same projects and period. Output includes reasoning where reported.">Push yield</div><div class=valueWithDelta><div class=deliveryMetricValue id=d-push-yield>--</div><div class=trendDelta id=d-push-yield-change data-direction="" hidden><strong>No comparable prior period</strong><span></span></div></div><div class=deliveryMetricMeta id=d-push-yield-note>Waiting for output tokens.</div></div>
-    <div class="deliveryMetric deliveryCoverageMetric"><div class=deliveryMetricTop><div class="deliveryMetricLabel fieldtip" tabindex=0 aria-description="Share of spend from projects with both cost and Git evidence." data-tip="Share of spend from projects with both cost and Git evidence.">Spend coverage</div><strong id=d-coverage-percent>--</strong></div><div class=deliveryCoverageBar id=d-coverage-bar role=progressbar aria-label="Share of selected-period spend with comparable Git evidence" aria-valuemin=0 aria-valuemax=100 aria-valuetext="Spend coverage unavailable"><i aria-hidden=true></i></div></div>
-	   </div>
-	   <div class=deliveryEvidenceStrip aria-label="Git evidence details">
-	    <div class=deliveryEvidenceItem><span>Push days</span><strong id=d-active-days>--</strong></div>
-	    <div class=deliveryEvidenceItem><span class="fieldtip" tabindex=0 aria-description="Your non-merge commits in successful pushes." data-tip="Your non-merge commits in successful pushes.">Commits</span><strong id=d-commits>--</strong></div>
-	    <div class=deliveryEvidenceItem><span>Repositories</span><strong id=d-repo-evidence>--</strong></div>
-	    <div class=deliveryEvidenceItem><span>Comparable</span><strong id=d-comparable-evidence>--</strong></div>
-	    <div class=deliveryEvidenceItem><span class="fieldtip" tabindex=0 aria-description="Deleted share of pushed lines. Deletions are normal editing, not defects." data-tip="Deleted share of pushed lines. Deletions are normal editing, not defects.">Deleted share</span><strong id=d-rework>--</strong></div>
-	   </div>
-	  </section>
-	  <section class="card deliveryEvidencePanel" id=d-evidence-panel hidden aria-labelledby=d-evidence-title>
-   <div class=deliveryEvidenceHead><div><h2 class=fieldtip id=d-evidence-title tabindex=0 aria-description="Period-specific spend and Git coverage; unavailable is not zero." data-tip="Period-specific spend and Git coverage; unavailable is not zero.">Evidence coverage</h2></div><button class=deliveryEvidenceClose id=d-evidence-close type=button aria-label="Close evidence coverage">&times;</button></div>
-   <div class=deliveryEvidenceSummary><strong id=d-evidence-spend>--</strong><span>of spend has Git evidence</span></div>
-	   <div class=deliveryEvidenceChoices>
-	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=comparable><span>Comparable</span><strong id=d-evidence-count-comparable>--</strong></button>
-	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=spend_only><span>Spend only</span><strong id=d-evidence-count-spend>--</strong></button>
-	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=git_only><span>Git only</span><strong id=d-evidence-count-git>--</strong></button>
-	    <button class=deliveryEvidenceChoice type=button data-delivery-evidence-filter=unavailable><span>No period evidence</span><strong id=d-evidence-count-unavailable>--</strong></button>
-	   </div>
-	   <div class=deliveryEvidenceMeta><span class="fieldtip" id=d-evidence-ratio tabindex=0 aria-description="Ratios require overlapping spend and Git evidence." data-tip="Ratios require overlapping spend and Git evidence.">Waiting for overlap</span><span id=d-evidence-freshness>Git scan pending.</span></div>
-	  </section>
-	  <section class=goalsSection id=git-goals aria-labelledby=git-goals-heading><div class=goalsHead><h2 id=git-goals-heading tabindex=-1>Delivery goals</h2><div class=goalActions><button class=tbtn type=button data-goals-toggle>Previous goals</button><button class=tbtn type=button data-goal-new=git-goals>New goal</button></div></div><div class=goalsNotice role=status aria-live=polite hidden></div><div class=goalsList data-goals-current></div><div class=goalsList data-goals-previous hidden></div></section>
-	  <section class="card deliveryVisual">
-	   <div class=deliveryVisualHead><div><h2 class=fieldtip tabindex=0 aria-description="Added + deleted text lines per day. Select a day for spend." data-tip="Added + deleted text lines per day. Select a day for spend.">Code pushed by day</h2></div><div class=deliveryLegend aria-label="Git chart legend"><span><i></i>Added</span><span><i class=deleted></i>Deleted</span></div></div>
-	   <div class=deliveryMobileScrollHint aria-hidden=true>Swipe or scroll to explore &rarr;</div>
-	   <div class=deliveryChartViewport><div class=deliveryChartWrap id=d-chart-wrap><svg class=deliveryChart id=d-daily-chart viewBox="0 0 1040 310" preserveAspectRatio=none role=img aria-label="Daily pushed text lines"></svg><div class=deliveryHitGrid id=d-chart-hits aria-label="Daily Git values"></div><div class="deliveryChartTip chartTip" id=d-chart-tip role=tooltip hidden></div></div></div>
-	   <div class=deliveryDayInspector id=d-day-inspector hidden aria-live=polite><div class=deliveryDayIdentity><span>Selected day</span><strong id=d-day-title>--</strong><small id=d-day-note></small></div><div class=deliveryDayMetrics id=d-day-metrics></div><div class=deliveryDayActions><button id=d-day-prev type=button>&larr; Previous</button><button id=d-day-next type=button>Next &rarr;</button><button class=deliveryDayClose id=d-day-close type=button aria-label="Close selected day">&times;</button></div></div>
-	  </section>
-	  <section class=deliveryInsightSection aria-labelledby=d-insight-title>
-	   <div class=deliveryInsightHead><div><h2 class=fieldtip id=d-insight-title tabindex=0 aria-description="Conversion, typical days, and outliers. Statistics only · no quality judgment." data-tip="Conversion, typical days, and outliers. Statistics only · no quality judgment.">Delivery economics</h2></div></div>
-	   <div class=deliveryInsightGrid>
-    <section class="card deliverySignalCard"><div class=deliveryInsightCardHead><div><h3 class=fieldtip tabindex=0 aria-description="Ranked local Git and covered-spend observations." data-tip="Ranked local Git and covered-spend observations.">Signals</h3></div></div><div class=deliverySignalList id=d-signals aria-live=polite><div class="deliverySignalEmpty emptyState">Reading local Git evidence&hellip;</div></div></section>
-    <section class="card deliveryShapeCard"><div class=deliveryInsightCardHead><div><h3 class=fieldtip tabindex=0 aria-description="Median, range, and high day · ratios require 50+ pushed lines." data-tip="Median, range, and high day · ratios require 50+ pushed lines.">Daily shape</h3></div></div><div class=deliveryShape id=d-shape><div class="deliveryShapeEmpty emptyState">Reading daily distributions&hellip;</div></div></section>
-	   </div>
-	  </section>
-	  <section class="card deliveryModels" aria-labelledby=d-model-title>
-	   <div class=deliveryProjectHead><h2 class=fieldtip id=d-model-title tabindex=0 aria-description="Estimate. Each project&rsquo;s pushed lines are split by each model&rsquo;s share of its covered spend." data-tip="Estimate. Each project&rsquo;s pushed lines are split by each model&rsquo;s share of its covered spend.">Code by model</h2><div class=deliveryModelNote id=d-model-note></div></div>
-	   <div class=deliveryTableWrap><table class=tbl id=d-model-table><thead><tr><th aria-sort=none><button class=deliverySort type=button data-delivery-model-sort=model>Model<span class=deliverySortMark aria-hidden=true></span></button></th><th>App</th><th>Effort</th><th class=num aria-sort=descending><button class="deliverySort fieldtip" type=button data-delivery-model-sort=covered_cost data-tip="Covered spend: estimated spend from sessions with cost evidence in these projects." aria-description="Covered spend: estimated spend from sessions with cost evidence in these projects.">Spend<span class=deliverySortMark aria-hidden=true>&darr;</span></button></th><th class=num aria-sort=none><button class=deliverySort type=button data-delivery-model-sort=attributed_lines>Est. lines<span class=deliverySortMark aria-hidden=true></span></button></th></tr></thead><tbody></tbody></table></div>
-		  </section>
-	  <section class="card deliveryProjects">
-	   <div class=deliveryProjectHead><h2>Projects</h2><div class=deliveryProjectControls><label class=deliveryEvidenceFilter><span>Evidence</span><select class=filterSelect id=d-evidence-filter aria-label="Filter Git projects by evidence"><option value=all>All projects</option><option value=comparable>Comparable</option><option value=spend_only>Spend only</option><option value=git_only>Git only</option><option value=unavailable>No period evidence</option></select></label><label class=deliveryMobileSort><span>Sort</span><select class=filterSelect id=d-mobile-sort aria-label="Sort Git projects"><option value=covered_cost:desc>Spend high–low</option><option value=covered_cost:asc>Spend low–high</option><option value=changed_lines:desc>Lines high–low</option><option value=changed_lines:asc>Lines low–high</option><option value=spend_per_1k:asc>Spend / 1K low–high</option><option value=spend_per_1k:desc>Spend / 1K high–low</option><option value=project:asc>Project A–Z</option><option value=project:desc>Project Z–A</option></select></label></div></div>
-	   <div class=deliveryTableWrap><table class=tbl id=d-project-table><thead><tr><th aria-sort=none><button class=deliverySort type=button data-delivery-sort=project>Project<span class=deliverySortMark aria-hidden=true></span></button></th><th class=num aria-sort=descending><button class="deliverySort fieldtip" type=button data-delivery-sort=covered_cost data-tip="Covered spend: estimated spend from sessions with cost evidence in these projects." aria-description="Covered spend: estimated spend from sessions with cost evidence in these projects.">Spend<span class=deliverySortMark aria-hidden=true>&darr;</span></button></th><th class=num aria-sort=none><button class=deliverySort type=button data-delivery-sort=changed_lines>Pushed lines<span class=deliverySortMark aria-hidden=true></span></button></th><th class=num aria-sort=none><button class=deliverySort type=button data-delivery-sort=spend_per_1k>Spend / 1K<span class=deliverySortMark aria-hidden=true></span></button></th></tr></thead><tbody></tbody></table></div>
-		  </section>
-	 </div>
-
-	 <div class=view id=view-learn>
-  <div class="spectrumPageHeadFrame hasPageActions"><div class="learnHead spectrumPageHead" data-page-signal=learn><div class=spectrumPageHeadCopy><h1>Learn</h1><p class=spectrumPageSubtitle>Spend tokens like money. Measure what you get back.</p></div></div><div class=spectrumPageActions><button class=tbtn id=learn-play type=button>Play as full screen</button></div></div>
-  <div class="deck deckInline" id=learn-deck data-deck-host=learn></div>
-	 </div>
-
-	 <div class=view id=view-capabilities>
-  <div class=spectrumPageHeadFrame>
-   <header class="capPageHead spectrumPageHead" data-page-signal=capabilities>
-    <div class=spectrumPageHeadCopy><h1>Tools</h1><p class=spectrumPageSubtitle>Tools, MCP servers, and skills.</p></div>
-   </header>
-  </div>
-  <section class="card capStats" aria-label="Capability overview">
-   <button class=capStat type=button data-cap-jump=tool aria-label="Show Tools in the capability inventory"><span class=capStatLabel>Tools</span><strong id=c-stat-tools>&mdash;</strong><span class=capStatDetail id=c-stat-tools-detail>Waiting for evidence</span></button>
-   <button class=capStat type=button data-cap-jump=mcp aria-label="Show MCP servers in the capability inventory"><span class=capStatLabel>MCP servers</span><strong id=c-stat-mcps>&mdash;</strong><span class=capStatDetail id=c-stat-mcps-detail>Waiting for evidence</span></button>
-   <button class=capStat type=button data-cap-jump=skill aria-label="Show Skills in the capability inventory"><span class=capStatLabel>Skills</span><strong id=c-stat-skills>&mdash;</strong><span class=capStatDetail id=c-stat-skills-detail>Waiting for evidence</span></button>
-  </section>
-  <section class="card capReviewQueue" id=c-review-queue aria-labelledby=c-review-title>
-   <div class=capQueueHead>
-    <div><h2 id=c-review-title>Checking review candidates</h2><div class=capQueueDetail id=c-review-detail></div></div>
-    <span class=capQueueCount id=c-review-count>Waiting for evidence</span>
-   </div>
-   <div class=capReviewList id=c-review-list aria-live=polite><div class=capQueueLoading>Reading local capability evidence&hellip;</div></div>
-   <div class=capSelectionBar id=c-selection-bar hidden><span id=c-selection-count>0 selected</span><button class=tbtn id=c-clear-selection type=button>Clear selection</button><button class="tbtn danger" id=c-disable-selected type=button disabled>Disable selected&hellip;</button></div>
-  </section>
-  <section class="card capInventory" id=c-inventory aria-labelledby=c-inventory-title>
-   <div class=capInventoryHead><span class=capInventorySummary><h2 id=c-inventory-title tabindex=-1>All capabilities</h2></span><span class=capInventoryCount id=c-inventory-count>Waiting for inventory</span></div>
-   <div class=capInventoryBody>
-    <section class=capCatalog aria-label="Prompt-load evidence">
-     <div class=capCatalogHead><span><b class=fieldtip tabindex=0 title="Useful eager: schema loaded up front and called. Unused eager: schema loaded up front but not called. Deferred: schema kept out of the initial prompt. Default and read-only entries remain included as evidence." data-tip="Useful eager: schema loaded up front and called. Unused eager: schema loaded up front but not called. Deferred: schema kept out of the initial prompt. Default and read-only entries remain included as evidence.">Prompt-load evidence</b><small>Tool definitions in the initial prompt</small></span><span class=subline id=c-def-note>Waiting for evidence</span></div>
-     <div class=capCatalogBody><div class=defBar id=c-def-chart></div><div class=legend id=c-def-legend></div></div>
-    </section>
-    <div class=capFilters>
-     <label class=capFilterControl><span>Search</span><input class=searchbox id=c-search type=search aria-label="Search installed capabilities" placeholder="Name, source, or runtime"></label>
-     <div class=capFilterControl><span>Type</span><div class="seg sortseg" id=c-type-filter role=group aria-label="Capability type"><button type=button data-ctype=all>All</button><button type=button data-ctype=tool>Tools</button><button type=button data-ctype=mcp>MCPs</button><button type=button data-ctype=skill>Skills</button></div></div>
-     <div class=capFilterControl><span>State</span><div class="seg sortseg" id=c-state-filter role=group aria-label="Evidence and configuration"><button type=button data-cstate=all>All</button><button type=button data-cstate=enabled>Configured on</button><button type=button data-cstate=observed>Observed</button><button type=button data-cstate=unused>No use observed</button></div></div>
-     <label class=capFilterControl><span>Runtime</span><select id=c-runtime-filter aria-label="Capability runtime"><option value=all>All runtimes</option></select></label>
-    </div>
-    <label class=capMobileSort><span>Sort by</span><select id=c-mobile-sort><option value=name:asc>Name A–Z</option><option value=name:desc>Name Z–A</option><option value=use:desc>Most observed</option><option value=use:asc>Least observed</option><option value=last:desc>Recently observed</option><option value=last:asc>Oldest observed</option><option value=runtime:asc>Runtime A–Z</option><option value=state:asc>Configuration A–Z</option><option value=control:asc>Control A–Z</option></select></label>
-    <div class=capFilterStatus><div><span class=hint id=c-filter-count>Loading inventory&hellip;</span><div class=activeFilters id=c-active-filters hidden aria-live=polite></div></div><button class="tbtn clearFilters" id=c-clear-filters type=button hidden>Clear filters</button></div>
-    <div class=capTableWrap><table class=tbl id=c-table><thead><tr><th class=sortable data-csort=name tabindex=0 aria-sort=none>Capability</th><th class=sortable data-csort=type tabindex=0 aria-sort=none>Type</th><th class=sortable data-csort=runtime tabindex=0 aria-sort=none>Runtime / source</th><th class=sortable data-csort=state tabindex=0 aria-sort=none>Configuration</th><th class=sortable data-csort=use tabindex=0 aria-sort=none>Evidence</th><th class=sortable data-csort=last tabindex=0 aria-sort=none>Last observed</th><th class=sortable data-csort=control tabindex=0 aria-sort=none>Control</th></tr></thead><tbody><tr><td colspan=7 class=capEmpty>Loading local capability inventory&hellip;</td></tr></tbody></table></div>
-   </div>
-  </section>
-	 </div>
-
-	 <div class=view id=view-settings>
-  <div class=spectrumPageHeadFrame><div class="learnHead settingsPageHead spectrumPageHead" data-page-signal=settings><div class=spectrumPageHeadCopy><h1>Settings</h1><p class=spectrumPageSubtitle>Connections, pricing, and updates.</p></div></div></div>
-  <div class=settingsPageLayout>
-   <nav class="card settingsMap" aria-label="Settings sections">
-    <button type=button data-settings-target=appearance-settings><b>Appearance</b></button>
-    <button type=button data-settings-target=agent-access><b>Agent connection</b></button>
-    <button type=button data-settings-target=model-pricing-settings><b>Model pricing</b></button>
-    <button type=button data-settings-target=work-insights-settings><b>Work insights</b></button>
-    <button type=button data-settings-target=delivery-settings><b>Git evidence history</b></button>
-    <button type=button data-settings-target=update-settings><b>Software updates</b></button>
-   </nav>
-   <div class=settingsPageContent>
-   <section class="card pad appearanceSettings" id=appearance-settings>
-    <div class=learnSectionHead><div><h2 class=fieldtip id=appearance-title tabindex=0 aria-description="Provider and status colors stay the same in every theme." data-tip="Provider and status colors stay the same in every theme.">Appearance</h2><div class=subline>Theme for this browser · <kbd>&#8984;K</kbd> → Theme</div></div><span class="agentAccessBadge chip" id=theme-current-badge>Classic</span></div>
-    <div class=themePicker id=theme-picker role=group aria-labelledby=appearance-title></div>
-   </section>
-   <section class="card pad agentAccess" id=agent-access>
-    <div class=agentAccessHead><div><h2 class=fieldtip tabindex=0 aria-description="Give Codex and Claude read-only, on-demand access to numeric Token Meter evidence, and optionally install Token Meter skills that use it. Connections stay local and read-only." data-tip="Give Codex and Claude read-only, on-demand access to numeric Token Meter evidence, and optionally install Token Meter skills that use it. Connections stay local and read-only.">Agent connection</h2></div><a class=tbtn id=agent-skills-learn href="https://github.com/splunk/token-meter/blob/main/agent-skills/README.md" target=_blank rel="noopener noreferrer" aria-label="Learn more about Token Meter skills (opens GitHub in a new tab)">Learn more about skills</a></div>
-    <div class=agentClients id=agent-clients><div class=agentClient><div><div class=agentClientName>Loading connection status</div><div class=agentClientState>Checking local Codex and Claude Code configuration.</div></div></div></div>
-   </section>
-   <section class="card pad settingsLexicon settingsPricing" id=model-pricing-settings>
-    <div class=settingsLexiconHead><div><div class=label>Cost estimates</div><h2 class=fieldtip tabindex=0 aria-description="Edit prices in USD per 1 million tokens. By default, a change starts now and older sessions retain their earlier prices." data-tip="Edit prices in USD per 1 million tokens. By default, a change starts now and older sessions retain their earlier prices.">Model pricing</h2></div><span class="agentAccessBadge chip" id=model-pricing-badge>Loading prices</span></div>
-    <div class=modelPricingProvenance>Built-in rates reviewed <time id=model-pricing-reviewed>—</time><span aria-hidden=true>·</span><span id=model-pricing-sources>Loading sources</span></div>
-    <fieldset class=modelPriceScope id=model-price-scope><legend>Apply to selected models</legend><div class=modelPriceScopeOptions><label><input id=model-price-scope-from-now name=model-price-scope type=radio value=from_now checked><span>From now</span></label><label><input id=model-price-scope-from-date name=model-price-scope type=radio value=from_date><span>From date</span></label><label><input id=model-price-scope-all-history name=model-price-scope type=radio value=all_history><span>All history</span></label></div><label class=modelPriceEffective><span>Effective from</span><input id=model-price-effective-from type=datetime-local disabled aria-label="Model price effective date and time"></label><span id=model-price-selection-count>No models selected</span><span id=model-price-scope-note></span></fieldset>
-    <div class=modelPriceTabs id=model-price-tabs role=tablist aria-label="Model pricing provider"></div>
-    <div class=modelPriceTableWrap id=model-price-table-wrap><table class="tbl modelPriceTable"><thead><tr><th>Select</th><th>Provider</th><th>Model id</th><th class=num>Input</th><th class=num>Output</th><th class=num>Cache write</th><th class=num>Cached input</th></tr></thead><tbody id=model-pricing-rows><tr><td colspan=7 class=modelPricingEmpty>Waiting for dashboard data.</td></tr></tbody></table></div>
-    <form class=modelPriceAdd id=model-price-add-form>
-     <label><span>Provider</span><select id=model-price-provider><option value=claude>Claude</option><option value=codex>Codex / OpenAI</option><option value=cursor>Cursor</option><option value=opencode>OpenCode</option><option value=google>Google Gemini</option></select></label>
-     <label><span>New model id</span><input id=model-price-model autocomplete=off spellcheck=false required maxlength=160 placeholder="model-name-version"></label>
-     <label><span>Input</span><input id=model-price-input type=number min=0 max=1000000 step=any required placeholder=0></label>
-     <label><span>Output</span><input id=model-price-output type=number min=0 max=1000000 step=any required placeholder=0></label>
-     <label><span>Cache write</span><input id=model-price-cache-write type=number min=0 max=1000000 step=any required value=0></label>
-     <label><span>Cached input</span><input id=model-price-cache-read type=number min=0 max=1000000 step=any required value=0></label>
-     <button class=tbtn id=model-price-add type=submit>Add model</button>
-    </form>
-    <div class=modelPricingFooter><span class=settingsStatus id=model-pricing-status role=status aria-live=polite></span><button class=tbtn id=model-price-save-changes type=button disabled>Save models</button></div>
-   </section>
-   <section class="card pad workSettings" id=work-insights-settings hidden>
-    <div class=softwareUpdateHead><div><h2 class=fieldtip tabindex=0 aria-description="A local model labels each session's area, work type, complexity, and pushback so the Work page can show what spend went into. A local model reads the prompts you typed, the last few lines of the assistant reply before each one (to spot pushback), the names of files you uploaded, and the names of the files the agent changed for each request, and it counts the kinds of commands the agent ran. It never reads file contents or tool output. Text goes only to the Ollama address below on this machine, cloud models are refused, and Token Meter stores labels and counts, never text, file names, or commands." data-tip="A local model labels each session's area, work type, complexity, and pushback so the Work page can show what spend went into. A local model reads the prompts you typed, the last few lines of the assistant reply before each one (to spot pushback), the names of files you uploaded, and the names of the files the agent changed for each request, and it counts the kinds of commands the agent ran. It never reads file contents or tool output. Text goes only to the Ollama address below on this machine, cloud models are refused, and Token Meter stores labels and counts, never text, file names, or commands.">Work insights</h2><div class=subline>Reads your prompts and file names with a local Ollama model; stores only labels and counts.</div></div><span class=agentAccessBadge id=work-settings-badge>Off</span></div>
-    <div class=workEnableCta id=work-enable-cta hidden><button class="tbtn go" id=work-enable-button type=button>Turn on Work insights</button><small>Sets up Ollama and Google’s Gemma model in the background. Nothing leaves this Mac.</small></div>
-    <div class=softwareUpdateToggles>
-     <label class=softwareUpdateToggle><input id=work-enabled type=checkbox><span><b>Label sessions with a local model</b></span></label>
-     <label class=softwareUpdateToggle><input id=work-battery type=checkbox checked><span><b>Pause while on battery</b><small>Resumes automatically on power.</small></span></label>
-     <label class=softwareUpdateToggle><input id=work-live-notify type=checkbox checked><span><b>Notify me about live suggestions</b><small>Menu bar notification, one per suggestion per running session.</small></span></label>
-    </div>
-    <div class=workSettingsGrid>
-     <label class=settingsField><span>Model</span><input id=work-model spellcheck=false autocomplete=off maxlength=100></label>
-     <label class=settingsField><span>Ollama URL</span><input id=work-url spellcheck=false autocomplete=off maxlength=120></label>
-     <label class=settingsField><span class=fieldtip tabindex=0 aria-description="Automatic: up to 60 a minute while the CPU is mostly idle and this Mac is plugged in, 5 a minute otherwise." data-tip="Automatic: up to 60 a minute while the CPU is mostly idle and this Mac is plugged in, 5 a minute otherwise.">Pace</span><select class=filterSelect id=work-rate aria-description="Automatic: up to 60 a minute while the CPU is mostly idle and this Mac is plugged in, 5 a minute otherwise."><option value=auto>Automatic (default)</option><option value=5>5 labels / min</option><option value=10>10 labels / min</option><option value=20>20 labels / min</option><option value=40>40 labels / min</option><option value=60>60 labels / min</option></select></label>
-     <label class=settingsField><span>History to label</span><select class=filterSelect id=work-backfill><option value=30>Last 30 days</option><option value=90>Last 90 days</option><option value=365>Last 365 days</option><option value=0>All history</option></select></label>
-    </div>
-    <div class="workSetupHint fieldtip" tabindex=0 aria-description="Turning this on sets everything up in the background: Token Meter installs a pinned Ollama if this Mac doesn’t have one, downloads Google’s Gemma 4 E4B model (about 5 GB, Apache-2.0), adds it to Ollama, and deletes the download. It needs about 11 GB free while it sets up and about 5 GB after, and uses about 5.5 GB of memory while it labels." data-tip="Turning this on sets everything up in the background: Token Meter installs a pinned Ollama if this Mac doesn’t have one, downloads Google’s Gemma 4 E4B model (about 5 GB, Apache-2.0), adds it to Ollama, and deletes the download. It needs about 11 GB free while it sets up and about 5 GB after, and uses about 5.5 GB of memory while it labels.">Needs ~11 GB free to set up, ~5 GB after, ~5.5 GB RAM while labeling.</div>
-    <div class=workAreasHead><h3>Areas</h3><span class=subline id=work-areas-count></span></div>
-    <div class=workAreas id=work-areas></div>
-    <div class=workSettingsActions><div class=workActionGroup><button class=tbtn id=work-area-add type=button>Add area</button><button class="tbtn clearFilters" id=work-areas-reset type=button>Restore default areas</button></div><span class=settingsStatus id=work-settings-status aria-live=polite></span><button class=tbtn id=work-save type=button disabled>Save changes</button></div>
-    <div class="workActionGroup workSettingsManage"><label class=workPause><span class=workSrOnly>Pause work insights</span><select class=filterSelect id=work-pause aria-label="Pause work insights"><option value="">Pause…</option><option value=1h>Pause for 1 hour</option><option value=tomorrow>Pause until tomorrow</option><option value=indefinite>Pause until resumed</option><option value=resume>Resume</option></select></label><button class="tbtn clearFilters" id=work-clear type=button>Delete all labels</button></div>
-   </section>
-   <section class="card pad" id=delivery-settings>
-    <div class=learnSectionHead><div><h2 class=fieldtip tabindex=0 aria-description="Reads local pushes every five minutes. Clear starts a new baseline; older reflogs stay excluded. Token Meter stores these totals locally." data-tip="Reads local pushes every five minutes. Clear starts a new baseline; older reflogs stay excluded. Token Meter stores these totals locally.">Git evidence history</h2><div class=subline>Scans local pushes every 5 min.</div></div><button class="tbtn clearFilters" id=delivery-clear type=button>Clear Git evidence</button></div>
-    <div class="settingsStatus deliveryClearStatus" id=delivery-clear-status></div>
-   </section>
-   <section class="card pad" id=menubar-settings>
-    <div class=learnSectionHead><div><h2 class=fieldtip tabindex=0 aria-description="Shows the prompt-cache timer next to the cost in the menu bar title. Session cards and the menu bar popover always show it. The menu bar app reads this setting." data-tip="Shows the prompt-cache timer next to the cost in the menu bar title. Session cards and the menu bar popover always show it. The menu bar app reads this setting.">Menu bar</h2><div class=subline>Cache timer in the menu bar title.</div></div><div class=seg id=menubar-cache-timer role=group aria-label="Cache timer in menu bar"><button type=button data-cache-timer=always aria-pressed=true>Always</button><button type=button data-cache-timer=final2 aria-pressed=false>Last 2 min</button><button type=button data-cache-timer=off aria-pressed=false>Off</button></div></div>
-    <div class=settingsStatus id=menubar-settings-status aria-live=polite></div>
-   </section>
-   <section class="card pad softwareUpdates" id=update-settings>
-    <div class=softwareUpdateHead><div><h2 class=fieldtip tabindex=0 aria-description="Checks fetch revision metadata only. Safe updates from the tracked main branch can install automatically without opening the dashboard. Enabled by default: Token Meter checks once at startup, then every 10 minutes while it is running, and installs safe updates automatically." data-tip="Checks fetch revision metadata only. Safe updates from the tracked main branch can install automatically without opening the dashboard. Enabled by default: Token Meter checks once at startup, then every 10 minutes while it is running, and installs safe updates automatically.">Software updates</h2></div><span class="agentAccessBadge chip" id=update-settings-badge>Waiting</span></div>
-    <div class=softwareUpdateToggles>
-     <label class=softwareUpdateToggle><input id=update-enabled type=checkbox checked><span><b>Check for updates every 10 minutes</b><small>Off also disables auto-install.</small></span></label>
-     <label class=softwareUpdateToggle><input id=update-auto-install type=checkbox checked><span><b>Automatically install available updates</b><small>Checks continue when off.</small></span></label>
-    </div>
-    <div class=softwareUpdateActions><button class=tbtn id=update-check type=button>Check now</button><span class=settingsStatus id=update-settings-status>Waiting for the first update check.</span><span class=softwareUpdateMeta id=update-settings-meta></span></div>
-   </section>
-   </div>
-  </div>
-	 </div>
-</div>
-<button class="deckPrimary tourReturn" id=tour-return type=button hidden><span class=tourReturnArrow aria-hidden=true>←</span><span id=tour-return-label>Back to the tour</span></button>
-<dialog class=welcome id=welcome-dialog aria-modal=true aria-labelledby=welcome-label aria-describedby=welcome-deck-status>
- <header class=welcomeTop><div class=welcomeBrand><b id=welcome-label>Welcome to Token Meter</b></div><div class=welcomeTopActions><button class=welcomeSkip id=welcome-skip type=button>Skip tour</button><button class=welcomeClose id=welcome-close type=button aria-label="Close welcome" title="Close (Esc)"><span aria-hidden=true>&#10005;</span></button></div></header>
- <div class=deck id=welcome-deck data-deck-host=welcome></div>
-</dialog>
-<dialog class=commandPalette id=command-palette aria-labelledby=command-title>
- <div class=commandShell>
-  <div class=commandSearch><svg viewBox="0 0 24 24" fill=none stroke-width=2 stroke-linecap=round aria-hidden=true><circle cx=11 cy=11 r=7></circle><path d="m20 20-4-4"></path></svg><input id=command-search type=search role=combobox aria-label="Search commands" aria-autocomplete=list aria-expanded=true aria-controls=command-list placeholder="Search views and actions" autocomplete=off spellcheck=false><kbd>ESC</kbd></div>
-  <div class=commandList id=command-list role=listbox aria-label="Available commands"></div>
-  <div class=commandFooter><span id=command-title><kbd>&#8984;K</kbd> opens this anywhere</span><span><kbd>&uarr;</kbd><kbd>&darr;</kbd> move <kbd>&crarr;</kbd> open</span></div>
- </div>
-</dialog>
-<dialog class="mcpDialog goalsDialog" id=goals-dialog aria-labelledby=goals-form-heading>
-	   <form class=goalsForm id=goals-form novalidate>
-	    <h3 id=goals-form-heading tabindex=-1>New goal</h3>
-	    <div class=goalsFormBody>
-	    <div class=goalsFields>
-	    <div class="goalsStep goalsWide"><span id=goals-metric-label>Metric</span><div class=goalsOptions id=goals-metric-options role=group aria-labelledby=goals-metric-label></div><select id=goals-metric hidden></select></div>
-	    <label class=goalsStep id=goals-app-field>App<select class=filterSelect id=goals-app></select></label>
-	    <label class=goalsStep id=goals-work-field hidden>Kind of work<select class=filterSelect id=goals-work-type></select></label>
-	    <div class=goalsStep id=goals-models-field><span>Models</span><details class=modelPicker id=goals-model-picker><summary aria-label="Choose models for this goal"><span id=goals-model-summary>All models</span></summary><div class=modelPickerMenu id=goals-model-menu><label class=goalsModelSearch id=goals-model-search-field hidden><input id=goals-model-search type=search maxlength=120 autocomplete=off placeholder="Find a model" aria-label="Find a model"><small class=goalsHelp id=goals-model-note></small></label><div id=goals-model-options role=group aria-label="Models for this goal"></div></div></details></div>
-	    <label class=goalsStep for=goals-period>Period<select class=filterSelect id=goals-period><option value=today>Today</option><option value=week>This week</option><option value=month>This month</option><option value=next7>Next 7 days</option><option value=next30>Next 30 days</option><option value=next90>Next 90 days</option><option value=custom>Custom dates</option></select></label>
-	    <div class="goalsStep goalsDates goalsWide" id=goals-dates hidden><label>Start<input id=goals-start type=date></label><label>End<input id=goals-end type=date></label></div>
-	    <fieldset class="goalsStep goalsWide"><legend>Target</legend><div class=goalsOptions id=goals-options role=group aria-label="Target"></div>
-	     <div class=goalsCustom id=goals-custom hidden><select class=filterSelect id=goals-comparison aria-label="Direction"><option value="">Direction</option><option value=at_most>At most</option><option value=at_least>At least</option><option value=between hidden>Between</option></select><input id=goals-target type=number min=0 step=any aria-label="Target value"><input id=goals-target-high type=number min=0 step=any aria-label="Upper target value" hidden></div><p class=goalsHelp id=goals-target-note hidden></p></fieldset>
-	    <label class="goalsStep goalsSpan2">Name<input id=goals-title maxlength=100></label>
-	    <label class=goalsRepeat id=goals-repeat-field><input type=checkbox id=goals-repeat> Repeat <span id=goals-repeat-unit>monthly</span></label>
-	    </div>
-	    <aside class=goalPreview id=goals-preview aria-live=polite aria-label="Goal preview"></aside>
-	    </div>
-	    <div class=goalsFormActions><div class=goalsFormError id=goals-form-error role=alert hidden></div><button class=tbtn type=button id=goals-cancel>Cancel</button><button class=tbtn type=submit id=goals-save>Save goal</button></div>
-	   </form>
-</dialog>
-<dialog class=mcpDialog id=cap-dialog aria-labelledby=cap-dialog-title aria-describedby=cap-dialog-sub>
- <div class=inner>
-  <h3 id=cap-dialog-title>Change skill pack?</h3>
-  <div class=subline id=cap-dialog-sub></div>
-  <div class=evidence id=cap-dialog-evidence></div>
-  <div class=label>Exact control</div>
-  <code id=cap-dialog-control></code>
-  <div class=subline id=cap-dialog-setting></div>
-  <div class=actions><button class=tbtn id=cap-cancel>Cancel</button><button class=tbtn id=cap-confirm>Confirm</button></div>
- </div>
-</dialog>
-<dialog class=mcpDialog id=bulk-dialog aria-labelledby=bulk-dialog-title aria-describedby=bulk-dialog-sub>
- <div class=inner>
-  <h3 id=bulk-dialog-title>Disable selected skill packs?</h3>
-  <div class=subline id=bulk-dialog-sub></div>
-  <div class=evidence id=bulk-dialog-evidence></div>
-  <div class=label>Exact controls</div>
-  <code class=bulkControls id=bulk-dialog-controls></code>
-  <div class=subline>Only selected current review candidates are accepted. MCP servers, built-ins, standalone skills, used groups, and runtime-managed packs are excluded. Successful changes require restarting the IDE or agent.</div>
-  <div class=actions><button class=tbtn id=bulk-cancel>Cancel</button><button class="tbtn danger" id=bulk-confirm>Disable selected</button></div>
- </div>
-</dialog>
-<dialog class=mcpDialog id=agent-dialog>
- <div class=inner>
-  <h3 id=agent-dialog-title>Connect agent?</h3>
-  <div class=subline id=agent-dialog-sub></div>
-  <div class=evidence id=agent-dialog-evidence></div>
-  <div class=label id=agent-dialog-command-label>Exact local command</div>
-  <code class=agentCommand id=agent-dialog-command></code>
-  <div class=subline id=agent-dialog-note>Only Token Meter&rsquo;s exact <code>tokenmeter</code> entry is managed. Start a new agent session after the change.</div>
-  <div class=actions><button class=tbtn id=agent-cancel>Cancel</button><button class=tbtn id=agent-confirm>Confirm</button></div>
- </div>
-</dialog>
-<dialog class=mcpDialog id=session-delete-dialog>
- <div class=inner>
-  <h3>Delete session?</h3>
-  <div class=subline id=session-delete-sub></div>
-  <div class=evidence id=session-delete-evidence></div>
-  <div class=label>Session</div>
-  <code id=session-delete-id></code>
-  <div class=subline id=session-delete-note></div>
-  <div class=actions><button class=tbtn id=session-delete-cancel>Cancel</button><button class="tbtn danger" id=session-delete-confirm>Move to Trash</button></div>
- </div>
-</dialog>
-<dialog class=mcpDialog id=session-model-identity-dialog aria-labelledby=session-model-identity-title aria-describedby=session-model-identity-note>
- <div class=inner>
-  <h3 id=session-model-identity-title>Assign model to this session</h3>
-  <div class=subline id=session-model-identity-sub></div>
-  <div class=evidence id=session-model-identity-evidence></div>
-  <label class=settingsField><span id=session-model-identity-model-label>Codex / OpenAI model ID</span><input id=session-model-identity-model autocomplete=off spellcheck=false maxlength=160 placeholder="gpt-model-version" list=session-model-identity-candidates></label>
-  <datalist id=session-model-identity-candidates></datalist>
-  <div class=subline id=session-model-identity-note>This affects only this saved session. It does not change model prices; configure a model rate separately in Settings → Model pricing.</div>
-  <div class=actions><button class="tbtn danger" id=session-model-identity-remove type=button hidden>Clear assignment</button><button class=tbtn id=session-model-identity-cancel type=button>Cancel</button><button class=tbtn id=session-model-identity-save type=button>Save model</button></div>
- </div>
-</dialog>
-<button class=updateNotice id=update-notice type=button hidden>New update available</button>
-<div class=toastbox id=toastbox></div>
-
-<script>
-// Data-series palettes for charts and SVG; CSS colors live in the stylesheet :root.
-const THEME={
- compare:['#00bceb','#c7a7ff','#ffb457','#66d990'],
- modelOther:'#5E6E7E',
- modelSpeedExtra:['#F3C76A','#7AA7FF','#D4E157','#E6E6E6','#A1887F','#4DB6AC','#CE93D8','#90A4AE'],
-};
-const $=id=>document.getElementById(id);
-const TOKENOMICS_SEARCH_URL='https://www.google.com/search?q=site%3Asplunk.com+tokenomics';
-const DELIVERY_RANGES=['today','yesterday','7','30','90','month','last_month'];
-const TIME_FILTER_WINDOWS=['today','yesterday','7d','30d','90d','month','last_month','all'];
-const TIME_FILTER_LABELS={today:'Today',yesterday:'Yesterday','7d':'7 days','30d':'30 days','90d':'90 days',month:'Month','last_month':'Last month',all:'All history'};
-const DEFAULT_TIME_FILTER_WINDOW='30d';
-function normalizeTimeFilterWindow(value){return value==='24h'?'today':TIME_FILTER_WINDOWS.includes(value)?value:DEFAULT_TIME_FILTER_WINDOW;}
-function timeFilterBounds(window,nowMs=Date.now()){
- const now=new Date(nowMs),stamp=(month,day)=>new Date(now.getFullYear(),month,day).getTime()/1000;
- if(window==='today')return {start:stamp(now.getMonth(),now.getDate()),end:0};
- if(window==='yesterday')return {start:stamp(now.getMonth(),now.getDate()-1),end:stamp(now.getMonth(),now.getDate())};
- if(window==='month')return {start:stamp(now.getMonth(),1),end:0};
- if(window==='last_month')return {start:stamp(now.getMonth()-1,1),end:stamp(now.getMonth(),1)};
- const seconds={'7d':604800,'30d':2592000,'90d':7776000}[window]||0;
- return {start:seconds?nowMs/1000-seconds:0,end:0};
-}
-const DELIVERY_EVIDENCE_FILTERS=['all','comparable','spend_only','git_only','unavailable'];
-let deliveryRange=localStorage.getItem('tm_delivery_range')||'30';
-if(!DELIVERY_RANGES.includes(deliveryRange)){deliveryRange='30';localStorage.setItem('tm_delivery_range',deliveryRange);}
-let deliveryProject=localStorage.getItem('tm_delivery_project')||'';
-let deliveryPayload=null,deliveryRequest=0,deliverySelectedDay='',deliveryLastLoadedAt=0;
-let deliverySort={key:'covered_cost',direction:'desc'};
-let deliveryModelSort={key:'covered_cost',direction:'desc'};
-let deliveryEvidenceFilter='all';
-let deliveryIgnorePointerSelection=false;
-function stripNativeFieldTipTitles(root=document){
- root.querySelectorAll('.fieldtip[title]').forEach(el=>{if(!el.hasAttribute('aria-description'))el.setAttribute('aria-description',el.getAttribute('title'));el.removeAttribute('title');});
-}
-stripNativeFieldTipTitles();
-function initFieldTipPopup(){
- const popup=document.createElement('div');
- popup.id='fieldtip-popup';popup.setAttribute('role','tooltip');popup.hidden=true;document.body.append(popup);
- let activeFieldTip=null,positionFrame=0;
- const fieldTipTarget=node=>node instanceof Element?node.closest('.fieldtip[data-tip]'):null;
- const hideFieldTip=target=>{
-  if(target&&activeFieldTip!==target)return;
-  activeFieldTip=null;popup.hidden=true;
- };
- const positionFieldTip=()=>{
-  positionFrame=0;
-  const target=activeFieldTip,tip=target?.getAttribute('data-tip')?.trim();
-  if(!target||!target.isConnected||!tip){hideFieldTip();return;}
-  popup.textContent=tip;popup.hidden=false;
-  const rect=target.getBoundingClientRect(),margin=12,gap=8,width=popup.offsetWidth,height=popup.offsetHeight;
-  const maxLeft=Math.max(margin,window.innerWidth-margin-width),maxTop=Math.max(margin,window.innerHeight-margin-height);
-  const left=Math.max(margin,Math.min(rect.left,maxLeft)),below=rect.bottom+gap,above=rect.top-gap-height;
-  const top=Math.max(margin,Math.min(below+height<=window.innerHeight-margin||above<margin?below:above,maxTop));
-  popup.style.left=`${left}px`;popup.style.top=`${top}px`;
- };
- const scheduleFieldTipPosition=()=>{
-  if(positionFrame)cancelAnimationFrame(positionFrame);
-  positionFrame=requestAnimationFrame(positionFieldTip);
- };
- document.addEventListener('pointerover',event=>{
-  const target=fieldTipTarget(event.target);
-  if(target&&!target.contains(event.relatedTarget)){activeFieldTip=target;scheduleFieldTipPosition();}
- });
- document.addEventListener('pointerout',event=>{
-  const target=fieldTipTarget(event.target);
-  if(target&&!target.contains(event.relatedTarget))hideFieldTip(target);
- });
- document.addEventListener('focusin',event=>{
-  const target=fieldTipTarget(event.target);
-  if(target){activeFieldTip=target;scheduleFieldTipPosition();}
- });
- document.addEventListener('focusout',event=>{
-  const target=fieldTipTarget(event.target);
-  if(target&&!target.contains(event.relatedTarget))hideFieldTip(target);
- });
- window.addEventListener('resize',scheduleFieldTipPosition);
- window.addEventListener('scroll',scheduleFieldTipPosition,true);
-}
-initFieldTipPopup();
-const f=n=>Math.round(n||0).toLocaleString();
-const compactNumber=n=>{n=Number(n)||0;const a=Math.abs(n);if(a>=1e9)return (n/1e9).toFixed(a>=1e10?0:1).replace(/\.0$/,'')+'B';if(a>=1e6)return (n/1e6).toFixed(a>=1e7?0:1).replace(/\.0$/,'')+'M';if(a>=1e3)return (n/1e3).toFixed(a>=1e4?0:1).replace(/\.0$/,'')+'K';return f(n);};
-const money=n=>{n=Number(n)||0;const a=Math.abs(n),d=a>=1000?1:2;if(a>0&&a<.005)return n<0?'-<$0.01':'<$0.01';return (n<0?'-':'')+'$'+a.toLocaleString('en-US',{minimumFractionDigits:d,maximumFractionDigits:d});};
-const wholeMoney=n=>`${Number(n||0)<0?'-':''}$${Math.round(Math.abs(Number(n||0))).toLocaleString('en-US')}`;
-const COST_UNAVAILABLE_TIP='Cost is unavailable, not $0. Token Meter can estimate cost only from locally stored usage with an identifiable model and an available configured rate. The local trace may omit billable usage, the model may be unknown or unpriced, or the session may be cloud-hosted without a readable local trace.';
-function setCostValue(id,value,available){
- const element=$(id);element.textContent=available?value:'--';
- element.classList.toggle('fieldtip',!available);
- if(available){
-  element.removeAttribute('tabindex');element.removeAttribute('aria-description');element.removeAttribute('data-tip');
-  return;
- }
- element.setAttribute('tabindex','0');element.setAttribute('aria-description',COST_UNAVAILABLE_TIP);element.setAttribute('data-tip',COST_UNAVAILABLE_TIP);
-}
-function costUnavailableAttrs(){const safe=esc(COST_UNAVAILABLE_TIP);return `data-tip="${safe}"`;}
-function costValueHtml(value,available,focusable=true){
- if(available)return value;
- if(focusable)return `<span ${tipAttrs(COST_UNAVAILABLE_TIP)}>--</span>`;
- const safe=esc(COST_UNAVAILABLE_TIP);return `<span class=fieldtip aria-description="${safe}" data-tip="${safe}">--</span>`;
-}
-const pct=n=>Math.round((n||0)*100)+'%';
-const metricAvailable=(row,metric)=>row?.availability?.[metric]!==false;
-const metricText=(row,metric,value,formatter)=>metricAvailable(row,metric)?formatter(value):'--';
-const metricPartial=(row,metric)=>row?.coverage?.[metric]?.complete===false;
-const partialSuffix=(row,metric)=>metricPartial(row,metric)?' · partial':'';
-const usageProvenance=row=>row?.provenance||{};
-const usageBasis=row=>usageProvenance(row).usage_basis||row?.usage_basis||(row?.token_estimate?'local_estimate':'reported');
-const hasLocalEstimate=row=>['local_estimate','mixed'].includes(usageBasis(row))||row?.provider==='cursor';
-const estimateSuffix=row=>usageBasis(row)==='local_estimate'?' est':usageBasis(row)==='mixed'?' incl. est':'';
-const runtimeId=session=>String(session?.provider||session?.runtime_id||session?.client||'unknown-runtime');
-const runtimeMeta=session=>RUNTIME_CATALOG[runtimeId(session)]||RUNTIME_CATALOG['unknown-runtime']||{label:'Unknown Runtime',symbol:'runtime.generic',color:'runtime-neutral',capabilities:['sessions']};
-const runtimeMarkSvg=session=>{
- const symbol=runtimeMeta(session).symbol;
- const mark={
-  'runtime.claude':'<path d="M25.7146 63.2153L41.4393 54.3917L41.7025 53.6226L41.4393 53.1976H40.6705L38.0394 53.0359L29.054 52.7929L21.2624 52.4691L13.7134 52.0644L11.8111 51.6594L10.0303 49.3118L10.2123 48.138L11.8111 47.0657L14.0981 47.2681L19.1574 47.6119L26.7467 48.138L32.2516 48.4618L40.4073 49.3118H41.7025L41.8846 48.7857L41.4393 48.4618L41.0955 48.138L33.243 42.8155L24.7432 37.1894L20.2909 33.9513L17.8824 32.3119L16.6684 30.774L16.1422 27.4147L18.328 25.0062L21.2624 25.2088L22.0112 25.4112L24.9861 27.6979L31.3407 32.616L39.6381 38.7273L40.8525 39.7391L41.3381 39.395L41.399 39.1523L40.8525 38.2415L36.3394 30.0858L31.5227 21.7883L29.3775 18.3478L28.811 16.2837C28.6087 15.4334 28.4669 14.7252 28.4669 13.8549L30.9563 10.4753L32.3321 10.0303L35.6515 10.4756L37.0479 11.6897L39.112 16.4052L42.4513 23.8327L47.6321 33.9313L49.15 36.9265L49.9594 39.6991L50.2632 40.5491H50.7894V40.0632L51.2141 34.3766L52.0035 27.3944L52.7726 18.4087L53.0358 15.8793L54.2905 12.8435L56.7795 11.2041L58.7224 12.135L60.3212 14.422L60.0986 15.899L59.1474 22.0718L57.2857 31.7458L56.0713 38.2218H56.7795L57.5892 37.4121L60.8677 33.061L66.3723 26.18L68.801 23.448L71.6342 20.4325L73.4556 18.9957H76.8962L79.4255 22.7601L78.2926 26.6456L74.7509 31.1384L71.8163 34.943L67.607 40.6097L64.9758 45.1431L65.2188 45.5072L65.8464 45.4466L75.358 43.4228L80.4984 42.4917L86.6304 41.4393L89.4033 42.7346L89.7065 44.0502L88.6135 46.7419L82.0566 48.3607L74.3662 49.8989L62.9118 52.6109L62.77 52.7121L62.9321 52.9144L68.0925 53.4L70.2987 53.5214H75.7021L85.7601 54.2702L88.3912 56.0108L89.9697 58.1358L89.7065 59.7545L85.6589 61.8189L80.1949 60.5236L67.4452 57.4881L63.0735 56.3952H62.4665V56.7596L66.1093 60.3213L72.7877 66.3523L81.1461 74.1236L81.5707 76.0462L80.4984 77.5638L79.3649 77.4021L72.0186 71.8772L69.1854 69.3879L62.77 63.9844H62.3453V64.5509L63.8223 66.7164L71.6342 78.4544L72.0389 82.0567L71.4725 83.2308L69.4487 83.939L67.2222 83.534L62.6485 77.1189L57.9333 69.8937L54.1284 63.4177L53.6631 63.6809L51.4167 87.8651L50.3644 89.0995L47.9356 90.0303L45.9121 88.4924L44.8392 86.0031L45.9118 81.0852L47.2071 74.6701L48.2594 69.5699L49.2106 63.2356L49.7773 61.131L49.7367 60.9892L49.2715 61.0498L44.4954 67.607L37.23 77.4224L31.4825 83.5746L30.1063 84.1211L27.7181 82.8864L27.9408 80.6805L29.2763 78.7177L37.2297 68.5988L42.026 62.3248L45.1227 58.7025L45.1024 58.176H44.9204L23.7917 71.8975L20.0274 72.3831L18.4083 70.8655L18.6106 68.3761L19.3798 67.5664L25.7343 63.195L25.7146 63.2153Z" fill="currentColor"/>',
-  'runtime.codex':'<path d="M83.7733 42.8087C84.6678 40.1149 84.9771 37.2613 84.6807 34.4385C84.3843 31.6156 83.489 28.8885 82.0544 26.4394C77.6908 18.8436 68.9203 14.9365 60.3548 16.7725C57.9831 14.1344 54.9591 12.1668 51.5864 11.0673C48.2137 9.96772 44.611 9.77498 41.1402 10.5084C37.6694 11.2418 34.4527 12.8755 31.8132 15.2455C29.1736 17.6155 27.204 20.6383 26.1024 24.0103C23.3212 24.5806 20.6938 25.738 18.3958 27.405C16.0977 29.0721 14.1819 31.2104 12.7765 33.6772C8.36538 41.2609 9.3669 50.8267 15.2527 57.3327C14.3549 60.0251 14.0424 62.8782 14.3361 65.7012C14.6298 68.5241 15.523 71.2518 16.9558 73.7017C21.325 81.3002 30.1011 85.207 38.6712 83.3686C40.5554 85.4904 42.8707 87.1858 45.4623 88.3416C48.0539 89.4975 50.8622 90.0871 53.6999 90.0713C62.4793 90.079 70.2575 84.4114 72.9393 76.0515C75.7201 75.4802 78.347 74.3225 80.6449 72.6555C82.9427 70.9886 84.8587 68.8507 86.2649 66.3846C90.6227 58.8145 89.6172 49.3005 83.7733 42.8087ZM53.6999 84.8356C50.1955 84.8411 46.801 83.6129 44.1116 81.3661L44.5848 81.098L60.5123 71.9043C60.9087 71.6718 61.2379 71.3402 61.4674 70.942C61.6969 70.5439 61.8189 70.0929 61.8215 69.6333V47.1769L68.5553 51.072C68.6225 51.1063 68.6694 51.1707 68.6814 51.2456V69.854C68.6641 78.1208 61.9667 84.8183 53.6999 84.8356ZM21.4977 71.0843C19.7402 68.0497 19.1092 64.4925 19.7156 61.0386L20.1885 61.3225L36.1321 70.5165C36.5266 70.748 36.9757 70.87 37.4331 70.87C37.8905 70.87 38.3396 70.748 38.7341 70.5165L58.21 59.2883V67.0628C58.2081 67.1031 58.1973 67.1424 58.1782 67.1779C58.1591 67.2134 58.1322 67.2441 58.0996 67.2678L41.9671 76.5722C34.798 80.7022 25.6388 78.2463 21.4977 71.0843ZM17.3026 36.3898C19.0723 33.3357 21.8655 31.0062 25.1878 29.8138V48.7376C25.1818 49.1949 25.2986 49.6453 25.5261 50.042C25.7535 50.4387 26.0833 50.7671 26.4809 50.9928L45.8622 62.1739L39.1283 66.069C39.0919 66.0883 39.0513 66.0984 39.0101 66.0984C38.9689 66.0984 38.9283 66.0883 38.8919 66.069L22.7908 56.7809C15.6359 52.6337 13.1822 43.4816 17.3026 36.3112V36.3898ZM72.624 49.2426L53.1792 37.9512L59.8976 34.0718C59.9341 34.0524 59.9747 34.0423 60.016 34.0423C60.0573 34.0423 60.0979 34.0524 60.1344 34.0718L76.2355 43.3761C78.6973 44.7966 80.7043 46.8882 82.0221 49.4065C83.3398 51.9249 83.914 54.7661 83.6775 57.5985C83.4411 60.431 82.4038 63.1377 80.6867 65.4027C78.9696 67.6677 76.6436 69.3975 73.9803 70.3901V51.466C73.9663 51.0096 73.834 50.5647 73.5962 50.1749C73.3584 49.7851 73.0234 49.4638 72.624 49.2426ZM79.3261 39.1657L78.8529 38.8815L62.9411 29.6089C62.5442 29.376 62.0924 29.2532 61.6322 29.2532C61.172 29.2532 60.7202 29.376 60.3233 29.6089L40.8629 40.8374V33.0628C40.8587 33.0233 40.8654 32.9834 40.882 32.9473C40.8987 32.9113 40.9248 32.8803 40.9575 32.8579L57.0586 23.5692C59.5263 22.1476 62.3478 21.458 65.193 21.5811C68.0382 21.7042 70.7896 22.6348 73.1253 24.2642C75.461 25.8936 77.2845 28.1543 78.3825 30.782C79.4806 33.4097 79.8077 36.2957 79.3257 39.1025V39.1657H79.3261ZM37.1888 52.9484L30.455 49.069C30.4213 49.0487 30.3925 49.0212 30.3707 48.9884C30.3488 48.9557 30.3345 48.9186 30.3286 48.8797V30.3188C30.3323 27.4714 31.1466 24.6839 32.6761 22.2822C34.2057 19.8805 36.3874 17.9639 38.9661 16.7564C41.5448 15.549 44.4139 15.1005 47.2381 15.4636C50.0622 15.8267 52.7247 16.9862 54.9141 18.8067L54.4409 19.0748L38.5134 28.2686C38.117 28.5011 37.7879 28.8327 37.5584 29.2308C37.329 29.629 37.207 30.0799 37.2045 30.5395L37.1888 52.9487V52.9484ZM40.8472 45.0632L49.5209 40.0643L58.21 45.0635V55.0615L49.5523 60.0608L40.8632 55.0615L40.8472 45.0632Z" fill="currentColor"/>',
-  'runtime.cursor':'<path d="M84.0704 28.9353L51.9066 10.4454C50.8738 9.85153 49.5994 9.85153 48.5666 10.4454L16.4043 28.9353C15.536 29.4345 15 30.3576 15 31.3575V68.6425C15 69.6424 15.536 70.5655 16.4043 71.0647L48.5681 89.5546C49.6009 90.1485 50.8753 90.1485 51.9081 89.5546L84.0719 71.0647C84.9402 70.5655 85.4762 69.6424 85.4762 68.6425V31.3575C85.4762 30.3576 84.9402 29.4345 84.0719 28.9353H84.0704ZM82.0501 32.8519L51.0006 86.4003C50.7907 86.7611 50.2366 86.6138 50.2366 86.1958V51.1329C50.2366 50.4322 49.8606 49.7842 49.2506 49.4324L18.7553 31.9017C18.3929 31.6927 18.5409 31.141 18.9606 31.141H81.0595C81.9414 31.141 82.4925 32.0927 82.0516 32.8534H82.0501V32.8519Z" fill="currentColor"/>',
-  'runtime.opencode':'<g transform="scale(6.25)"><path d="M6.2 2.5 2 8l4.2 5.5M9.8 2.5 14 8l-4.2 5.5" fill=none stroke=currentColor stroke-width=1.6 stroke-linecap=round stroke-linejoin=round/></g>',
- }[symbol]||'<g transform="scale(6.25)"><circle cx=8 cy=8 r=5.7 fill=none stroke=currentColor stroke-width=1.4/><circle cx=8 cy=8 r=1.6 fill="currentColor"/></g>';
- return `<svg class=runtimeMark viewBox="0 0 100 100" aria-hidden=true focusable=false>${mark}</svg>`;
-};
-const runtimeBadgeContent=(session,label)=>`${runtimeMarkSvg(session)}<span>${esc(label)}</span>`;
-const runtimeLabel=session=>session?.runtime||session?.label||runtimeMeta(session).label;
-const PROVIDER_COLOR_IDS=new Set(['claude','codex','cursor','opencode','kiro']);
-const providerColor=id=>PROVIDER_COLOR_IDS.has(id)?`var(--provider-${id})`:'var(--provider-other)';
-const runtimeHarness=session=>providerColor(runtimeId(session));
-const appBadgeClass=session=>PROVIDER_COLOR_IDS.has(runtimeId(session))?runtimeId(session):'neutral';
-const appFilterGroup=session=>runtimeId(session);
-const appFilterLabel=session=>runtimeMeta(session).label||session?.label||session?.runtime||'Unknown app';
-const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
-const speedFmt=n=>{n=Number(n)||0;if(n<=0)return'--';if(n>=100)return n.toFixed(0);if(n>=10)return n.toFixed(1);return n.toFixed(2);};
-const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
-// Work page state is declared early: the initial hash route can run before later definitions.
-let WORK=null,workRequest=0,workLastLoadedAt=0,workMonths='6',workRuntime='',workProject='';
-let workSupported=null;
-// Declared before the first route runs: a deep link schedules its scroll during startup.
-let pendingSettingsScroll=null;
-let workSessionFilter=null,workFilterRequest=0;
-let WORK_SETTINGS=null,workAreasDraft=null;
-function durationShort(seconds){
- seconds=Math.max(0,Math.round(seconds||0));
- if(seconds<60) return seconds+'s';
- const minutes=Math.floor(seconds/60);
- if(minutes<60) return minutes+'m';
- const hours=Math.floor(minutes/60);
- if(hours<48) return hours+'h '+String(minutes%60).padStart(2,'0')+'m';
- const days=Math.floor(hours/24);
- return days+'d '+String(hours%24).padStart(2,'0')+'h';
-}
-function waitFmt(seconds){
- seconds=Math.max(0,Number(seconds)||0);
- if(seconds<10)return seconds.toFixed(1).replace(/\.0$/,'')+'s';
- const whole=Math.round(seconds);
- if(whole<60)return whole+'s';
- const minutes=Math.floor(whole/60),secs=whole%60;
- if(minutes<60)return minutes+'m '+String(secs).padStart(2,'0')+'s';
- const hours=Math.floor(minutes/60),rem=minutes%60;
- if(hours<48)return hours+'h '+String(rem).padStart(2,'0')+'m';
- const days=Math.floor(hours/24);
- return days+'d '+String(hours%24).padStart(2,'0')+'h';
-}
-// Readouts pair one number with a reference point and a plain-language reading.
-function typicalComparison(value,typical){
- value=Number(value);typical=Number(typical);
- if(!Number.isFinite(value)||!Number.isFinite(typical)||typical<=0)return {ratio:null,band:''};
- const ratio=value/typical;
- return {ratio,band:value<=0?'none':ratio>=1.15?'above':ratio<=.85?'below':'near'};
-}
-function typicalCaption(value,typical,noun,typicalText){
- const {ratio,band}=typicalComparison(value,typical);
- if(!band)return '';
- if(band==='none')return `Nothing yet · ${noun} is ${typicalText}`;
- if(band==='above')return `${ratio>=10?Math.round(ratio):ratio.toFixed(1)}× ${noun} of ${typicalText}`;
- if(band==='below')return `${Math.round((1-ratio)*100)}% below ${noun} of ${typicalText}`;
- return `In line with ${noun} of ${typicalText}`;
-}
-function readoutScaleHtml({value,typical,high=0,label='',toned=true}){
- const {ratio,band}=typicalComparison(value,typical);
- if(!band)return '';
- const top=Math.max(Number(high)||0,Number(value)*1.1,Number(typical)*2);
- const at=Math.min(100,Math.max(0,Number(value)/top*100)),typ=Math.min(100,Number(typical)/top*100);
- const tone=toned&&ratio>=1.5?'high':'';
- return `<span class=readoutScale role=img aria-label="${esc(label)}" data-tone="${tone}" style="--at:${at.toFixed(1)}%;--typ:${typ.toFixed(1)}%"><i class=readoutScaleFill></i><i class=readoutScaleTypical></i><i class=readoutScaleMark></i></span>`;
-}
-const medianOf=values=>{const sorted=values.filter(Number.isFinite).sort((a,b)=>a-b);if(!sorted.length)return null;const mid=sorted.length>>1;return sorted.length%2?sorted[mid]:(sorted[mid-1]+sorted[mid])/2;};
-// Baselines come from up to 30 prior active days; today is excluded so it is compared, not averaged in.
-function dailyBaseline(days,todayKey=localDayKey()){
- const start=new Date(`${todayKey}T12:00:00`);start.setDate(start.getDate()-30);
- const startKey=localDayKey(start);
- const prior=(Array.isArray(days)?days:[]).filter(row=>row?.day&&row.day<todayKey&&row.day>=startKey&&Number(row.sessions)>0);
- const costRows=prior.filter(row=>metricAvailable(row,'cost')&&!metricPartial(row,'cost'));
- const costs=costRows.map(row=>Number(row.cost)||0),sessions=prior.map(row=>Number(row.sessions)||0);
- // A median of per-day rates keeps one burst of scripted sessions from swamping the baseline.
- const sessionCosts=costRows.map(row=>(Number(row.cost)||0)/Number(row.sessions));
- return {
-  days:prior.length,
-  typicalCost:medianOf(costs),highCost:costs.length?Math.max(...costs):0,
-  typicalSessions:medianOf(sessions),highSessions:sessions.length?Math.max(...sessions):0,
-  sessionCost:medianOf(sessionCosts),
-  estimated:costRows.some(row=>hasLocalEstimate(row)),
- };
-}
-function idleLabel(seconds){
- seconds=Math.max(0,Math.round(seconds||0));
- if(seconds<60) return seconds+'s idle';
- const minutes=Math.floor(seconds/60);
- if(minutes<60) return minutes+'m idle';
- const hours=Math.floor(minutes/60), rem=minutes%60;
- return hours+'h '+String(rem).padStart(2,'0')+'m idle';
-}
-function dt12(v){
- const s=String(v||'');
- if(/\b[ap]m\b/i.test(s)) return s.toLowerCase();
- return s.replace(/\b(\d{4}-\d{2}-\d{2}) (\d{2}):(\d{2}):(\d{2})\b/,(_,d,h,m,sec)=>{
-  const n=Number(h), hh=String(n%12||12).padStart(2,'0');
-  return `${d} ${hh}:${m}:${sec} ${n>=12?'pm':'am'}`;
- });
-}
-function costTipHtml(s,tok){
- if(!metricAvailable(s,'cost'))return `<div class=h>Cost unavailable</div><div class=note>${s.provider==='cursor'?'No supported public rate or input-context evidence was found for this Cursor trace.':'This trace does not expose enough pricing evidence.'}</div>`;
- const cost=s.cost||{};
- const rate=(usd,tokens)=>tokens?money((usd||0)*1e6/tokens):'$0.00';
- const row=(name,tokens,usd)=>tokens||usd?`<div class=r><span class=name>${name}</span><span class=formula>${f(tokens)} x ${rate(usd,tokens)} / 1M</span><span class=amt>${money(usd)}</span></div>`:'';
- const requestRow=(name,usd)=>usd?`<div class=r><span class=name>${name}</span><span class=formula>${f(Math.round(usd/.01))} x $0.01 / request</span><span class=amt>${money(usd)}</span></div>`:'';
- const cursor=s.provider==='cursor';
- const rows=(cursor?[
-  row('Input context proxy',tok.input||0,cost.input||0),
-  row('Visible model output',tok.output||0,cost.output||0),
- ]:[
-  row('Uncached input',tok.input||0,cost.input||0),
-  row('Cached input',tok.cache_read||0,cost.cache_read||0),
-  row('Cache write',tok.cache_write||0,cost.cache_write||0),
-  row('Output',tok.output||0,cost.output||0),
-  requestRow('Web searches',cost.server_tools||0),
- ]).join('');
- const note=s.source?.pricing_note||(cursor?'Local Cursor estimate; cache and hidden model work are excluded.':`${s.cost_approx?'Estimated with public API rates. ':''}Cached input is priced separately from uncached input.`);
- return `<div class=h>${cursor?'Local cost estimate':'Cost calculation'}</div>${rows}<div class=total><span>Total</span><span>${money(s.total_cost||0)}${s.cost_approx?' est':''}</span></div><div class=note>${esc(note)}</div>`;
-}
-let LATEST=null, CURRENT=null, pinned=null, sessionRequest=0, selectedPollId='', RUNTIME_CATALOG={};
-// Declared early: the first header render looks up trace titles before the All sessions code runs.
-let allSessionInventory=null,allSessionInventoryAt=0,allSessionsRequest=null,renderedAllSessions=new Map(),renderedAllSessionActions={},forceAllSessionRowRefresh=false;
-const LIVE_XSESSION={state:{snapshot:null,revision:''},session:{snapshot:null,revision:''}};
-let AGENT_ACCESS=null, pendingAgentAccess=null, agentAccessLoading=false, agentAccessRechecking=false;
-const CURRENT_SESSION_ORDER_KEY='tm_current_session_order_v1';
-const CURRENT_SESSION_ORDER_LIMIT=200;
-const CURRENT_SESSION_ORDER_MIGRATION_KEY='tm_current_session_newest_first_v1';
-let currentSessionOrder=loadCurrentSessionOrder();
-let currentSessionOrderNeedsNewestMigration=localStorage.getItem(CURRENT_SESSION_ORDER_MIGRATION_KEY)!=='1';
-let currentSessionRuntimeFilter='all',currentSessionActivityFilter='all';
-let currentSessionDragId='',currentSessionDropId='',currentSessionDropAfter=false;
-let currentSessionSuppressClickUntil=0;
-let currentSessionSeenIds=[],currentSessionSeenReady=false;
-const pageSignalReducedMotionQuery=window.matchMedia('(prefers-reduced-motion: reduce)');
-const pageSignalClockStartedAt=performance.now();
-let pageEffectsModulePromise=null,pageEffectsDisabled=false;
-let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
-let activePageSignalMounting=false,activePageSignalGeneration=0;
-let latestSessionSignalSnapshot=null;
-const usageDetails=$('usage-details');
-usageDetails.open=localStorage.getItem('tm_usage_details_open')==='1';
-usageDetails.addEventListener('toggle',()=>localStorage.setItem('tm_usage_details_open',usageDetails.open?'1':'0'));
-
-function routedSessionId(){
- const match=(location.pathname||'').match(/^\/sessions\/([^/]+)\/?$/);
- if(!match)return null;
- try{return decodeURIComponent(match[1]);}catch(e){return null;}
-}
-function sessionRoute(id){return `/sessions/${encodeURIComponent(id)}#summary`;}
-function stateSessionId(state){return state?.source?.id||String(state?.session||'').split('.')[0]||null;}
-function sessionRowKey(row){return String(row?.session||row?.id||'');}
-function stateSessionKey(state){return String(state?.session||stateSessionId(state)||'');}
-const DESKTOP_RESUME_ID=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function desktopSessionTarget(session){
- const source=session?.source||session||{},provider=String(source.provider||session?.provider||'').toLowerCase();
- if(provider==='codex'){
-  const id=String(source.id||session?.id||stateSessionId(session)||'').trim();
-  return id?{href:`codex://threads/${encodeURIComponent(id)}`,label:'Open in Codex',title:'Open this session in the Codex desktop app'}:null;
- }
- if(provider==='claude'){
-  const resume=String(source.desktop_resume_id||session?.desktop_resume_id||'');
-  return DESKTOP_RESUME_ID.test(resume)?{href:`claude://resume?session=${encodeURIComponent(resume)}`,label:'Open in Claude',title:'Open this session in the Claude desktop app'}:null;
- }
- return null;
-}
-function renderDesktopSessionLink(session){
- const link=$('session-desktop-link'),target=desktopSessionTarget(session);
- link.hidden=!target;
- if(target){
-  link.href=target.href;
-  link.textContent=target.label;
-  link.title=target.title;
-  link.setAttribute('aria-label',target.title);
- }else{
-  link.removeAttribute('href');
-  link.removeAttribute('title');
- }
-}
-function setHashRoute(route,{replace=false,apply=true}={}){
- const url=`${location.pathname}${location.search||''}#${route}`;
- if(history.pushState){
-  history[replace?'replaceState':'pushState'](null,'',url);
-  if(apply)applyHashRoute();
- }else location.hash=route;
-}
-function openSelectedSessionRoute(route='summary'){
- if(pinned&&history.pushState){
-  history.pushState({sessionScope:sessionReturnScope},'',sessionRoute(pinned));
-  applyHashRoute();
-  return;
- }
- setHashRoute(route);
-}
-const SESSION_SCOPES=['current','all','compare','subagents'];
-let sessionScope='current',sessionReturnScope='current';
-const COMPARE_MAX=4,COMPARE_LETTERS='ABCD',COMPARE_COLORS=THEME.compare;
-function loadCompareIds(){
- try{
-  const stored=JSON.parse(localStorage.getItem('tm_compare_ids')||'[]');
-  return Array.isArray(stored)?[...new Set(stored.map(String).filter(id=>id&&id.length<=240))].slice(0,COMPARE_MAX):[];
- }catch(error){return [];}
-}
-let compareIds=loadCompareIds(),compareBaseline=localStorage.getItem('tm_compare_baseline')||'';
-let compareChartMetric=localStorage.getItem('tm_compare_chart')==='tokens'?'tokens':'cost';
-let compareMissing=[],compareData=null,compareError='',compareLoading=false,compareRequestSeq=0,compareLoadedKey='',compareLoadedAt=0,compareNotice='';
-const compareTitles=new Map();
-let compareUiReady=false;
-function normalizeSessionScope(scope){return SESSION_SCOPES.includes(scope)?scope:'current';}
-function sessionScopeRoute(scope){scope=normalizeSessionScope(scope);return scope==='all'?'sessions-all':scope==='compare'?'sessions-compare':scope==='subagents'?'sessions-subagents':'sessions';}
-function sessionScopeLabel(scope){return {all:'All sessions',compare:'Compare',subagents:'Subagents'}[normalizeSessionScope(scope)]||'Current sessions';}
-function sessionListBackAvailable(scope){return !routedSessionId()&&(location.hash||'').replace(/^#/,'')===sessionScopeRoute(scope);}
-function renderSessionBack(){
- const label=sessionScopeLabel(sessionReturnScope);
- $('session-back-label').textContent=label;
- $('session-back').setAttribute('aria-label',`Back to ${label}`);
-}
-function openSessionBack(){
- const scope=normalizeSessionScope(sessionReturnScope),state=history.state;
- if(state?.sessionListBack&&normalizeSessionScope(state.sessionScope)===scope&&history.back){history.back();return;}
- openSessionScope(scope);
-}
-function sessionScopeCopy(scope){
- return {
-  all:['Local session history.','Search, filter, and compare local session history.'],
-  compare:['Selected sessions side by side.','Compare up to four selected sessions and see which is cheapest and fastest.'],
-  subagents:['Investigate child-agent spend, completion, and role patterns.','Filter child agents, inspect incomplete work, and open their parent sessions.'],
- }[scope]||['Last 30 minutes','Select a card to inspect it. Drag a card or press ⌥ and an arrow key to reorder.'];
-}
-function renderSessionScope(){
- const all=sessionScope==='all',subagents=sessionScope==='subagents',compare=sessionScope==='compare',overview=currentPanel==='sessions';
- $('view-session').classList.toggle('sessionAll',all);
- $('view-session').classList.toggle('sessionSubagents',subagents);
- $('view-session').classList.toggle('sessionCompare',compare);
- $('current-sessions-overview').hidden=all||subagents||compare;
- $('all-session-history').hidden=!all;
- $('session-compare').hidden=!compare;
- if($('subagent-explorer').parentElement===$('preview-surface-sessions'))$('subagent-explorer').hidden=!subagents;
- [...$('session-scope-tabs').querySelectorAll('[data-session-scope]')].forEach(button=>{
-  const selected=button.dataset.sessionScope===sessionScope;
-  button.setAttribute('aria-selected',String(selected));
-  button.classList.toggle('on',selected);
-  button.tabIndex=selected?0:-1;
- });
- if(overview){
-  const [description,help]=sessionScopeCopy(sessionScope);
-  $('current-description').textContent=description;
-  $('session-page-title').setAttribute('aria-description',help);
- }
- if(compareUiReady)syncCompareSelectionUi();
- if(compareUiReady&&compare&&overview){
-  renderComparison();
-  loadComparison();
-  if(!allSessionInventory)loadAllSessions();
- }
- if(all&&LATEST){
-  renderAllSessions(LATEST.xsession);
-  loadAllSessions();
- }
- if(subagents&&LATEST){renderSubagentExplorer(LATEST.xsession?.agent_usage);loadAllSessions();}
-}
-function setSessionScope(scope){
- sessionScope=normalizeSessionScope(scope);
- renderSessionScope();
-}
-function openSessionScope(scope,{replace=false}={}){
- if(scope==='subagents')mountSubagentExplorer('sessions');
- sessionRequest++;
- pinned=null;
- CURRENT=LATEST;
- sessionScope=normalizeSessionScope(scope);
- sessionReturnScope=sessionScope;
- const route=sessionScopeRoute(sessionScope);
- if(history.pushState)history[replace?'replaceState':'pushState'](null,'',`/#${route}`);
- else location.hash=route;
- applyHashRoute();
- return sessionScope==='all'?allSessionInventory||[]:sessionScope==='compare'?compareData?.sessions||[]:sessionScope==='subagents'?LATEST?.xsession?.agent_usage?.inventory||[]:LATEST?.xsession?.current_sessions||[];
-}
-
-// deck-pure-start: tour storage, slide copy, and frame markup. Nothing here touches the DOM, so tests run it in Node.
-const WELCOME_KEY='tm_welcome_v1';
-const LEGACY_ONBOARDING_KEY='tm_onboarding_v1';
-const LEARN_SLIDE_KEY='tm_learn_slide';
-// Reads one stored welcome record. Unreadable storage throws to the caller; corrupt JSON reads as absent.
-function readWelcomeStore(key){
- const raw=localStorage.getItem(key);
- if(!raw)return null;
- try{const value=JSON.parse(raw);return value&&typeof value==='object'?value:null;}catch(error){return null;}
-}
-// First launch only. Anyone who used the retired checklist (a step done, finished, or collapsed) has already met the product.
-// When storage cannot be read, a dismissal could not be remembered either, so the welcome stays out of the way.
-function welcomeShouldAutoShow(){
- try{
-  if(readWelcomeStore(WELCOME_KEY)?.seen===true)return false;
-  const legacy=readWelcomeStore(LEGACY_ONBOARDING_KEY);
-  if(legacy&&((Array.isArray(legacy.completed)&&legacy.completed.length>0)||legacy.completed===true||legacy.collapsed===true||Number(legacy.completed_at)>0))return false;
-  return true;
- }catch(error){return false;}
-}
-// A stored slide index is trusted only when it names a real slide; anything else starts at the beginning.
-function deckSlideIndex(value){
- if(typeof value!=='number'&&!(typeof value==='string'&&value.trim()))return 0;
- const index=Number(value);
- return Number.isInteger(index)&&index>=0&&index<DECK_SLIDES.length?index:0;
-}
-function readWelcomeProgress(){
- try{return deckSlideIndex(readWelcomeStore(WELCOME_KEY)?.last_slide);}catch(error){return 0;}
-}
-// An explicit slide (Learn's full-screen button) always wins. Otherwise a tour left partway offers to resume.
-function welcomeStartSlide(requested=null){
- if(requested!==null&&requested!==undefined)return {index:deckSlideIndex(requested),offer:false};
- const index=readWelcomeProgress();
- return {index,offer:index>0};
-}
-function recordWelcomeSlide(index){
- try{
-  const previous=readWelcomeStore(WELCOME_KEY),slide=deckSlideIndex(index);
-  localStorage.setItem(WELCOME_KEY,JSON.stringify(previous?.seen===true?{seen:true,dismissed_at:Number(previous.dismissed_at)||Date.now(),last_slide:slide}:{seen:false,last_slide:slide}));
- }catch(error){}
-}
-function markWelcomeSeen(lastSlide=0){
- try{localStorage.setItem(WELCOME_KEY,JSON.stringify({seen:true,dismissed_at:Date.now(),last_slide:deckSlideIndex(lastSlide)}));}catch(error){}
-}
-function readLearnSlide(){
- try{return deckSlideIndex(localStorage.getItem(LEARN_SLIDE_KEY));}catch(error){return 0;}
-}
-function saveLearnSlide(index){
- try{localStorage.setItem(LEARN_SLIDE_KEY,String(deckSlideIndex(index)));}catch(error){}
-}
-const DECK_PLATFORM=(()=>{const platform=String(navigator.userAgentData?.platform||navigator.platform||navigator.userAgent||'');return /mac/i.test(platform)?'mac':/win/i.test(platform)?'windows':/linux|x11|cros/i.test(platform)?'linux':'other';})();
-const COMPANION_PLACE={mac:'menu bar',windows:'notification area',linux:'tray'}[DECK_PLATFORM]||'menu bar or tray';
-// The only live facts the tour reads change behavior, never what a frame shows: frames always carry sample values.
-function deckFacts(state=LATEST){
- const budget=state?.xsession?.budget;
- return {budgetConfigured:!!(budget?.configured&&Number(budget.budget)>0)};
-}
-const DECK_ARROW='<svg class=deckArrow viewBox="0 0 16 16" aria-hidden=true><path d="M3 8h9M9 4l4 4-4 4"/></svg>';
-function levelBarHtml(fill,{label='',tone='',mark=null}={}){
- const at=value=>`${(100*Math.max(0,Math.min(1,value))).toFixed(1)}%`;
- return `<span class=levelBar${tone?` data-tone=${tone}`:''} role=img aria-label="${esc(label)}" style="--fill:${at(fill)}${mark==null?'':`;--mark:${at(mark)}`}"><i></i>${mark==null?'':'<b></b>'}</span>`;
-}
-// A numbered marker placed on a frame. `at` pins it to a corner or side of its nearest [data-callout] parent; without it, it sits inline.
-const calloutHtml=(number,at='')=>`<mark class=frameCallout${at?` data-at=${at}`:''} aria-hidden=true>${number}</mark>`;
-// One explained frame: a real dashboard component filled with sample values, numbered markers on it, and a matching numbered legend.
-function conceptFrameHtml(frame,host){
- const legend=frame.legend.map((text,index)=>`<li>${calloutHtml(index+1)}<span>${esc(text)}</span></li>`).join('');
- return `<figure class=conceptFrame data-frame=${frame.kind}${frame.anchor?` id=${host}-${frame.anchor}`:''}><div class=conceptFrameHead><span>${esc(frame.label)}</span><span class=chip>Example</span></div><div class=conceptFrameStage role=img aria-label="${esc(frame.alt)}">${frame.html()}</div><figcaption><ol class=frameLegend role=list>${legend}</ol></figcaption></figure>`;
-}
-// Sample sessions and spend for the frames: round numbers that make each idea obvious. Never the user's data.
-const sampleCardHtml=({title,model,cost,metrics,status='working',heroCallout=''})=>`<div class="card currentSessionCard activity-${status}" style="--harness:${providerColor('claude')}"><div class=currentSessionTop><div class=currentSessionRuntime>${runtimeMarkSvg({provider:'claude'})}<span>Claude Code</span><span class=currentSessionProject>website</span></div><div class=currentSessionTopMeta><div class="currentSessionStatus ${status}">${status==='working'?'Working':'Recent'}</div></div></div><div class=currentSessionIdentity><h3>${esc(title)}</h3><span class="currentSessionCaps mono">${esc(model)}</span></div><div class=currentSessionHero><div class=currentSessionHeroCost><span class=currentSessionHeroLabel>Cost</span><b class="currentSessionHeroValue mono">${esc(cost)} ${heroCallout}</b></div></div><div class=currentSessionMetrics>${metrics.map(([label,value,extra='',callout='',labelCallout=''])=>`<div class="currentSessionMetric metric"><span>${esc(label)}${labelCallout?` ${labelCallout}`:''}</span>${extra?`<div class=currentSessionContextValue><b class=mono>${esc(value)}</b>${extra}</div>`:`<b class=mono>${esc(value)}${callout?` ${callout}`:''}</b>`}</div>`).join('')}</div></div>`;
-// The real context sparkline: one bar per turn, toned as the chat fills.
-const SAMPLE_PRICES=[
- {label:'Re-reading (cache read)',price:.3,color:'var(--c-cache-read)'},
- {label:'Reading new text (input)',price:3,color:'var(--c-input)'},
- {label:'Saving to re-read (cache write)',price:3.75,color:'var(--c-cache-write)'},
- {label:'Writing the answer (output)',price:15,color:'var(--c-output)'},
-];
-const SAMPLE_SPEND_DAYS=[12,18,9,24,0,0,16,21,14,30,19,22];
-const SAMPLE_MODELS=[{name:'Opus',share:.7,cost:'$210.00'},{name:'Sonnet',share:.2,cost:'$60.00'},{name:'Haiku',share:.1,cost:'$30.00'}];
-const SAMPLE_OUTPUT_PER_DOLLAR=[2.6,2.8,2.7,3.2,3.1,3.6,3.5,4.1,4.3,4.8,4.7,5.4,5.6,6];
-const SAMPLE_HELPER_COST=[6,5.4,4.8,4.1,3.2,2.6,2.1,1.6,1.3,1];
-// Frame markup, one function per frame. Each takes no arguments, so no live value can reach it.
-function priceFrameHtml(){
- const max=SAMPLE_PRICES.at(-1).price,min=SAMPLE_PRICES[0].price;
- return `<div class=priceLadder>${SAMPLE_PRICES.map((row,index)=>`<div class=priceRow><span class=priceType><i style="--seg:${row.color}"></i>${esc(row.label)}</span>${levelBarHtml(row.price/max)}<b class=mono>${money(row.price)}</b><small class=mono>${esc(`${+(row.price/min).toFixed(1)}×`)}</small>${index===0?calloutHtml(1):index===SAMPLE_PRICES.length-1?calloutHtml(2):''}</div>`).join('')}</div>`;
-}
-function menuFrameHtml(){
- return `<div class=menuMock><div class=menuMockBar>${calloutHtml(1)}<span class=menuMockMark aria-hidden=true></span><b class=mono>$2.40 est</b><span class=mono>40%</span></div><dl class=menuMockRows><div><dt>This session</dt><dd class=mono>$2.40 est</dd></div><div data-callout><dt>Context</dt><dd class=mono>40%</dd>${calloutHtml(2,'r')}</div><div><dt>Spend today</dt><dd class=mono>$6.40</dd></div></dl></div>`;
-}
-const SAMPLE_TURN_COSTS=[.05,.07,.09,.12,.15,.19,.23,.28,.34,.41,.5,.62];
-function turnsFrameHtml(){
- // Headroom keeps the callout markers above the tallest bars inside the plot.
- const max=Math.max(...SAMPLE_TURN_COSTS)*1.3,last=SAMPLE_TURN_COSTS.length-1,first=SAMPLE_TURN_COSTS[0],end=SAMPLE_TURN_COSTS[last];
- const bars=SAMPLE_TURN_COSTS.map((cost,index)=>`<div class=spendDay><span class="spendBarValue mono"></span><span class=spendDayTrack${index===6||index===last?` data-callout style="--bar-h:${(100*cost/max).toFixed(1)}%"`:''}><span class=spendDayStack style="--spend-height:${(100*cost/max).toFixed(1)}%"><i class=spendStackSegment style="--spend-color:${providerColor('claude')};--segment-share:100%"></i></span>${index===6?calloutHtml(1,'bar'):index===last?calloutHtml(2,'bar'):''}</span><span class=spendDayLabel></span></div>`).join('');
- return `<div class=spendChart><div class=spendPlot><div class=spendChartInner>${bars}</div></div></div><div class=budgetMeterFoot><span>Turn 1 · <b class=mono>${money(first)}</b></span><span>Turn 40 · <b class=mono>${money(end)}</b></span></div><div class=budgetSpend><div class=budgetFigureLine><span class="budgetSpendValue mono">85%</span><span class=budgetOf>of what the AI can hold in mind</span></div><div class=budgetProgress><i style="width:85%"></i></div><div class=budgetMeterFoot><span>Context in use</span><span>${calloutHtml(3)} Nearly full</span></div></div>`;
-}
-function spendFrameHtml(){
- const max=Math.max(...SAMPLE_SPEND_DAYS);
- const bars=SAMPLE_SPEND_DAYS.map((cost,index)=>`<div class=spendDay><span class="spendBarValue mono"></span><span class=spendDayTrack${index===9?' data-callout':''}><span class=spendDayStack style="--spend-height:${cost?Math.max(3,100*cost/max).toFixed(1):0}%">${cost?`<i class=spendStackSegment style="--spend-color:${providerColor('claude')};--segment-share:100%"></i>`:''}</span>${index===9?calloutHtml(1,'t'):''}</span><span class=spendDayLabel>${index===0?'Oct 1':index===SAMPLE_SPEND_DAYS.length-1?'Oct 12':''}</span></div>`).join('');
- return `<div class=spendChart><div class=spendPlot><div class=spendChartInner>${bars}</div></div></div><div class=budgetSpend><div class=budgetFigureLine><span class="budgetSpendValue mono">$310</span><span class=budgetOf>of <b class=mono>$600</b></span></div><div class=budgetProgress><i style="width:52%"></i><span class=budgetProgressMarkers><span style="left:90%"></span></span></div><div class=budgetMeterFoot><span>Monthly budget · 52% used</span><span>${calloutHtml(2)} Lands near $540</span></div></div>`;
-}
-function modelsFrameHtml(){
- const colors=modelRankedColors(SAMPLE_MODELS.map(model=>({key:model.name,ids:[`${model.name}::Claude Code`]})));
- return `<div class=modelSpendHead><h2>Where your spend goes</h2><span class=modelSpendTotal>≈ $300.00 est.</span></div><div class=modelSpendBar>${SAMPLE_MODELS.map((model,index)=>`<div class=modelSpendSeg style="flex:${model.share} 1 0;background:${colors.get(model.name)}">${index===0?`<span>${esc(model.name)}</span><b>${Math.round(100*model.share)}%</b>`:''}</div>`).join('')}</div><div class=modelSpendLegend>${SAMPLE_MODELS.map((model,index)=>`<span class=modelSpendChip>${index===0?calloutHtml(1):index===2?calloutHtml(2):''}<i style="background:${colors.get(model.name)}"></i><span class=modelSpendChipName>${esc(model.name)}</span><b class=mono>${esc(model.cost)}</b><em>${Math.round(100*model.share)}%</em></span>`).join('')}</div>`;
-}
-function efficiencyFrameHtml(){
- const width=520,height=96,pad=8,max=6.6,points=SAMPLE_OUTPUT_PER_DOLLAR.map((value,index)=>[pad+index*(width-2*pad)/(SAMPLE_OUTPUT_PER_DOLLAR.length-1),pad+(height-2*pad)*(1-value/max)]);
- const line=points.map(([x,y],index)=>`${index?'L':'M'}${x.toFixed(1)} ${y.toFixed(1)}`).join(' '),last=points.at(-1),floor=height-pad;
- return `<div class="card efficiencyHeadline"><div class=efficiencyEyebrow>Output / $</div><div class="efficiencyValueRow valueWithDelta"><div class="v mono">6K / $</div><div class=trendDelta data-direction=up data-tone=improving data-callout><strong>↑ 50%</strong><span>vs prior 30 days</span>${calloutHtml(2,'r')}</div></div><div class=efficiencyChartWrap data-callout><svg class=efficiencyChart viewBox="0 0 ${width} ${height}" preserveAspectRatio=none aria-hidden=true><line class=efficiencyChartGrid x1="${pad}" x2="${width-pad}" y1="${floor}" y2="${floor}" vector-effect="non-scaling-stroke"/><path class=efficiencyChartArea d="${line} L${last[0].toFixed(1)} ${floor} L${pad} ${floor} Z"/><path class=efficiencyChartLine d="${line}" vector-effect="non-scaling-stroke"/></svg>${calloutHtml(1,'tr')}<div class=subagentRoleSparkDates><span>Sep 16</span><span>Oct 15</span></div></div></div>`;
-}
-function toolsFrameHtml(){
- const rows=[['Browser tools','0','12K tokens'],['Design kit','0','4K tokens']];
- return `<div class="card capReviewQueue warn"><div class=capQueueHead><h2>Needs review</h2><span class=capQueueCount>2 packs</span></div><div class=capReviewHead><span class=capReviewCols><span>Pack</span><span>Times used</span><span>Added to each request</span></span></div><div class=capReviewList>${rows.map(([name,use,load],index)=>`<div class=capReviewItem><div class=capReviewRow><div class=capReviewCols><span></span><span class=capReviewName><strong>${esc(name)}</strong></span><span class=capReviewNum>${esc(use)}${index?'':` ${calloutHtml(1)}`}</span><span class=capReviewNum>${esc(load)}${index?'':` ${calloutHtml(2)}`}</span></div></div></div>`).join('')}</div></div>`;
-}
-function helpersFrameHtml(){
- const width=220,height=62,pad=5,max=Math.max(...SAMPLE_HELPER_COST),x=index=>pad+index*(width-2*pad)/(SAMPLE_HELPER_COST.length-1),y=value=>height-pad-(value/max)*(height-2*pad);
- const line=SAMPLE_HELPER_COST.map((value,index)=>`${x(index).toFixed(1)},${y(value).toFixed(1)}`).join(' ');
- return `<div class=subagentRoleTrendList><div class=subagentRoleTrendRow><div class=subagentRoleIdentity><strong>explorer ${calloutHtml(2)}</strong><small>Claude Code · helper · 20 runs</small></div><div class="subagentRolePrimary good"><span>Cost / run</span><b>$1.00</b><small>was $6.00</small></div><div class=subagentRoleSpark data-callout><svg viewBox="0 0 ${width} ${height}" preserveAspectRatio=none aria-hidden=true><path d="M ${x(0).toFixed(1)} ${height-pad} L ${line.replaceAll(' ',', ')} L ${x(SAMPLE_HELPER_COST.length-1).toFixed(1)} ${height-pad} Z" style="fill:rgb(var(--signal-rgb)/.08)"/><polyline points="${line}" fill=none stroke="var(--accent)" stroke-width="2.2" vector-effect="non-scaling-stroke"/></svg><div class=subagentRoleSparkDates><span>Week 1</span><span>Week 4</span></div>${calloutHtml(1,'tr')}</div></div></div>`;
-}
-function compareFrameHtml(){
- const runs=[['A','Claude Opus','$0.40','12 steps · 4m'],['B','Claude Haiku','$0.10','11 steps · 3m']];
- return `<div class=compareCards style="grid-template-columns:repeat(2,minmax(0,1fr))">${runs.map(([letter,model,cost,meta],index)=>`<div class="card compareCard" style="--compare-color:${compareColor(index)}"${index?' data-callout':''}><div class=compareCardTop><span class=compareLetter>${letter}</span><span class=compareCardTitle>Fix the login test</span></div><div class=compareCardMeta>${esc(model)}</div><div class="compareCardCost mono">${esc(cost)} est</div><div class=compareCardMeta>${esc(meta)}</div>${index?calloutHtml(1,'tr'):''}</div>`).join('')}</div><div class="card compareSection"><h3>Where the cost went</h3><div class=compareBreakdown>${runs.map(([letter,,cost],index)=>`<div class=compareBreakdownRow${index?' data-callout':''}><span class=compareLetter style="--compare-color:${compareColor(index)}">${letter}</span><div class=compareBreakdownBar style="width:${index?20:100}%"><i style="width:100%;background:${compareColor(index)}"></i></div><b class=mono>${esc(cost)}</b>${index?calloutHtml(2,'r'):''}</div>`).join('')}</div></div>`;
-}
-function agentFrameHtml(){
- return `<div class=chatMock><p class=chatAsk data-callout>${calloutHtml(1,'l')}Am I on track this month?</p><p class=chatTool>Token Meter → numbers only ${calloutHtml(2)}</p><p class=chatAnswer>Yes. You've spent $310 of your $600 budget. At this pace the month lands near $540.</p><p class=chatTool>Change a session budget? → it asks you first ${calloutHtml(3)}</p></div>`;
-}
-// A frame-free visual for list slides: rows that each open the page where the habit is measured.
-const DECK_ICONS={
- model:'<path d="M5 5h6v6H5zM8 1v4M8 11v4M1 8h4M11 8h4"/>',
- load:'<path d="M2 5l6-3 6 3-6 3zM2 8l6 3 6-3M2 11l6 3 6-3"/>',
- stable:'<path d="M8 2v9M5 5h6M3 10a5 4 0 0 0 10 0"/>',
- done:'<circle cx="8" cy="8" r="6"/><path d="M5.5 8.2l1.8 1.8 3.4-3.6"/>',
- fresh:'<path d="M13 8a5 5 0 1 1-1.5-3.6M13 2v3h-3"/>',
-};
-const HABITS=[
- {icon:'model',title:'Pick the right model for the job',page:'Models',route:'models'},
- {icon:'load',title:'Load only the tools you need',page:'Tools',route:'capabilities'},
- {icon:'done',title:'Say what “done” looks like',page:'Compare',route:'sessions-compare'},
- {icon:'fresh',title:'Start fresh instead of arguing',page:'All sessions',route:'sessions-all'},
-];
-function habitsListHtml(){
- return `<ol class=leverList>${HABITS.map(habit=>`<li><button class=leverRow type=button data-deck-route=${habit.route}><svg class=leverIcon viewBox="0 0 16 16" aria-hidden=true>${DECK_ICONS[habit.icon]}</svg><span class=leverName><b>${esc(habit.title)}</b></span><small class=leverPage>${esc(habit.page)}<span class=srOnly>, opens this page</span></small>${DECK_ARROW}</button></li>`).join('')}</ol>`;
-}
-const TOKENOMICS_URL='https://www.splunk.com/en_us/products/tokenomics.html';
-function startListHtml(){
- return `${habitsListHtml()}<div class=teamsRow><span><span class=label>For teams</span><b>Splunk Tokenomics</b></span><a class=tbtn href="${TOKENOMICS_URL}" target=_blank rel="noopener noreferrer">Read about Tokenomics<span aria-hidden=true> ↗</span><span class=srOnly> (opens in a new tab)</span></a></div>`;
-}
-const DECK_CHAPTERS=[
- {id:'basics',title:'The basics'},
- {id:'work',title:'While you work'},
- {id:'review',title:'Review and find waste'},
- {id:'better',title:'Do better'},
-];
-// One slide set, two hosts: the welcome overlay and the Learn page render these same entries.
-// Word budget per slide: headline ≤ 8, optional body ≤ 14, one to three legend lines of ≤ 12 each, at most one link.
-// A frame shows a real dashboard component with sample values and carries an Example chip; list slides show rows instead.
-const DECK_SLIDES=[
- {id:'tokens',chapter:'basics',rail:'Tokens',kicker:'Current sessions',title:'You pay for every token the AI uses.',body:'Counted on your computer, never uploaded, and turned into dollars.',
-  frame:{kind:'session',label:'Session card',alt:'Example session card: Fix the login page, 1.2 million tokens, $2.40 estimated.',legend:['Tokens are small pieces of words. Every request is counted.','The cost is an estimate from public prices, not your bill.'],
-   html:()=>sampleCardHtml({title:'Fix the login page',model:'Claude Sonnet',cost:'$2.40 est',heroCallout:calloutHtml(2),metrics:[['Tokens','1.2M','',calloutHtml(1)],['Context in use','40%'],['Turns','12']]})},
-  links:[{label:'Open Current sessions',route:'sessions'}]},
- {id:'prices',chapter:'basics',rail:'Model pricing',kicker:'Model pricing',title:'Not every token costs the same.',
-  frame:{kind:'prices',label:'Price per 1M tokens',alt:'Example prices per million tokens: re-reading $0.30, new text $3.00, saving to re-read $3.80, writing the answer $15.00.',legend:['Re-reading what it already saw is the cheapest.','Writing the answer costs about 50 times more.'],html:priceFrameHtml},
-  links:[{label:'Open Model pricing',route:'model-pricing'}]},
- {id:'context',chapter:'work',rail:'Current sessions',kicker:'Current sessions',title:'Context in use: long chats cost more.',body:'Each turn, the AI re-reads the whole chat so far.',
-  frame:{kind:'context',label:'Cost per turn',alt:'Example chat of 40 turns: each turn costs more, from $0.10 for turn 1 to $0.60 for turn 40, and 85% of what the AI can hold in mind is in use.',legend:['The bars rise as the chat grows. Each turn costs more.','Turn 40 costs about 12 times turn 1.','Nearly full? Start fresh, or ask it to summarize.'],
-   html:()=>turnsFrameHtml()},
-  links:[{label:'Open Current sessions',route:'sessions'}]},
- {id:'glance',chapter:'work',rail:'Menu bar',kicker:'Menu bar',title:'See the live cost while you work.',body:`It sits in your ${COMPANION_PLACE}, always on.`,
-  frame:{kind:'menu',label:`Companion in the ${COMPANION_PLACE}`,alt:'Example companion: this session $2.40 estimated, context 40%, spend today $6.40.',legend:['The live cost of the session you are running.','How much the AI is holding in mind right now.'],html:menuFrameHtml},
-  links:[{label:'Open Current sessions',route:'sessions'}]},
- {id:'compare',chapter:'work',rail:'Compare',kicker:'Compare',title:'Compare: change one thing, run again.',body:'Pick two sessions of the same task and see what changed.',
-  frame:{kind:'compare',label:'Compare · two runs',alt:'Example comparison of the same task: run A with Claude Opus cost $0.40, run B with Claude Haiku cost $0.10.',legend:['Same task, one change: a lighter model.','B cost 80% less. Keep it if the result holds.'],html:compareFrameHtml},
-  links:[{label:'Open Compare',route:'sessions-compare'}]},
- {id:'month',chapter:'review',rail:'Spend',kicker:'Spend',title:'Spend: your month and your budget.',body:'Each day, and where the month will land.',
-  frame:{kind:'spend',label:'Spend · this month',alt:'Example month: daily spend bars, $310 spent of a $600 budget, projected to land near $540.',legend:['Each bar is one day of spending.','Where the month should land at this pace.'],html:spendFrameHtml},
-  links:[{label:'Open Spend',route:'spend-budgets'}]},
- {id:'models',chapter:'review',rail:'Models',kicker:'Models',title:'Models: one model is often most of it.',
-  frame:{kind:'models',label:'Models · spend by model',alt:'Example spend by model: Opus 70%, Sonnet 20%, Haiku 10%.',legend:['This one model is 70% of the spend.','A lighter model can do routine work for less.'],html:modelsFrameHtml},
-  links:[{label:'Open Models',route:'models'}]},
- {id:'efficiency',chapter:'review',rail:'Efficiency',kicker:'Efficiency',title:'Efficiency: more work for each dollar.',
-  frame:{kind:'efficiency',label:'Efficiency · output per dollar',alt:'Example efficiency: output per dollar rose 50% over 30 days.',legend:['A rising line means more work for each dollar.','The change compared with the 30 days before.'],html:efficiencyFrameHtml},
-  links:[{label:'Open Efficiency',route:'efficiency'}]},
- {id:'tools',chapter:'review',rail:'Tools',kicker:'Tools',title:'Tools: unused tools still cost you.',body:'Tool instructions ride along with every request.',
-  frame:{kind:'tools',label:'Tools · needs review',alt:'Example review list: Browser tools, used 0 times, adds 12 thousand tokens to every request.',legend:['Never used in your recent sessions.','Still sent with every request. Turn it off.'],html:toolsFrameHtml},
-  links:[{label:'Open Tools',route:'capabilities'}]},
- {id:'helpers',chapter:'review',rail:'Subagents',kicker:'Subagents',title:'Subagents: small helper jobs are cheap.',body:'Your agent can hand side jobs to helpers called subagents.',
-  frame:{kind:'helpers',label:'Subagents · cost per run',alt:'Example helper: cost per run fell from $6.00 to $1.00 over four weeks.',legend:['Cost per helper run fell from $6.00 to $1.00.','Short, clear jobs keep each run small.'],html:helpersFrameHtml},
-  links:[{label:'Open Subagents',route:'subagents'}]},
- {id:'agent',chapter:'better',rail:'Agent connection',kicker:'Agent connection',title:'Ask your AI agent about spending.',body:'Turn on Agent connection, and your agent can ask Token Meter (MCP).',
-  frame:{kind:'agent',anchor:'agent-access',label:'Chat with your agent',alt:'Example chat: Am I on track this month? Yes, $310 of $600, landing near $540.',legend:['Ask in plain words, in the chat you already use.','It gets numbers only, never your prompts or code.','Its AI provider sees those numbers; session-budget changes need your OK.'],html:agentFrameHtml},
-  links:[{label:'Open Agent connection',route:'settings',target:'agent-access'}]},
- {id:'start',chapter:'better',rail:'Get started',kicker:'Get started',title:'Four habits that lower the bill.',body:'Each habit opens the page that measures it.',visual:startListHtml,
-  links:[{label:facts=>facts.budgetConfigured?'Review your budget':'Set a monthly budget',route:'spend-budgets',primary:true}]},
-];
-function deckCopyHtml(index,facts,host){
- const slide=DECK_SLIDES[index];
- const links=(slide.links||[]).map(link=>`<button class=${link.primary?'deckPrimary':'tbtn'} type=button data-deck-route=${link.route}${link.target?` data-deck-target=${link.target}`:''}>${esc(typeof link.label==='function'?link.label(facts):link.label)}${DECK_ARROW}</button>`).join('');
- return `<span class=deckKicker>${esc(slide.kicker)}</span><h2 id=${host}-deck-title>${esc(slide.title)}</h2>${slide.body?`<p>${esc(slide.body)}</p>`:''}${links?`<div class=deckActions>${links}</div>`:''}`;
-}
-function deckVisualHtml(index,host){
- const slide=DECK_SLIDES[index];
- return slide.frame?conceptFrameHtml(slide.frame,host):`<div class=deckList>${slide.visual()}</div>`;
-}
-function deckRailHtml(index){
- return `<ol class=deckChapters>${DECK_CHAPTERS.map((chapter,number)=>{
-  const slides=DECK_SLIDES.map((slide,i)=>({slide,i})).filter(row=>row.slide.chapter===chapter.id);
-  const first=slides[0].i,last=slides.at(-1).i,state=index>last?'done':index>=first?'current':'upcoming';
-  return `<li class=deckChapter data-state=${state}><h3><span class=mono>${number+1}</span>${esc(chapter.title)}</h3><ol>${slides.map(({slide,i})=>{
-   const step=i<index?'done':i===index?'current':'upcoming';
-   return `<li><button class=deckStep type=button data-deck-go=${i} data-state=${step}${step==='current'?' aria-current=step':''} aria-label="${esc(`${i+1} of ${DECK_SLIDES.length}: ${slide.rail}${step==='done'?', done':''}`)}"><i aria-hidden=true>${step==='done'?'✓':step==='current'?'●':'○'}</i><span>${esc(slide.rail)}</span></button></li>`;
-  }).join('')}</ol></li>`;
- }).join('')}</ol>`;
-}
-// The first slide of the next chapter, or -1 in the last chapter.
-function deckChapterSkipTarget(index){
- const chapter=DECK_SLIDES[index]?.chapter;
- return DECK_SLIDES.findIndex((slide,i)=>i>index&&slide.chapter!==chapter);
-}
-const DECK_SECONDS_PER_SLIDE=18;
-function deckTimeLeft(index){
- const seconds=(DECK_SLIDES.length-index)*DECK_SECONDS_PER_SLIDE;
- if(index===0)return `about ${Math.round(seconds/60)} min`;
- return seconds<=60?'under a minute left':`about ${Math.round(seconds/60)} min left`;
-}
-function deckResumeHtml(index,host){
- return `<section class=deckSlide role=group aria-labelledby=${host}-deck-title><div class=deckCopy><span class=deckKicker>Welcome back</span><h2 id=${host}-deck-title>Pick up where you left off?</h2><p>${esc(`You stopped on slide ${index+1} of ${DECK_SLIDES.length}: ${DECK_SLIDES[index].rail}`)}</p><div class=deckActions><button class=deckPrimary type=button data-deck-action=resume>Resume where you left off${DECK_ARROW}</button><button class=tbtn type=button data-deck-action=restart>Start over</button></div></div></section>`;
-}
-// deck-pure-end
-// Writes preview markup only when it changes, and never while focus is inside it, so polling does not steal focus.
-function paintPreview(id,html){
- const root=$(id);
- if(!root||root.dataset.signature===html||root.contains(document.activeElement))return;
- root.dataset.signature=html;
- root.innerHTML=html;
-}
-let welcomeReturnFocus=null,welcomeAutoChecked=false,welcomeLeaving=false,welcomeFromLearn=false;
-const deckHosts={welcome:{index:0,offer:false},learn:{index:readLearnSlide(),offer:false}};
-function deckShellHtml(host){
- return `<nav class=deckRail id=${host}-deck-rail aria-label="Tour chapters"></nav><div class=deckMain><div class=deckStage id=${host}-deck-stage></div><footer class=deckFoot id=${host}-deck-foot><button class=deckSkip id=${host}-deck-skip-chapter type=button data-deck-action=skip-chapter>Skip chapter</button><span class="deckCount mono" id=${host}-deck-count aria-hidden=true></span><div class=deckNav><button class=tbtn id=${host}-deck-back type=button data-deck-action=back>Back</button><button class=deckPrimary id=${host}-deck-next type=button data-deck-action=next>Next</button></div></footer><p class=srOnly id=${host}-deck-status aria-live=polite></p></div>`;
-}
-function ensureDeck(host){
- const root=$(`${host}-deck`);
- if(root.dataset.mounted)return true;
- root.innerHTML=deckShellHtml(host);
- root.dataset.mounted='true';
- return false;
-}
-function paintDeck(host,state=LATEST){
- const current=deckHosts[host];
- if(current.offer||!$(`${host}-deck-copy`))return;
- paintPreview(`${host}-deck-copy`,deckCopyHtml(current.index,deckFacts(state),host));
- paintPreview(`${host}-deck-visual`,deckVisualHtml(current.index,host));
-}
-function showDeckSlide(host,index,{animate=true,offer=false}={}){
- ensureDeck(host);
- const current=deckHosts[host],total=DECK_SLIDES.length,rail=$(`${host}-deck-rail`),stage=$(`${host}-deck-stage`);
- const railFocused=rail.contains(document.activeElement),stageFocused=stage.contains(document.activeElement);
- current.index=Math.max(0,Math.min(total-1,Math.trunc(Number(index))||0));
- current.offer=offer;
- const slide=DECK_SLIDES[current.index],last=current.index===total-1;
- rail.innerHTML=deckRailHtml(current.index);
- stage.innerHTML=offer?deckResumeHtml(current.index,host):`<section class="deckSlide${animate?' deckEnter':''}" role=group aria-roledescription=slide aria-labelledby=${host}-deck-title><div class=deckCopy id=${host}-deck-copy></div><div class=deckVisual id=${host}-deck-visual></div></section>`;
- stage.scrollTop=0;
- $(`${host}-deck-foot`).hidden=offer;
- $(`${host}-deck-count`).textContent=`${current.index+1} / ${total} · ${deckTimeLeft(current.index)}`;
- $(`${host}-deck-status`).textContent=offer?`You stopped at slide ${current.index+1} of ${total}. Resume or start over.`:`Slide ${current.index+1} of ${total}: ${slide.rail}`;
- $(`${host}-deck-back`).disabled=current.index===0;
- $(`${host}-deck-skip-chapter`).disabled=deckChapterSkipTarget(current.index)<0;
- const next=$(`${host}-deck-next`);
- next.textContent=last?(host==='welcome'?'Done':'Back to start'):'Next';
- next.className=last?'tbtn':'deckPrimary';
- if(railFocused)rail.querySelector('[aria-current=step]')?.focus();
- else if(stageFocused)next.focus();
- if(offer)return;
- paintDeck(host);
- if(host==='welcome')recordWelcomeSlide(current.index);else saveLearnSlide(current.index);
-}
-function openDeckRoute(route,target=''){
- openTopLevelRoute(route);
- if(target)requestAnimationFrame(()=>$(target)?.scrollIntoView({block:'start'}));
-}
-function deckAction(host,action){
- const current=deckHosts[host],last=DECK_SLIDES.length-1;
- if(action==='back')showDeckSlide(host,current.index-1);
- else if(action==='next'){if(current.index<last)showDeckSlide(host,current.index+1);else if(host==='welcome')closeWelcome();else showDeckSlide(host,0);}
- else if(action==='skip-chapter'){const target=deckChapterSkipTarget(current.index);if(target>=0)showDeckSlide(host,target);}
- else if(action==='resume'||action==='restart'){showDeckSlide(host,action==='resume'?current.index:0);$(`${host}-deck-next`).focus();}
-}
-function renderWelcome(state=LATEST){paintDeck('welcome',state);}
-function renderLearn(state=LATEST){
- if(ensureDeck('learn'))paintDeck('learn',state);
- else showDeckSlide('learn',deckHosts.learn.index,{animate:false});
-}
-function openWelcome(index=null,{auto=false,returnFocus=null,fromLearn=false}={}){
- const dialog=$('welcome-dialog'),other=document.querySelector('dialog[open]');
- if(other&&other!==dialog){if(auto)return false;other.close();}
- showTourReturn(null);
- const start=welcomeStartSlide(index);
- welcomeFromLearn=fromLearn;
- showDeckSlide('welcome',start.index,{animate:false,offer:start.offer});
- if(!dialog.open){welcomeReturnFocus=returnFocus||document.activeElement;dialog.showModal();}
- requestAnimationFrame(()=>(start.offer?dialog.querySelector('[data-deck-action=resume]'):$('welcome-deck-next'))?.focus());
- return true;
-}
-// Leaving the tour through one of its links keeps a way back to the same slide.
-let tourReturn=null;
-const TOUR_RETURN_KEY='tm_tour_return';
-function showTourReturn(value){
- tourReturn=value;
- $('tour-return').hidden=!value;
- if(value)$('tour-return-label').textContent=value.host==='learn'?'Back to Learn':'Back to the tour';
- try{if(value)sessionStorage.setItem(TOUR_RETURN_KEY,JSON.stringify(value));else sessionStorage.removeItem(TOUR_RETURN_KEY);}catch(error){}
-}
-// Survives a reload, so the way back is still there after the page refreshes.
-function restoreTourReturn(){
- try{const value=JSON.parse(sessionStorage.getItem(TOUR_RETURN_KEY)||'null');if(value&&Number.isInteger(value.index)&&value.index>=0&&value.index<DECK_SLIDES.length)showTourReturn({index:value.index,hash:String(value.hash||''),host:value.host==='learn'?'learn':'welcome'});}catch(error){}
-}
-function returnToTour(){
- const value=tourReturn;
- showTourReturn(null);
- if(!value)return;
- if(value.host==='learn'){openTopLevelRoute('learn');showDeckSlide('learn',value.index,{animate:false});return;}
- openWelcome(value.index);
-}
-function closeWelcome({route='',target=''}={}){
- const dialog=$('welcome-dialog');
- welcomeLeaving=!!route;
- const from=dialog.open&&route?{index:deckHosts.welcome.index,hash:location.hash,host:'welcome'}:null;
- if(dialog.open)dialog.close();
- if(route){openDeckRoute(route,target);if(from)showTourReturn(from);}
-}
-function maybeAutoShowWelcome(){
- if(welcomeAutoChecked)return;
- welcomeAutoChecked=true;
- if(welcomeShouldAutoShow())openWelcome(null,{auto:true});
-}
-function deckKey(host,event){
- if(event.target?.closest?.('input,select,textarea,[contenteditable]')||event.metaKey||event.ctrlKey||event.altKey)return;
- const current=deckHosts[host];
- if(current.offer)return;
- if(event.key==='ArrowRight'&&current.index<DECK_SLIDES.length-1){event.preventDefault();showDeckSlide(host,current.index+1);}
- else if(event.key==='ArrowLeft'&&current.index>0){event.preventDefault();showDeckSlide(host,current.index-1);}
-}
-function handleWelcomeKey(event){deckKey('welcome',event);}
-// Learn pages with ←/→ only when focus is on the page itself or inside the deck.
-function handleLearnDeckKey(event){
- if(!$('view-learn').classList.contains('on')||document.querySelector('dialog[open]'))return;
- const active=document.activeElement;
- if(active&&active!==document.body&&!$('learn-deck').contains(active))return;
- deckKey('learn',event);
-}
-['welcome','learn'].forEach(host=>$(`${host}-deck`).addEventListener('click',event=>{
- const control=event.target.closest('[data-deck-go],[data-deck-action],[data-deck-route]');
- if(!control)return;
- if(control.dataset.deckGo!==undefined){showDeckSlide(host,Number(control.dataset.deckGo));return;}
- if(control.dataset.deckAction){deckAction(host,control.dataset.deckAction);return;}
- if(host==='welcome')closeWelcome({route:control.dataset.deckRoute,target:control.dataset.deckTarget||''});
- else{const from={index:deckHosts.learn.index,hash:location.hash,host:'learn'};openDeckRoute(control.dataset.deckRoute,control.dataset.deckTarget||'');showTourReturn(from);}
-}));
-$('welcome-close').onclick=()=>closeWelcome();
-$('welcome-skip').onclick=()=>closeWelcome();
-$('welcome-dialog').addEventListener('cancel',event=>{event.preventDefault();closeWelcome();});
-$('welcome-dialog').addEventListener('close',()=>{
- const index=deckHosts.welcome.index;
- markWelcomeSeen(index>=DECK_SLIDES.length-1?0:index);
- if(welcomeFromLearn&&!welcomeLeaving&&!deckHosts.welcome.offer)showDeckSlide('learn',index,{animate:false});
- welcomeFromLearn=false;
- const target=welcomeReturnFocus;
- welcomeReturnFocus=null;
- if(!welcomeLeaving&&target?.focus&&target.isConnected&&target.offsetParent!==null)target.focus();
- welcomeLeaving=false;
-});
-$('tour-return').onclick=returnToTour;
-restoreTourReturn();
-window.addEventListener('popstate',()=>{if(tourReturn&&location.hash===tourReturn.hash)returnToTour();});
-$('learn-play').onclick=()=>openWelcome(deckHosts.learn.index,{fromLearn:true});
-
-const THEMES=[
- {id:'classic',label:'Classic',tagline:'The original cyan instrument field'},
- {id:'nebula',label:'Nebula',tagline:'Ultraviolet glass with ion-cyan and mint highlights'},
- {id:'monolith',label:'Monolith',tagline:'Graphite and platinum with one vermilion tip'},
- {id:'voltage',label:'Voltage',tagline:'Volt yellow on carbon with cyan and magenta sparks'},
- {id:'phosphor',label:'Phosphor',tagline:'Terminal green with falling-code rain'},
- {id:'omarchy',label:'Omarchy',tagline:'Deep indigo with blue, violet, and sky neon'},
- {id:'jadehorse',label:'Jade Horse',tagline:'Deep pine surfaces with celadon jade and pale green-white text'},
- {id:'ferrous',label:'Ferrous',tagline:'Oxidized red rust with molten amber and coolant-teal sparks'},
- {id:'afterglow',label:'Afterglow',tagline:'Plum dusk with a pink-to-amber sunset horizon'},
-];
-const THEME_STORAGE_KEY='tm_theme';
-const normalizeThemeId=value=>THEMES.some(theme=>theme.id===value)?value:'classic';
-const themeLabel=id=>THEMES.find(theme=>theme.id===id)?.label||'Classic';
-const resolveTheme=preference=>window.tokenMeterTheme?.resolve(preference)||preference;
-let themePreference=(()=>{try{return normalizeThemeId(localStorage.getItem(THEME_STORAGE_KEY));}catch(error){return 'classic';}})();
-let activeTheme=document.documentElement.dataset.theme||'classic';
-function renderThemePicker(){
- const host=$('theme-picker');
- host.innerHTML=THEMES.map(theme=>`<button type=button class=themeOption aria-pressed=false data-theme-option="${theme.id}" title="${esc(theme.tagline)}" style="--theme-swatch:var(--swatch-${theme.id});--theme-swatch-bg:var(--swatch-${theme.id}-bg)"><span class=themePreview aria-hidden=true><i></i><i></i><i></i></span><span class=themeCopy><b>${esc(theme.label)}</b><small>${esc(theme.tagline)}</small></span></button>`).join('');
- paintThemePicker();
-}
-function paintThemePicker(){
- [...$('theme-picker').querySelectorAll('[data-theme-option]')].forEach(option=>{
-  option.setAttribute('aria-pressed',String(option.dataset.themeOption===themePreference));
- });
- $('theme-current-badge').textContent=themeLabel(activeTheme);
-}
-function repaintThemedSurfaces(){
- document.querySelector('meta[name=theme-color]')?.setAttribute('content',cssVar('--bg'));
- readChartTokens();
- if(activeModelStats&&activeModelScope===modelProject)renderModelStats(activeModelStats);
- if(activeEfficiencyStats&&activeEfficiencyScope===efficiencyProject)renderEfficiency(activeEfficiencyStats);
- if(CURRENT)drawIO(CURRENT.series||[]);
- if(spendInsightPayload)drawSpendScatter(spendInsightPayload.sessions||[]);
- if(deliveryPayload)drawDeliveryChart(deliveryPayload.days||[]);
- if(compareData)renderComparison();
- syncActivePageSignalEffects();
-}
-function setTheme(preference,{persist=true,origin=null}={}){
- preference=normalizeThemeId(preference);
- if(persist){try{localStorage.setItem(THEME_STORAGE_KEY,preference);}catch(error){}}
- themePreference=preference;
- const id=resolveTheme(preference);
- if(id===activeTheme){paintThemePicker();return;}
- activeTheme=id;
- paintThemePicker();
- // The latest choice wins even if an earlier transition callback is still queued.
- const commit=()=>{document.documentElement.dataset.theme=activeTheme;repaintThemedSurfaces();};
- if(!document.startViewTransition||pageSignalReducedMotionQuery.matches){commit();return;}
- const root=document.documentElement,generation=setTheme.revealGeneration=(setTheme.revealGeneration||0)+1;
- root.classList?.toggle('themeReveal',!!origin);
- const transition=document.startViewTransition(commit);
- // A pointer pick grows the new theme out of the option that was pressed.
- if(origin&&transition?.ready)transition.ready.then(()=>{
-  const radius=Math.hypot(Math.max(origin.x,innerWidth-origin.x),Math.max(origin.y,innerHeight-origin.y));
-  root.animate({clipPath:[`circle(0px at ${origin.x}px ${origin.y}px)`,`circle(${Math.ceil(radius)}px at ${origin.x}px ${origin.y}px)`]},{duration:480,easing:cssVar('--ease-in-out'),pseudoElement:'::view-transition-new(root)'});
- }).catch(()=>{});
- transition?.finished?.catch(()=>{}).finally(()=>{if(generation===setTheme.revealGeneration)root.classList.remove('themeReveal');});
-}
-renderThemePicker();
-document.querySelector('meta[name=theme-color]')?.setAttribute('content',getComputedStyle(document.documentElement).getPropertyValue('--bg').trim());
-$('theme-picker').onclick=event=>{const option=event.target.closest('[data-theme-option]');if(option)setTheme(option.dataset.themeOption,{origin:event.detail?{x:event.clientX,y:event.clientY}:null});};
-window.addEventListener('storage',event=>{if(event.key===THEME_STORAGE_KEY)setTheme(event.newValue,{persist:false});});
-
-const NAV_COMMANDS=[
- {id:'sessions',label:'Sessions',description:'Choose a recently active local session',section:'Navigate',action:'sessions'},
- {id:'all-sessions',label:'All sessions',description:'Search, filter, and open recorded session history',aliases:'logs',section:'Navigate',route:'sessions-all',glyph:'All'},
- {id:'compare-sessions',label:'Compare sessions',description:'Put selected sessions side by side',aliases:'diff same prompt runs',section:'Navigate',route:'sessions-compare',glyph:'A|B'},
- {id:'spend',label:'Spend',description:'Review spend across days and runtimes',section:'Navigate',route:'spend'},
- {id:'models',label:'Models',description:'Compare model spend, speed, and cache efficiency',section:'Navigate',route:'models'},
- {id:'subagents',label:'Subagents',description:'Track custom-agent spend and inspect child runs',section:'Navigate',route:'subagents'},
- {id:'efficiency',label:'Efficiency',description:'Review token efficiency overall and by model runtime',section:'Navigate',route:'efficiency'},
- {id:'work',label:'Work',description:'See where spend went, how sessions ended, and right-sizing',section:'Navigate',route:'work'},
- {id:'git',label:'Git',description:'Compare locally observed pushed code with covered AI spend',section:'Navigate',route:'git'},
- {id:'learn',label:'Learn',description:'Learn what drives cost and how to measure it',section:'Navigate',route:'learn'},
- {id:'capabilities',label:'Tools',description:'Inspect tools, MCPs, and optional skill packs',section:'Navigate',route:'capabilities'},
- {id:'settings',label:'Settings',description:'Configure pricing, analytics, connections, and updates',section:'Navigate',route:'settings'},
- {id:'spend-budgets',label:'Spend · Monthly budget',description:'Set runtime budgets and track their monthly total',section:'Navigate',route:'spend-budgets',glyph:'$'},
- {id:'spend-discounts',label:'Spend · Discounts',description:'Add the discount you pay so spend and budgets match your bill',section:'Navigate',route:'spend-discounts',glyph:'$'},
- {id:'session-run',label:'Session · Run',description:'Review cost, context, and pace for the selected session',section:'Selected session',route:'summary',action:'selected-session',glyph:'R'},
- {id:'appearance',label:'Settings · Appearance',description:'Choose the dashboard theme',aliases:'theme colors look',section:'Appearance',route:'settings-appearance',glyph:'◐'},
- ...THEMES.map(theme=>({id:`theme-${theme.id}`,label:`Theme · ${theme.label}`,description:theme.tagline,aliases:'appearance theme colors look',section:'Appearance',action:'theme',theme:theme.id,glyph:'◑'})),
- {id:'welcome',label:'Open welcome tour',description:'Replay the 12-slide tour of Token Meter pages',aliases:'getting started onboarding intro help tour',section:'Help',action:'welcome',glyph:'?'},
-];
-let visibleCommands=[],commandIndex=0,commandReturnFocus=null;
-function setCommandIndex(index,{scroll=true}={}){
- const items=[...$('command-list').querySelectorAll('[data-command-index]')];
- if(!items.length){commandIndex=0;$('command-search').removeAttribute('aria-activedescendant');return;}
- commandIndex=(index+items.length)%items.length;
- items.forEach((item,i)=>{const selected=i===commandIndex;item.classList.toggle('selected',selected);item.setAttribute('aria-selected',String(selected));});
- const active=items[commandIndex];
- $('command-search').setAttribute('aria-activedescendant',active.id);
- if(scroll)active.scrollIntoView({block:'nearest'});
-}
-function renderCommandPalette(query=''){
- const terms=query.trim().toLowerCase().split(/\s+/).filter(Boolean);
- visibleCommands=NAV_COMMANDS.filter(command=>{
-  if(command.id==='work'&&workSupported!==true)return false;
-  const haystack=`${command.label} ${command.description} ${command.aliases||''} ${command.section}`.toLowerCase();
-  return terms.every(term=>haystack.includes(term));
- });
- let section='';
- $('command-list').innerHTML=visibleCommands.length?visibleCommands.map((command,index)=>{
-  const heading=command.section!==section?`<div class=commandGroup role=presentation>${esc(command.section)}</div>`:'';
-  section=command.section;
-  return `${heading}<button class=commandItem id="command-option-${index}" type=button role=option aria-selected=false data-command-index="${index}"><span class=commandGlyph>${esc(command.action==='theme'&&command.theme===themePreference?'✓':command.glyph||'→')}</span><span class=commandCopy><span class=commandLabel>${esc(command.label)}</span><span class=commandDescription>${esc(command.description)}</span></span></button>`;
- }).join(''):'<div class="commandEmpty emptyState">No matching commands</div>';
- setCommandIndex(0,{scroll:false});
-}
-function openCommandPalette(){
- const dialog=$('command-palette'),other=document.querySelector('dialog[open]');
- if(other&&other!==dialog)return false;
- if(dialog.open)return true;
- commandReturnFocus=document.activeElement;
- $('command-search').value='';
- renderCommandPalette();
- dialog.showModal();
- requestAnimationFrame(()=>$('command-search').focus());
- return true;
-}
-function closeCommandPalette(){if($('command-palette').open)$('command-palette').close();}
-function runNavigationCommand(command){
- if(!command)return;
- closeCommandPalette();
- if(command.action==='welcome'){const returnFocus=commandReturnFocus;commandReturnFocus=null;openWelcome(null,{returnFocus});return;}
- if(command.action==='theme'){setTheme(command.theme);return;}
- if(command.action==='sessions'){openCurrentSessions();return;}
- if(command.action==='selected-session'){openSelectedSessionRoute(command.route);return;}
- if(command.latest)goToLatestSession();
- else openTopLevelRoute(command.route);
-}
-$('command-search').addEventListener('input',event=>renderCommandPalette(event.target.value));
-$('command-list').onclick=event=>{const item=event.target.closest('[data-command-index]');if(item)runNavigationCommand(visibleCommands[Number(item.dataset.commandIndex)]);};
-$('command-palette').addEventListener('click',event=>{if(event.target===$('command-palette'))closeCommandPalette();});
-$('command-palette').addEventListener('close',()=>{
- const target=commandReturnFocus;
- commandReturnFocus=null;
- if(target?.focus&&target.offsetParent!==null)target.focus();
-});
-document.addEventListener('keydown',event=>{
- const palette=$('command-palette'),key=String(event.key||'').toLowerCase();
- if($('welcome-dialog').open){handleWelcomeKey(event);return;}
- if((event.metaKey||event.ctrlKey)&&!event.altKey&&!event.shiftKey&&key==='k'){
-  event.preventDefault();
-  if(palette.open)closeCommandPalette();else openCommandPalette();
-  return;
- }
- if(palette.open){
-  if(event.key==='Escape'){event.preventDefault();closeCommandPalette();}
-  else if(event.key==='ArrowDown'){event.preventDefault();setCommandIndex(commandIndex+1);}
-  else if(event.key==='ArrowUp'){event.preventDefault();setCommandIndex(commandIndex-1);}
-  else if(event.key==='Enter'&&!event.isComposing){event.preventDefault();runNavigationCommand(visibleCommands[commandIndex]);}
-  return;
- }
- handleLearnDeckKey(event);
-});
-
-const PANEL_KEYS=['summary'];
-const PANEL_ALIAS={overview:'summary',flow:'summary',analysis:'summary',settings:'summary',activity:'summary',tools:'summary',alerts:'summary'};
-const CURRENT_PANEL_KEYS=['sessions','run'];
-const CURRENT_PANEL_ROUTES={sessions:'sessions',run:'summary'};
-const storedSessionPanel=PANEL_ALIAS[localStorage.getItem('tm_session_panel')]||localStorage.getItem('tm_session_panel')||'summary';
-let sessionPanel=PANEL_KEYS.includes(storedSessionPanel)?storedSessionPanel:'summary';
-let currentPanel=sessionPanel==='summary'?'run':sessionPanel;
-function restoreCurrentModules(){
- const homes=[
-  ['session-chart-home','session-chart-module'],
-  ['session-efficiency-home','session-efficiency'],
-  ['session-budget-home','session-budget-control'],
-  ['session-token-split-home','session-token-split-module'],
- ];
- homes.forEach(([homeId,moduleId])=>{const home=$(homeId),module=$(moduleId);if(home&&module&&module.parentElement!==home)home.appendChild(module);});
-}
-function mountCurrentModule(slotId,moduleId){
- const slot=$(slotId),module=$(moduleId);
- if(slot&&module&&module.parentElement!==slot)slot.appendChild(module);
-}
-function showCurrentPanel(panel){
- panel=PANEL_ALIAS[panel]||panel;
- if(panel==='summary')panel='run';
- if(!CURRENT_PANEL_KEYS.includes(panel))panel='run';
- currentPanel=panel;
- if(panel!=='sessions'){
-  sessionPanel=CURRENT_PANEL_ROUTES[panel];
-  localStorage.setItem('tm_session_panel',sessionPanel);
- }
- const overview=panel==='sessions';
- $('view-session').classList.toggle('sessionOverview',overview);
- $('view-session').classList.toggle('sessionDetail',!overview);
- document.querySelectorAll('[data-current-detail]').forEach(element=>element.classList.toggle('currentOverviewHidden',overview));
- if(!overview)renderSessionBack();
- $('session-page-title').textContent=overview?'Sessions':sessionDisplayName(CURRENT);
- const pageHelp=overview?sessionScopeCopy(sessionScope)[1]:'Review this session.';
- $('session-page-title').setAttribute('aria-description',pageHelp);
- $('session-page-title').dataset.tip=pageHelp;
- $('current-description').textContent=overview?sessionScopeCopy(sessionScope)[0]:(pinned?'Pinned run · updates every two seconds.':'Live run · updates with the trace.');
- CURRENT_PANEL_KEYS.forEach(key=>$(`preview-surface-${key}`).classList.toggle('on',key===panel));
- restoreCurrentModules();
- if(panel==='sessions'){
-  renderCurrentSessions();
-  renderSessionScope();
- }else if(panel==='run'){
- mountCurrentModule('preview-run-chart-slot','session-chart-module');
-  mountCurrentModule('preview-run-efficiency-slot','session-efficiency');
-  mountCurrentModule('preview-run-budget-slot','session-budget-control');
-  mountCurrentModule('preview-token-split-slot','session-token-split-module');
-  if(CURRENT)requestAnimationFrame(()=>drawIO(CURRENT.series||[]));
- }
-}
-
-function showTab(t){
- if(t!=='session')restoreCurrentModules();
- if(t!=='git')dismissGitChartInspector();
- const spend=t==='spend'||t==='daily';
- document.body.classList.toggle('sessionRoute',t==='session');
- $('tab-session').classList.toggle('on',t==='session');
-	 $('tab-models').classList.toggle('on',t==='models');
- $('tab-subagents').classList.toggle('on',t==='subagents');
- $('tab-daily').classList.toggle('on',spend);
- $('tab-capabilities').classList.toggle('on',t==='capabilities');
- $('tab-efficiency').classList.toggle('on',t==='efficiency');
- $('tab-work').classList.toggle('on',t==='work');
- $('tab-git').classList.toggle('on',t==='git');
- $('tab-learn').classList.toggle('on',t==='learn');
- $('tab-settings').classList.toggle('on',t==='settings');
- $('view-session').classList.toggle('on',t==='session');
-	 $('view-models').classList.toggle('on',t==='models');
- $('view-subagents').classList.toggle('on',t==='subagents');
- $('view-daily').classList.toggle('on',spend);
- $('view-capabilities').classList.toggle('on',t==='capabilities');
- $('view-efficiency').classList.toggle('on',t==='efficiency');
- $('view-work').classList.toggle('on',t==='work');
- $('view-git').classList.toggle('on',t==='git');
- $('view-learn').classList.toggle('on',t==='learn');
- $('view-settings').classList.toggle('on',t==='settings');
- [...document.querySelectorAll('.top .tab')].forEach(button=>{
-  if(button.id===(spend?'tab-daily':`tab-${t}`))button.setAttribute('aria-current','page');
-  else button.removeAttribute('aria-current');
- });
- const activeTop=$(spend?'tab-daily':`tab-${t}`);
- if(window.matchMedia('(max-width:760px)').matches&&activeTop?.scrollIntoView)requestAnimationFrame(()=>activeTop.scrollIntoView({block:'nearest',inline:'center'}));
- requestAnimationFrame(syncActivePageSignalEffects);
- const activeView=$(spend?'view-daily':`view-${t}`);
- requestAnimationFrame(()=>playRouteMotion(activeView));
-}
-function openTopLevelRoute(route){
- window.scrollTo(0,0);
- if(routedSessionId()&&history.pushState){history.pushState(null,'',`/#${route}`);applyHashRoute();return;}
- setHashRoute(route);
-}
-$('tab-session').onclick=()=>{window.scrollTo(0,0);openCurrentSessions();};
-$('tab-models').onclick=()=>openTopLevelRoute('models');
-$('tab-subagents').onclick=()=>openTopLevelRoute('subagents');
-$('tab-daily').onclick=()=>openTopLevelRoute('spend');
-$('tab-capabilities').onclick=()=>openTopLevelRoute('capabilities');
-$('tab-efficiency').onclick=()=>openTopLevelRoute('efficiency');
-$('tab-work').onclick=()=>openTopLevelRoute('work');
-$('tab-git').onclick=()=>openTopLevelRoute('git');
-$('tab-read').onclick=()=>window.open(TOKENOMICS_SEARCH_URL,'_blank','noopener');
-$('tab-learn').onclick=()=>openTopLevelRoute('learn');
-$('tab-settings').onclick=()=>openTopLevelRoute('settings');
-$('session-back').onclick=openSessionBack;
-$('session-scope-tabs').onclick=event=>{
- const button=event.target.closest('[data-session-scope]');
- if(button)openSessionScope(button.dataset.sessionScope);
-};
-$('session-scope-tabs').onkeydown=event=>{
- if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;
- event.preventDefault();
- const buttons=[...$('session-scope-tabs').querySelectorAll('[data-session-scope]')];
- const index=buttons.indexOf(event.target.closest('[data-session-scope]'));
- if(index<0)return;
- const next=event.key==='Home'?0:event.key==='End'?buttons.length-1:(index+(event.key==='ArrowRight'?1:-1)+buttons.length)%buttons.length;
- buttons[next].focus();
- openSessionScope(buttons[next].dataset.sessionScope);
-};
-$('view-settings').onclick=event=>{
- const targetButton=event.target.closest('[data-settings-target]');
- if(!targetButton)return;
- if(targetButton.dataset.settingsTarget==='update-settings'){setHashRoute('settings-updates');return;}
- if(targetButton.dataset.settingsTarget==='work-insights-settings'){setHashRoute('settings-work-insights');return;}
- if(targetButton.dataset.settingsTarget==='appearance-settings'){setHashRoute('settings-appearance');return;}
- $(targetButton.dataset.settingsTarget)?.scrollIntoView({behavior:'smooth',block:'start'});
-};
-
-showCurrentPanel(currentPanel);
-
-let GOALS=null,goalsLoading=null,goalsLoadedAt=0,goalDraft=null,goalPreviewRequest=0,goalsListModes={},goalModelRequest=0,goalModelTimer=0;
-const GOAL_STATUS_LABELS={on_track:'On track',at_risk:'At risk',met:'Met',missed:'Missed',no_result:'No result',ended:'Ended'};
-const GOAL_CONFIDENCE={complete:'Complete data',partial:'Partial data',estimated:'Estimated'};
-const GOAL_METRIC_HELP={
- tokens:'Processed input plus output tokens, including cache and reasoning once. Usage volume is not a productivity or quality score. Set At most for a cap or At least for a milestone.',
- spend:'Estimated cost of agent work in the period. Lower it with cheaper models, less reasoning, and shorter sessions.',
- output_per_dollar:'Output tokens for each dollar spent. It rises with cheaper models and better cache use. More output is not always better work.',
- cost_per_1k_lines:'What 1,000 pushed lines cost in agent spend, in the repositories your sessions ran in. Lower means more code shipped per dollar. Delivery evidence, not a quality score. Needs at least 50 lines.',
- context_load:'Tokens the agent reads for each token it writes. Lower it by starting fresh sessions and trimming the context you load.',
- reasoning_ratio:'Share of output spent on reasoning. Lower it by choosing a lower reasoning effort when a task does not need it. Sessions from runtimes that do not report reasoning tokens are left out.',
- frontier_share:'Share of spend on frontier models. Lower it by using mid range or efficient models for routine work. Spend on unrecognized models is shown separately.',
- work_pushback:'Share of labeled follow-ups where your next message pushed back, for one kind of work or all, and all models or chosen ones. Lower means the agent got it right more often. Local-model labels, so an estimate; a result needs 20 labeled follow-ups.',
- agent_per_human:'Agent turns (model calls) per message you typed, kept inside a range, for one kind of work or all, and all models or chosen ones. It counts only while pushback stays under the pushback goal with the same kind of work and models, so long runs that needed correcting never count as progress.',
-};
-const GOAL_PUSHED_SCOPE='All projects includes discovered repositories with both spend and measured Git coverage, across all apps and models. Lines pushed counts additions plus deletions. Sessions outside repository folders are not attributed.';
-function goalRepoText(count,names){
- if(!count)return 'no repositories';
- const shown=(names||[]).slice(0,3).join(', '),more=count-Math.min(count,3);
- return `${count} ${count===1?'repository':'repositories'}${shown?` (${shown}${more>0?`, +${more} more`:''})`:''}`;
-}
-function goalCoverageText(share){return share===null||share===undefined?'':`${share<1&&share>0?'under 1':Math.round(share)}% of your agent spend`;}
-function goalUnit(metric){return GOALS?.metrics?.[metric]?.unit||'';}
-function goalLabel(metric){return GOALS?.metrics?.[metric]?.label||metric;}
-function goalIsWork(metric){return (GOALS?.metrics?.[metric]?.scopes||[]).includes('work_type');}
-function goalTargetText(t,metric){
- if(t.comparison!=='between')return `${t.comparison==='at_most'?'≤':'≥'} ${goalValue(t.target,metric)}`;
- // A ratio range shares its ": 1", so it reads "32–48 : 1" rather than repeating it.
- const ratio=v=>Number(v).toLocaleString(undefined,{maximumFractionDigits:1});
- return goalUnit(metric)==='agent_ratio'?`${ratio(t.target)}–${ratio(t.target_high)} : 1`:`${goalValue(t.target,metric)} – ${goalValue(t.target_high,metric)}`;
-}
-function goalValue(value,metric){
- const v=Number(value);
- if(value===null||value===undefined||!Number.isFinite(v))return '--';
- const unit=goalUnit(metric);
- if(unit==='usd')return money(v);
- if(unit==='tokens')return `${compactNumber(v)} tokens`;
- if(unit==='tokens_per_usd')return `${compactNumber(v)} / $`;
- if(unit==='usd_per_1k_lines')return `${money(v)} / 1K lines`;
- if(unit==='percent')return `${v.toFixed(1)}%`;
- if(unit==='agent_ratio')return `${v.toLocaleString(undefined,{maximumFractionDigits:1})} : 1`;
- return efficiencyDecimal(v);
-}
-const GOAL_HOMES={spend:{route:'spend',section:'spend-goals',back:'Spend'},tokens:{route:'spend',section:'spend-goals',back:'Spend'},cost_per_1k_lines:{route:'git',section:'git-goals',back:'Git'},work_pushback:{route:'work',section:'work-goals',back:'Work'},agent_per_human:{route:'work',section:'work-goals',back:'Work'}};
-function goalHome(metric){return GOAL_HOMES[metric]||{route:'efficiency-goals',section:'efficiency-goals',back:'goals'};}
-function goalTitle(g){return g.title||`${goalLabel(g.metric)} for ${g.scope_label}`;}
-function goalIsCurrent(g){return !g.ended_at&&g.end>=(GOALS?.today||'');}
-function goalNotice(text,warn=false){
- document.querySelectorAll('.goalsNotice').forEach(el=>{
- el.textContent=text||'';
- el.hidden=!text;el.classList.toggle('tone-warn',warn);});
-}
-function goalHistory(g){
- if(!(g.history||[]).length)return '';
- const label=h=>new Date(h.start+'T12:00:00').toLocaleDateString(undefined,g.period==='week'?{month:'short',day:'numeric'}:{month:'short'});
- return `<div class=goalHistory aria-label="Previous periods">${g.history.map(h=>`<span class="chip goalStatus ${esc(h.status)}" title="${esc(goalValue(h.value,g.metric))}">${esc(label(h))} · ${esc(GOAL_STATUS_LABELS[h.status]||h.status)}</span>`).join('')}</div>`;
-}
-function goalGuardrail(g){
- const r=g.guardrail;
- if(!r||r.value===null||r.value===undefined)return '';
- const open=goalIsCurrent(g)&&r.metric==='spend';
- return `${goalLabel(r.metric)} ${goalValue(r.value,r.metric)}${open?' so far':''}${r.baseline!==null&&r.baseline!==undefined?` (${(r.baseline_label||'last period').toLowerCase()} ${goalValue(r.baseline,r.metric)})`:''}`;
-}
-function goalNotes(g){
- const m=g.measurement||{};
- return [g.metric==='cost_per_1k_lines'?`Across ${goalRepoText(m.projects||0,m.project_names)}`:'',
-  g.metric==='cost_per_1k_lines'&&m.observations?`${f(m.added)} added · ${f(m.deleted)} deleted`:'',
-  g.metric==='cost_per_1k_lines'&&m.counted_share!==null&&m.counted_share!==undefined?`Counts ${goalCoverageText(m.counted_share)}`:'',
-  m.unclassified_share?`Unrecognized models ${m.unclassified_share.toFixed(1)}% of spend`:'',
-  m.reasoning_excluded?`${m.reasoning_excluded} session${m.reasoning_excluded===1?'':'s'} without reported reasoning left out`:'',
-  m.cost_excluded?`${m.cost_excluded} session${m.cost_excluded===1?'':'s'} without reported cost left out`:'',
-  g.budget_reference?`Monthly budget ${money(g.budget_reference)}`:'',
-  m.guard?`Pushback ${goalValue(m.guard.value,'work_pushback')} vs its goal ≤ ${goalValue(m.guard.target,'work_pushback')}`:''].filter(Boolean);
-}
-function goalDateRange(g){
- const s=new Date(g.start+'T12:00:00'),e=new Date(g.end+'T12:00:00'),year=new Date((GOALS?.today||g.end)+'T12:00:00').getFullYear();
- const opts=d=>d.getFullYear()===year?{month:'short',day:'numeric'}:{month:'short',day:'numeric',year:'numeric'};
- const end=s.getMonth()===e.getMonth()&&s.getFullYear()===e.getFullYear()?String(e.getDate()):e.toLocaleDateString(undefined,opts(e));
- return `${s.toLocaleDateString(undefined,s.getFullYear()===e.getFullYear()&&s.getFullYear()===year?{month:'short',day:'numeric'}:opts(s))} – ${end}`;
-}
-function goalHistoryDots(g){
- if(!(g.history||[]).length)return '';
- const label=h=>new Date(h.start+'T12:00:00').toLocaleDateString(undefined,g.period==='week'?{month:'short',day:'numeric'}:{month:'short'});
- return `<span class=goalDots>${g.history.map(h=>{const t=`${label(h)}: ${GOAL_STATUS_LABELS[h.status]||h.status}, ${goalValue(h.value,g.metric)}`;return `<i class="goalStatus ${esc(h.status)}" role=img aria-label="${esc(t)}" title="${esc(t)}"></i>`;}).join('')}</span>`;
-}
-function goalCard(g){
- const m=g.measurement||{},value=m.value,range=g.comparison==='between',target=range?(Number(g.target)+Number(g.target_high))/2:Number(g.target),hasValue=value!==null&&value!==undefined;
- const top=Math.max(hasValue?Number(value):0,target,range?Number(g.target_high):0,Number(m.projected)||0)*1.15||1;
- const at=hasValue?Math.min(100,Number(value)/top*100):0,typ=Math.min(100,target/top*100);
- const tone=g.status==='at_risk'||g.status==='missed'?'high':'';
- const detail=g.status_reason||(m.projected!==undefined?`On pace for ${goalValue(m.projected,g.metric)}`:'');
- const targetText=goalTargetText(g,g.metric);
- const progressLabel=range?`${goalValue(value,g.metric)}, target ${targetText}`:`${goalValue(value,g.metric)} of ${g.comparison==='at_most'?'at most':'at least'} ${goalValue(target,g.metric)}`;
- const confidence=m.confidence&&m.confidence!=='complete'?GOAL_CONFIDENCE[m.confidence]||'':'';
- const meta=[g.title?g.scope_label:'',goalDateRange(g),g.repeat?`Repeats ${g.period==='week'?'weekly':g.period==='today'?'daily':'monthly'}`:''].filter(Boolean).join(' · ');
- const menu=`<details class=goalMenu><summary class=tbtn aria-label="More actions for ${esc(goalTitle(g))}">⋯</summary><div class="modelPickerMenu goalMenuList" role=group><button type=button data-goal-duplicate="${esc(g.id)}">Duplicate</button>${goalIsCurrent(g)?`<button type=button data-goal-end="${esc(g.id)}">End goal</button>`:''}<button type=button class=goalMenuDanger data-goal-delete="${esc(g.id)}">Delete</button></div></details>`;
- return `<article class="card goalCard" data-status="${esc(g.status)}"><div class=goalCardHead><h4><a class=goalTitleLink href="#efficiency-goals/${esc(g.id)}">${esc(goalTitle(g))}</a></h4><span class="chip goalStatus ${esc(g.status)}">${esc(GOAL_STATUS_LABELS[g.status]||g.status)}</span></div>`
-  +`<p class=goalMeta>${esc(meta)}</p>`
-  +`<div class=goalNumbers><strong class=mono>${esc(goalValue(value,g.metric))}</strong><span>Target ${esc(targetText)}</span>${confidence?`<span class=goalConfidence title="${esc(m.reason||'')}">${esc(confidence)}</span>`:''}</div>`
-  +`<span class=readoutScale role=img aria-label="${esc(progressLabel)}" data-tone="${tone}" style="--at:${at.toFixed(1)}%;--typ:${typ.toFixed(1)}%"><i class=readoutScaleFill></i><i class=readoutScaleTypical></i><i class=readoutScaleMark></i></span>`
-  +`<div class=goalFoot>${detail?`<span class=readoutCaption>${esc(detail)}</span>`:'<span></span>'}${goalHistoryDots(g)}<span class=goalActions><button class=tbtn type=button data-goal-edit="${esc(g.id)}">Edit</button>${menu}</span></div>`
-  +`</article>`;
-}
-const GOAL_SECTIONS={'spend-goals':'spend','git-goals':'delivery cost','efficiency-goals':'efficiency','work-goals':'work'};
-function renderGoalSection(section){
- const root=$(section),mode=goalsListModes[section]||'current',noun=GOAL_SECTIONS[section];
- const goals=(GOALS?.goals||[]).filter(g=>goalHome(g.metric).section===section),current=goals.filter(goalIsCurrent),previous=goals.filter(g=>!goalIsCurrent(g));
- root.querySelector('[data-goals-current]').innerHTML=current.length?current.map(goalCard).join(''):`<p class="emptyState goalsEmpty">No current ${esc(noun)} goals.</p>`;
- root.querySelector('[data-goals-previous]').innerHTML=previous.length?previous.map(goalCard).join(''):`<p class="emptyState goalsEmpty">No previous ${esc(noun)} goals.</p>`;
- root.querySelector('[data-goals-current]').hidden=mode!=='current';
- root.querySelector('[data-goals-previous]').hidden=mode!=='previous';
- root.querySelector('[data-goals-toggle]').textContent=mode==='previous'?'Current goals':`Previous goals${previous.length?` (${previous.length})`:''}`;
-}
-function renderGoals(){
- if(!GOALS)return;
- if(GOALS.dropped&&document.querySelector('.goalsNotice')?.hidden)goalNotice(`${GOALS.dropped} goal${GOALS.dropped===1?'':'s'} from an earlier version can no longer be shown and will be removed the next time you save a goal.`);
- Object.keys(GOAL_SECTIONS).forEach(renderGoalSection);
-}
-let goalSeedSent=false;
-async function seedDefaultGoals(){
- if(goalSeedSent||!GOALS?.seed_pending||!agentActionToken())return;
- goalSeedSent=true;
- const result=await postGoalAction({operation:'seed'});
- if(result.ok)acceptGoalResult(result);
-}
-async function loadGoals(force=false){
- if(!force&&GOALS&&Date.now()-goalsLoadedAt<30000){renderGoals();return GOALS;}
- if(goalsLoading)return goalsLoading;
- goalsLoading=(async()=>{
-  try{
-   const data=await (await fetch('/goals',{cache:'no-store'})).json();
-   if(data.ok){GOALS=data;goalsLoadedAt=Date.now();renderGoals();seedDefaultGoals();}
-   else goalNotice(data.error||'Goals are unavailable right now.',true);
-  }catch{goalNotice('Goals are unavailable right now.',true);}
-  finally{goalsLoading=null;}
-  return GOALS;
- })();
- return goalsLoading;
-}
-function goalSelectedScope(){
- const work=goalIsWork($('goals-metric').value),chosen=[...(goalDraft?.modelKeys||[])].sort();
- if(work)return {kind:'work_type',key:$('goals-work-type').value,...(chosen.length?{keys:chosen}:{})};
- const keys=[...(goalDraft?.modelKeys||[])].sort();
- if(keys.length===1)return {kind:'model',key:keys[0]};
- if(keys.length)return {kind:'models',key:'',keys};
- return $('goals-app').value?{kind:'agent',key:$('goals-app').value}:{kind:'all',key:''};
-}
-function renderGoalModelPicker(){
- if(!goalDraft)return;
- const keys=goalDraft.modelKeys||[],enabled=(GOALS.metrics?.[$('goals-metric').value]?.scopes||[]).includes('model')||goalIsWork($('goals-metric').value),picker=$('goals-model-picker'),summary=picker.querySelector('summary');
- summary.setAttribute('aria-disabled',String(!enabled));summary.tabIndex=enabled?0:-1;
- if(!enabled)picker.open=false;
- $('goals-model-summary').textContent=keys.length===0?'All models':keys.length===1?(goalDraft.models.find(m=>m.key===keys[0])?.label||'Model unavailable'):`${keys.length} models selected`;
- const choices=goalDraft.models||[],focused=document.activeElement?.closest('[data-goal-model]')?.dataset.goalModel;
- $('goals-model-options').innerHTML=`<label class="modelOption all"><input type=checkbox data-goal-model=all ${keys.length?'':'checked'} ${enabled?'':'disabled'}><span>All models</span></label>`+choices.map(m=>`<label class=modelOption title="${esc(m.label)}"><input type=checkbox data-goal-model="${esc(m.key)}" ${keys.includes(m.key)?'checked':''} ${enabled?'':'disabled'}><span>${esc(m.label)}</span></label>`).join('');
- if(focused)$('goals-model-options').querySelector(`[data-goal-model="${focused}"]`)?.focus();
- $('goals-model-search-field').hidden=!enabled;
- if(picker.open)requestAnimationFrame(positionGoalModelPicker);
-}
-function fillGoalScopes(metric,scope={kind:'all',key:''}){
- const work=goalIsWork(metric);
- $('goals-app-field').hidden=work;$('goals-work-field').hidden=!work;
- $('goals-work-type').innerHTML=(GOALS.work_types||[]).map(w=>`<option value="${esc(w.id)}">${esc(w.label)}</option>`).join('');
- if(scope.kind==='work_type'&&scope.key)$('goals-work-type').value=scope.key;
- const scopes=GOALS.metrics?.[metric]?.scopes||['all'],keys=scope.kind==='models'||scope.kind==='work_type'?scope.keys||[]:scope.kind==='model'?[scope.key]:[],known=[...(GOALS.models||[]),...(goalDraft.models||[])],model=known.find(m=>m.key===scope.key),app=scope.kind==='agent'?scope.key:scope.kind==='model'?model?.runtime||'':'';
- $('goals-app').innerHTML='<option value="">All apps</option>'+(scopes.includes('agent')?(GOALS.agents||[]).map(a=>`<option value="${esc(a.id)}">${esc(a.label)}</option>`).join(''):'');
- $('goals-app').value=app;$('goals-app').disabled=!scopes.includes('agent');
- goalDraft.modelKeys=scopes.includes('model')||work?[...keys]:[];
- goalDraft.models=(GOALS.models||[]).filter(m=>!app||m.runtime===app);
- for(const key of goalDraft.modelKeys)if(!goalDraft.models.some(m=>m.key===key))goalDraft.models.push(known.find(m=>m.key===key)||{key,runtime:'',label:'Model unavailable — remove to choose another'});
- $('goals-model-search').value='';renderGoalModelPicker();refreshGoalModels();
-}
-async function refreshGoalModels(){
- const request=++goalModelRequest;
- if(!goalDraft||!((GOALS.metrics?.[$('goals-metric').value]?.scopes||[]).includes('model')||goalIsWork($('goals-metric').value)))return;
- const params=new URLSearchParams({models:'1',runtime:$('goals-app').value,query:$('goals-model-search').value});
- $('goals-model-note').textContent='Reading observed models…';
- let data;try{data=await(await fetch(`/goals?${params}`,{cache:'no-store'})).json();}catch{data={ok:false};}
- if(request!==goalModelRequest||!goalDraft)return;
- if(!data.ok){$('goals-model-note').textContent='Model choices are unavailable. Existing selection is preserved.';return;}
- const previous=goalDraft.models||[],choices=[...(data.models||[])];
- for(const key of goalDraft.modelKeys||[])if(!choices.some(m=>m.key===key))choices.push(previous.find(m=>m.key===key)||{key,runtime:'',label:'Model unavailable — remove to choose another'});
- goalDraft.models=choices;renderGoalModelPicker();
- $('goals-model-note').textContent=`${data.models.length} of ${data.total} models, by recent spend · up to ${GOALS.max_selected_models||32}`;
-}
-function positionGoalModelPicker(){
- const picker=$('goals-model-picker'),menu=$('goals-model-menu');if(!picker.open){picker.classList.remove('opensUp');menu.style.maxHeight='';return;}
- const rect=picker.querySelector('summary').getBoundingClientRect(),margin=12,above=Math.max(0,rect.top-margin),below=Math.max(0,window.innerHeight-rect.bottom-margin),preferred=Math.min(360,menu.scrollHeight||360),opensUp=below<preferred&&above>below;
- picker.classList.toggle('opensUp',opensUp);menu.style.maxHeight=`${Math.min(360,opensUp?above:below)}px`;
-}
-function goalPeriodFields(){
- const choice=$('goals-period').value;
- if(choice==='week'||choice==='month')return {period:choice,start:goalDraft?.anchor||'',end:''};
- if(choice==='custom')return {period:'custom',start:$('goals-start').value,end:$('goals-end').value};
- const count={today:1,next7:7,next30:30,next90:90}[choice]||1;
- return {period:'custom',start:GOALS.today,end:spendShiftDay(GOALS.today,count-1)};
-}
-function openGoalForm(preset={},duplicate=false,section=goalHome(preset.metric).section){
- if(!GOALS)return;
- const metrics=Object.entries(GOALS.metrics).filter(([id])=>goalHome(id).section===section),metric=preset.metric||metrics[0]?.[0]||'spend';
- goalDraft={id:duplicate?'':preset.id||'',option:'',wantedOption:duplicate?'custom':preset.target_option||'',autoTitle:preset.id?'':(preset.title||''),saved:preset.id?{comparison:preset.comparison,target:preset.target,target_high:preset.target_high}:null,anchor:!duplicate&&preset.id&&preset.period!=='custom'?preset.start:'',returnMode:goalsListModes[section]||'current',section};
- $('goals-metric').disabled=metrics.length<2;
- $('goals-metric').innerHTML=metrics.map(([id,m])=>`<option value="${esc(id)}">${esc(m.label)}</option>`).join('');
- $('goals-metric').value=metric;
- $('goals-metric-options').innerHTML=metrics.map(([id,m])=>`<button class=goalOption type=button data-goal-metric="${esc(id)}" title="${esc(GOAL_METRIC_HELP[id]||'')}">${esc(m.label)}</button>`).join('');
- fillGoalScopes(metric,preset.scope);
- $('goals-period').value=preset.period||'month';
- $('goals-repeat').checked=!!preset.repeat;
- const today=GOALS.today,length=duplicate&&preset.period==='custom'?Math.round((Date.parse(preset.end+'T12:00:00Z')-Date.parse(preset.start+'T12:00:00Z'))/864e5):29;
- $('goals-start').value=duplicate?today:preset.start||today;$('goals-end').value=duplicate?spendShiftDay(today,length):preset.end||spendShiftDay(today,29);
- $('goals-title').value=preset.title||'';
- $('goals-comparison').value='';$('goals-target').value='';$('goals-target-high').value='';
- $('goals-form-heading').textContent=duplicate?'Duplicate goal':preset.id?'Edit goal':'New goal';
- goalFormError('');
- if(!$('goals-dialog').open)$('goals-dialog').showModal();
- updateGoalFormFields();
- refreshGoalPreview();
- $('goals-form-heading').focus({preventScroll:true});
-}
-function clearAutoTitle(){if(goalDraft?.autoTitle&&$('goals-title').value===goalDraft.autoTitle){$('goals-title').value='';goalDraft.autoTitle='';}}
-function updateGoalFormFields(){
- const metric=$('goals-metric').value,{period}=goalPeriodFields(),locked=$('goals-metric').disabled;
- $('goals-metric-options').querySelectorAll('[data-goal-metric]').forEach(button=>{button.setAttribute('aria-pressed',String(button.dataset.goalMetric===metric));button.disabled=locked&&button.dataset.goalMetric!==metric;});
- $('goals-metric').title=`${GOAL_METRIC_HELP[metric]||''}${metric==='cost_per_1k_lines'?` ${GOAL_PUSHED_SCOPE}`:''}`;
- $('goals-dates').hidden=$('goals-period').value!=='custom';
- $('goals-repeat-field').hidden=period==='custom';
- $('goals-repeat-unit').textContent=period==='week'?'weekly':'monthly';
- $('goals-target').max=goalUnit(metric)==='percent'?'100':goalUnit(metric)==='tokens'?String(Number.MAX_SAFE_INTEGER):'';
- $('goals-target').step=goalUnit(metric)==='tokens'?'1':'any';
- renderGoalPreview();
-}
-function goalPreviewScope(metric){
- if(metric==='cost_per_1k_lines')return 'All projects';
- if(goalIsWork(metric))return `${$('goals-work-type').selectedOptions[0]?.textContent||'All kinds of work'}${goalDraft?.modelKeys?.length?` · ${$('goals-model-summary').textContent}`:''}`;
- const app=$('goals-app'),appLabel=app.value?app.selectedOptions[0]?.textContent||'':'All apps';
- return goalDraft?.modelKeys?.length?`${app.value?`${appLabel} · `:''}${$('goals-model-summary').textContent}`:appLabel;
-}
-function goalDraftTarget(){
- if(goalDraft?.option==='custom'){
-  const comparison=$('goals-comparison').value,raw=$('goals-target').value,target=Number(raw),high=Number($('goals-target-high').value);
-  if(comparison==='between')return raw!==''&&$('goals-target-high').value!==''&&Number.isFinite(target)&&Number.isFinite(high)?{comparison,target,target_high:high,label:'Custom'}:null;
-  return comparison&&raw!==''&&Number.isFinite(target)?{comparison,target,label:'Custom'}:null;
- }
- return (goalDraft?.options||[]).find(o=>o.id===goalDraft.option)||null;
-}
-function renderGoalPreview(){
- if(!goalDraft)return;
- const metric=$('goals-metric').value,p=goalDraft.preview||{loading:true},b=p.baseline||{},t=goalDraftTarget(),{period}=goalPeriodFields(),{kind,key}=goalSelectedScope();
- const now=p.ok?b.value:null,hasNow=now!==null&&now!==undefined;
- const scope=goalPreviewScope(metric),auto=`${goalLabel(metric)} for ${scope}`,title=$('goals-title').value.trim()||auto;
- $('goals-title').placeholder=auto;
- const repeat=period!=='custom'&&$('goals-repeat').checked;
- const meta=[title!==auto?scope:'',p.start&&p.end?goalDateRange({start:p.start,end:p.end}):'',repeat?`Repeats ${period==='week'?'weekly':'monthly'}`:''].filter(Boolean).join(' · ');
- const cumulative=GOALS.metrics?.[metric]?.cumulative;
- const nowNote=p.loading?'Checking…':!p.ok?(p.error||'Unavailable'):hasNow?[`${b.label||'Previous period'}${cumulative?(b.source==='so_far'?', projected':', scaled'):''}`,b.estimated?'estimated':'',b.complete===false?'partial':''].filter(Boolean).join(' · '):'No data yet';
- const aim=t?(t.comparison==='between'?(t.target+t.target_high)/2:t.target):null,change=hasNow&&t&&now>0?(aim-now)/now*100:null;
- const readout=(label,value,note,extra='')=>`<div class="metric goalPreviewReadout"${extra}><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
- const help=$('goals-metric').title,lead=(GOAL_METRIC_HELP[metric]||'').split(/(?<=\.)\s/)[0];
- const allocations=GOALS?.budget_allocations||{},allocation=metric!=='spend'||period!=='month'?0:kind==='all'?Object.values(allocations).reduce((a,v)=>a+v,0):kind==='agent'?Number(allocations[key]||0):0;
- const notes=[];
- if(allocation>0)notes.push(`Your ${money(allocation)} monthly budget keeps its own alerts`);
- if(metric==='cost_per_1k_lines'&&p.ok){const coverage=goalCoverageText(b.counted_share);notes.push(`Across ${goalRepoText(b.project_count||0,b.projects)}${coverage?` · covers ${coverage}`:''}`);if(!b.project_count||b.counted_share!==null&&b.counted_share!==undefined&&b.counted_share<50)notes.push('Low coverage: check Repository evidence after saving');}
- if(p.ok&&!hasNow)notes.push('No current value, so choose Custom to set a target');
- if(metric==='agent_per_human'){// Same rule as the server: the newest pushback goal, not ended, with the same scope, whose dates overlap.
-const models=JSON.stringify(goalSelectedScope().keys||[]),ceiling=(GOALS?.goals||[]).filter(g=>g.metric==='work_pushback'&&!g.ended_at&&g.scope?.key===key&&JSON.stringify(g.scope?.keys||[])===models&&(!p.start||g.series_start<=p.end&&(g.repeat||g.end>=p.start))).sort((a,b)=>String(b.created_at).localeCompare(String(a.created_at)))[0];notes.push(ceiling?`Counts while pushback stays ${goalTargetText(ceiling,'work_pushback')} (its pushback goal)`:'Counts only with a pushback goal for the same kind of work and models: add one too');}
- $('goals-preview').innerHTML=`<span class=goalPreviewKicker>Preview</span><div><h4>${esc(title)}</h4>${meta?`<p class=goalMeta>${esc(meta)}</p>`:''}</div>`
-  +`<div class=goalPreviewLedger>${readout('Now',hasNow?goalValue(now,metric):'--',nowNote,!hasNow&&b.reason?` title="${esc(b.reason)}"`:'')}${readout('Target',t?goalTargetText(t,metric).replace(/ : 1$/,''):'--',t?t.label:'Choose below')}${readout('Change',change===null?'--':`${change>0?'+':change<0?'−':''}${Math.abs(change).toFixed(0)}%`,'vs now')}</div>`
-  +(hasNow&&t?readoutScaleHtml({value:now,typical:aim,label:`Now ${goalValue(now,metric)}, target ${goalTargetText(t,metric)}`,toned:false}):'')
-  +(lead?`<span class=readoutCaption title="${esc(help)}">${esc(lead)}</span>`:'')
-  +notes.map(n=>`<span class="goalsHelp goalPreviewNote">${esc(n)}</span>`).join('');
-}
-async function refreshGoalPreview(){
- const request=++goalPreviewRequest,metric=$('goals-metric').value,{kind,key,keys}=goalSelectedScope(),{period,start,end}=goalPeriodFields();
- const params=new URLSearchParams({preview:'1',metric,scope_kind:kind,scope_key:key||'',period});
- if(keys?.length)params.set('scope_keys',JSON.stringify(keys));
- goalDraft.start='';goalDraft.end='';$('goals-save').disabled=true;
- if(period==='custom'){params.set('start',start);params.set('end',end);}
- else if(goalDraft.anchor)params.set('start',goalDraft.anchor);
- goalDraft.preview={loading:true};renderGoalPreview();
- let data;
- try{data=await (await fetch(`/goals?${params}`,{cache:'no-store'})).json();}catch{data={ok:false,error:'The previous period is unavailable.'};}
- if(request!==goalPreviewRequest||!goalDraft)return;
- goalDraft.options=data.ok?data.options:[];
- goalDraft.start=data.start||'';goalDraft.end=data.end||'';
- $('goals-save').disabled=false;
- const b=data.baseline||{};
- goalDraft.current=data.ok?b.value:null;
- goalDraft.preview=data;
- if(goalDraft.wantedOption){
-  const wanted=goalDraft.options.find(o=>o.id===goalDraft.wantedOption),saved=goalDraft.saved;
-  // Editing keeps the saved number; an option is reselected only if it still produces that number.
-  if(wanted&&(!saved||wanted.target===saved.target&&wanted.comparison===saved.comparison&&wanted.target_high===saved.target_high))goalDraft.option=wanted.id;
-  else if(saved){goalDraft.option='custom';$('goals-comparison').value=saved.comparison;$('goals-target').value=saved.target;$('goals-target-high').value=saved.target_high??'';}
-  goalDraft.wantedOption='';
- }
- if(goalDraft.option&&goalDraft.option!=='custom'&&!goalDraft.options.some(o=>o.id===goalDraft.option))goalDraft.option='';
- renderGoalOptions();
-}
-function renderGoalOptions(focus=false){
- const metric=$('goals-metric').value,direction=GOALS.metrics?.[metric]?.direction||'';
- const chip=(id,label,detail)=>`<button class=goalOption type=button aria-pressed=${goalDraft.option===id?'true':'false'} data-goal-option="${esc(id)}">${esc(label)}<small>${esc(detail)}</small></button>`;
- $('goals-options').innerHTML=goalDraft.options.map(o=>chip(o.id,o.label,goalTargetText(o,metric))).join('')+chip('custom','Custom',direction==='between'?'Your own range':'Your own number');
- $('goals-custom').hidden=goalDraft.option!=='custom';
- // Metrics with only one sensible direction fix Custom's direction too.
- if(!direction&&$('goals-comparison').disabled)$('goals-comparison').value='';
- $('goals-comparison').disabled=!!direction;
- if(direction)$('goals-comparison').value=direction;
- $('goals-target-high').hidden=direction!=='between';
- $('goals-target').setAttribute('aria-label',direction==='between'?'Lower end of the range':'Target value');
- updateGoalTargetNote();
- $('goals-comparison').title=direction==='between'?`Keep ${goalLabel(metric)} inside a range`:direction?`${direction==='at_most'?'Lower':'Higher'} is better for ${goalLabel(metric)}`:'';
- if(focus)$('goals-options').querySelector(`[data-goal-option="${goalDraft.option}"]`)?.focus();
- renderGoalPreview();
-}
-function chooseGoalOption(id,focus=false){
- if(!goalDraft)return;
- if(id!==goalDraft.option)clearAutoTitle();
- goalDraft.option=id;goalFormError('');renderGoalOptions(focus);
-}
-function updateGoalTargetNote(){
- const note=$('goals-target-note'),raw=$('goals-target').value,value=Number(raw);
- note.hidden=goalUnit($('goals-metric').value)!=='tokens'||goalDraft?.option!=='custom';
- note.textContent=raw!==''&&Number.isSafeInteger(value)&&value>=0?`= ${compactNumber(value)} tokens`:'Whole tokens, e.g. 1000000000 for 1B';
-}
-function goalFormError(text){$('goals-form-error').textContent=text;$('goals-form-error').hidden=!text;}
-async function postGoalAction(payload){
- const token=agentActionToken();
- if(!token)return {ok:false,error:'Token Meter is still loading. Try again in a moment.'};
- try{
-  const response=await fetch('/goals',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify(payload)});
-  return await response.json();
- }catch{return {ok:false,error:'Token Meter could not save goals.'};}
-}
-function acceptGoalResult(result){GOALS=result;goalsLoadedAt=Date.now();renderGoals();}
-async function saveGoalForm(){
- const metric=$('goals-metric').value,scope=goalSelectedScope(),option=goalDraft.option,{period}=goalPeriodFields();
- let comparison,target,targetHigh;
- if(!option)return goalFormError('Choose a target.');
- if(option==='custom'){
-  comparison=$('goals-comparison').value;target=Number($('goals-target').value);
-  if(!comparison)return goalFormError('Choose At most or At least.');
-  if(comparison==='between'){targetHigh=Number($('goals-target-high').value);if($('goals-target').value===''||$('goals-target-high').value===''||!(target>0)||!(targetHigh>target))return goalFormError('Enter a range whose upper end is above its lower end, both above zero.');}
-  if($('goals-target').value===''||!Number.isFinite(target)||target<0||(goalUnit(metric)==='percent'&&target>100))return goalFormError('Enter a valid target.');
-  if(goalUnit(metric)==='tokens'&&!Number.isSafeInteger(target))return goalFormError('Enter a whole-token count within the supported range.');
- }else{
-  const chosen=goalDraft.options.find(o=>o.id===option);
-  if(!chosen)return goalFormError('Choose a target.');
-  comparison=chosen.comparison;target=chosen.target;targetHigh=chosen.target_high;
- }
- if(!goalDraft.start)return goalFormError('Choose a valid period.');
- $('goals-save').disabled=true;
- const edited=!!goalDraft.id,returnMode=goalDraft.returnMode,before=new Set((GOALS?.goals||[]).map(g=>g.id));
- const result=await postGoalAction({operation:'save',id:goalDraft.id||undefined,goal:{metric,scope,comparison,target,...(comparison==='between'?{target_high:targetHigh}:{}),target_option:option,period,start:goalDraft.start,end:goalDraft.end,repeat:period!=='custom'&&$('goals-repeat').checked,title:$('goals-title').value.trim()||null}});
- $('goals-save').disabled=false;
- if(!result.ok)return goalFormError(result.error||'Token Meter could not save this goal.');
- const id=edited?goalDraft.id:result.goals.find(g=>!before.has(g.id))?.id||'',saved=result.goals.find(g=>g.id===id);
- const home=goalHome(saved?.metric);
- goalsListModes[home.section]=saved?(goalIsCurrent(saved)?'current':'previous'):edited?returnMode:'current';
- goalDraft=null;$('goals-dialog').close();goalNotice('Goal saved.');acceptGoalResult(result);
- if(edited&&location.hash===`#efficiency-goals/${id}`){loadGoalDetail(id);return;}
- if(location.hash!==`#${home.route}`)setHashRoute(home.route);
- loadGoals().then(()=>requestAnimationFrame(()=>requestAnimationFrame(()=>revealSavedGoal(id,home.section))));
-}
-function revealSavedGoal(id,section){
- const box=$(section),link=[...box.querySelectorAll('.goalTitleLink')].find(a=>a.getAttribute('href')===`#efficiency-goals/${id}`),card=link?.closest('.goalCard');
- if(!card)return box.scrollIntoView({block:'start'});
- card.scrollIntoView({block:'center'});link.focus({preventScroll:true});
- card.classList.add('is-saved');setTimeout(()=>card.classList.remove('is-saved'),2400);
-}
-async function goalAction(operation,id,message){
- const result=await postGoalAction({operation,id});
- if(!result.ok)return goalNotice(result.error||'Token Meter could not update this goal.',true);
- acceptGoalResult(result);goalNotice(message);
-}
-$('goals-cancel').onclick=()=>$('goals-dialog').close();
-$('goals-dialog').addEventListener('close',()=>{$('goals-model-picker').open=false;if(!goalDraft)return;goalsListModes[goalDraft.section]=goalDraft.returnMode;goalDraft=null;++goalModelRequest;++goalPreviewRequest;renderGoals();});
-$('goals-form').addEventListener('submit',event=>{event.preventDefault();saveGoalForm();});
-$('goals-metric').addEventListener('change',()=>{const app=$('goals-app').value;fillGoalScopes($('goals-metric').value,goalSelectedScope());if(!$('goals-app').disabled)$('goals-app').value=app;refreshGoalModels();clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();});
-$('goals-app').addEventListener('change',()=>{
- const app=$('goals-app').value,before=goalDraft.modelKeys.length;
- if(app)goalDraft.modelKeys=goalDraft.modelKeys.filter(key=>goalDraft.models.find(m=>m.key===key)?.runtime===app);
- goalFormError(before!==goalDraft.modelKeys.length?'Selections from other apps were removed. Review the model selection before saving.':'');
- goalDraft.models=goalDraft.models.filter(m=>!app||m.runtime===app||goalDraft.modelKeys.includes(m.key));
- renderGoalModelPicker();clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();refreshGoalModels();
-});
-$('goals-model-picker').querySelector('summary').addEventListener('click',event=>{if(event.currentTarget.getAttribute('aria-disabled')==='true')event.preventDefault();});
-$('goals-model-picker').addEventListener('keydown',event=>{if(event.key==='Escape'){$('goals-model-picker').open=false;$('goals-model-picker').querySelector('summary').focus();}});
-$('goals-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionGoalModelPicker));
-window.addEventListener('resize',()=>{if($('goals-model-picker').open)positionGoalModelPicker();});
-document.addEventListener('pointerdown',event=>{const picker=$('goals-model-picker');if(picker.open&&!picker.contains(event.target))picker.open=false;});
-$('goals-model-options').addEventListener('change',event=>{
- const input=event.target.closest('[data-goal-model]');if(!input||!goalDraft)return;
- const key=input.dataset.goalModel,keys=new Set(goalDraft.modelKeys);
- if(key==='all')keys.clear();else if(input.checked){if(keys.size>=(GOALS.max_selected_models||32)){input.checked=false;goalFormError(`Select at most ${GOALS.max_selected_models||32} models.`);return;}keys.add(key);}else keys.delete(key);
- goalDraft.modelKeys=[...keys].sort();
- const all=$('goals-model-options').querySelector('[data-goal-model="all"]');all.checked=keys.size===0;
- $('goals-model-options').querySelectorAll('[data-goal-model]').forEach(option=>{if(option!==all)option.checked=keys.has(option.dataset.goalModel);});
- $('goals-model-summary').textContent=keys.size===0?'All models':keys.size===1?(goalDraft.models.find(m=>keys.has(m.key))?.label||'Model unavailable'):`${keys.size} models selected`;
- goalFormError('');clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();
-});
-$('goals-model-search').addEventListener('input',()=>{clearTimeout(goalModelTimer);++goalModelRequest;goalModelTimer=setTimeout(refreshGoalModels,200);});
-$('goals-target').addEventListener('input',()=>{updateGoalTargetNote();renderGoalPreview();});
-$('goals-target-high').addEventListener('input',renderGoalPreview);
-$('goals-work-type').addEventListener('change',()=>{clearAutoTitle();goalDraft.option='';updateGoalFormFields();refreshGoalPreview();});
-['goals-comparison','goals-repeat'].forEach(id=>$(id).addEventListener('change',renderGoalPreview));
-$('goals-title').addEventListener('input',renderGoalPreview);
-['goals-period','goals-start','goals-end'].forEach(id=>$(id).addEventListener('change',()=>{if(id==='goals-period')goalDraft.anchor='';updateGoalFormFields();refreshGoalPreview();}));
-$('goals-metric-options').addEventListener('click',event=>{const button=event.target.closest('[data-goal-metric]');if(!button||button.dataset.goalMetric===$('goals-metric').value)return;$('goals-metric').value=button.dataset.goalMetric;$('goals-metric').dispatchEvent(new Event('change'));});
-$('goals-options').addEventListener('click',event=>{const button=event.target.closest('[data-goal-option]');if(!button)return;chooseGoalOption(button.dataset.goalOption,true);if(button.dataset.goalOption==='custom')($('goals-comparison').disabled?$('goals-target'):$('goals-comparison')).focus();});
-function handleGoalClick(event){
- const toggle=event.target.closest('[data-goals-toggle]');
- if(toggle){const root=event.currentTarget,section=root.id;goalsListModes[section]=goalsListModes[section]==='previous'?'current':'previous';return loadGoals().then(()=>root.querySelector('[data-goals-toggle]')?.focus());}
- const edit=event.target.closest('[data-goal-edit]'),duplicate=event.target.closest('[data-goal-duplicate]'),end=event.target.closest('[data-goal-end]'),remove=event.target.closest('[data-goal-delete]');
- if(edit){const g=GOALS?.goals?.find(goal=>goal.id===edit.dataset.goalEdit);if(g)openGoalForm(g);}
- else if(duplicate){const g=GOALS?.goals?.find(goal=>goal.id===duplicate.dataset.goalDuplicate);if(g)openGoalForm(g,true);}
- else if(end)goalAction('end',end.dataset.goalEnd,'Goal ended.');
- else if(remove)goalAction('delete',remove.dataset.goalDelete,'Goal deleted.');
-}
-['efficiency-goals','spend-goals','git-goals','work-goals'].forEach(id=>$(id).addEventListener('click',handleGoalClick));
-function openGoalFromLink(event){
- const link=event.target.closest('[data-goal-new]');if(!link)return;
- event.preventDefault();
- loadGoals().then(()=>{if(GOALS)openGoalForm({},false,link.dataset.goalNew);});
-}
-document.addEventListener('click',openGoalFromLink);
-function closeGoalMenus(event){document.querySelectorAll('.goalMenu[open]').forEach(menu=>{if(!menu.contains(event.target)||event.target.closest('[data-goal-duplicate],[data-goal-end],[data-goal-delete]'))menu.open=false;});}
-document.addEventListener('click',closeGoalMenus);
-document.addEventListener('keydown',event=>{if(event.key!=='Escape')return;const menu=event.target.closest?.('.goalMenu[open]');if(menu){menu.open=false;menu.querySelector('summary').focus();}});
-let goalDetailRequest=0,goalDetailOrigin='',goalDetailData=null;
-function releaseGoalChart(){const svg=$('goals-trend-chart');if(svg)chartResizeObserver.unobserve(svg);goalDetailData=null;}
-function showGoalDetail(open){
- const wasOpen=!$('goal-detail').hidden;
- if(!open){++goalDetailRequest;releaseGoalChart();}
- $('view-efficiency').classList.toggle('goalDetailOpen',open);
- $('goals-overview').hidden=open;$('goal-detail').hidden=!open;
- if(!open&&wasOpen)requestAnimationFrame(()=>{const link=[...$('goals-overview').querySelectorAll('.goalTitleLink')].find(a=>a.getAttribute('href')===`#efficiency-goals/${goalDetailOrigin}`);(link||$('goals-heading')).focus();});
-}
-function goalBackLink(g){const home=goalHome(g?.metric);return `<a class=tbtn href="#${home.route}">← Back to ${esc(home.back)}</a>`;}
-async function loadGoalDetail(id){
- goalDetailOrigin=id;
- releaseGoalChart();
- showGoalDetail(true);
- const request=++goalDetailRequest;
- $('goal-detail').innerHTML=`${goalBackLink()}<p class="emptyState goalsEmpty">Loading goal detail…</p>`;
- let data;
- try{if(!GOALS)await loadGoals();data=await (await fetch(`/goals?goal=${encodeURIComponent(id)}`,{cache:'no-store'})).json();}
- catch{data={ok:false,error:'Goal detail is unavailable right now.'};}
- if(request!==goalDetailRequest)return;
- if(!data.ok||!GOALS){$('goal-detail').innerHTML=`${goalBackLink()}<p class="emptyState goalsEmpty">${esc(data.error||'Goal detail is unavailable right now.')}</p>`;return;}
- $('goal-detail').innerHTML=renderGoalDetail(data);
- goalDetailData=data;drawGoalTrend();const chart=$('goals-trend-chart');if(chart)chartResizeObserver.observe(chart);
- window.scrollTo(0,0);$('goal-detail-heading')?.focus({preventScroll:true});
-}
-function goalTrendChart(g,trend){
- const days=(trend||[]).map(p=>p.day);
- if(!days.length)return '<p class="emptyState goalsEmpty">No daily evidence yet.</p>';
- return `<div class=efficiencyChartWrap><svg class="goalTrend efficiencyChart" id=goals-trend-chart preserveAspectRatio=none role=img tabindex=0 aria-label="${esc(goalLabel(g.metric))} to date. Use arrow keys to inspect values." aria-describedby=goals-trend-status></svg><div class="efficiencyChartTip chartTip goalTrendTip" id=goals-trend-tip role=tooltip hidden></div><span class=efficiencyChartStatus id=goals-trend-status aria-live=polite></span></div>`
-  +`<div class=goalTrendAxis><span>${esc(days[0])}</span><span>${g.comparison==='between'?`Dashed lines: range ${esc(goalTargetText(g,g.metric))}`:`Dashed line: target ${esc(goalValue(g.target,g.metric))}`}</span><span>${esc(days.at(-1))}</span></div>`;
-}
-function drawGoalTrend(){
- const svg=$('goals-trend-chart');if(!svg||!goalDetailData)return;
- const g=goalDetailData.goal,samples=goalDetailData.trend||[],tip=$('goals-trend-tip'),status=$('goals-trend-status'),width=Math.max(1,Math.round(svg.clientWidth)),height=Math.max(1,Math.round(svg.clientHeight)),target=Number(g.target),targets=g.comparison==='between'?[target,Number(g.target_high)]:[target],known=p=>p.value!==null&&Number.isFinite(p.value),values=samples.filter(known).map(p=>p.value),low=Math.min(0,...targets,...values),high=Math.max(...targets,...values,low+1),span=high-low,pad=10,plot=Math.max(1,width-pad*2),x=index=>pad+(samples.length===1?plot/2:index*plot/(samples.length-1)),y=value=>height-pad-(value-low)/span*Math.max(1,height-pad*2);
- svg.setAttribute('viewBox',`0 0 ${width} ${height}`);tip.hidden=true;status.textContent='';
- let html=targets.map(t=>`<line class=goalSparkTarget x1="${pad}" x2="${width-pad}" y1="${y(t)}" y2="${y(t)}"/>`).join(''),segment=[];
- const finish=()=>{if(segment.length===1)html+=`<circle class=efficiencyChartDot cx="${segment[0][0]}" cy="${segment[0][1]}" r=3.5/>`;else if(segment.length)html+=`<polyline class=goalSparkLine points="${segment.map(p=>p.join(',')).join(' ')}"/>`;segment=[];};
- samples.forEach((p,i)=>{if(known(p))segment.push([x(i).toFixed(1),y(p.value).toFixed(1)]);else finish();});finish();
- if(!values.length)html+=`<text class=efficiencyChartEmpty x=10 y="${height/2}">No daily evidence</text>`;
- svg.innerHTML=html+`<g class=efficiencyChartInspect visibility=hidden><line class=efficiencyChartInspectLine y1="${pad}" y2="${height-pad}"/><circle class=efficiencyChartInspectDot r=4/></g>`;
- const inspect=svg.querySelector('.efficiencyChartInspect'),line=inspect.querySelector('line'),dot=inspect.querySelector('circle');let active=samples.length-1;
- const hide=()=>{inspect.setAttribute('visibility','hidden');tip.hidden=true;status.textContent='';};
- const show=(index,announce=false)=>{const p=samples[index];if(!p)return;active=index;const px=x(index),value=known(p)?goalValue(p.value,g.metric):'No data',text=`${p.day} · ${value} to date · target ${goalValue(target,g.metric)}`;inspect.setAttribute('visibility','visible');line.setAttribute('x1',px);line.setAttribute('x2',px);dot.setAttribute('visibility',known(p)?'visible':'hidden');if(known(p)){dot.setAttribute('cx',px);dot.setAttribute('cy',y(p.value));}tip.textContent=text;tip.hidden=false;const edge=Math.min(width/2,tip.offsetWidth/2+8);tip.style.left=`${Math.max(edge,Math.min(width-edge,px))}px`;if(announce)status.textContent=text;};
- svg.onpointermove=event=>{const rect=svg.getBoundingClientRect(),local=(event.clientX-rect.left)*width/Math.max(1,rect.width);show(Math.max(0,Math.min(samples.length-1,Math.round((local-pad)/plot*Math.max(0,samples.length-1)))));};
- svg.onpointerleave=hide;svg.onblur=hide;svg.onfocus=()=>show(samples.length-1,true);
- svg.onkeydown=event=>{if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;event.preventDefault();show(efficiencyChartKeyIndex(event.key,active,samples.length),true);};
- if(document.activeElement===svg)show(active,true);
-}
-function goalDriverRows(rows,valueText){
- return rows.map(r=>`<div class=goalDriverRow><span title="${esc(r.label)}">${esc(r.label)}</span><div class=goalDriverBar><i style="width:${Math.max(0,Math.min(100,Number(r.share)||0)).toFixed(1)}%"></i></div><b>${esc(valueText(r))}</b></div>`).join('');
-}
-function goalDriversCard(g,drivers){
- const metric=g.metric,parts=[];
- if(metric==='cost_per_1k_lines'){
-  const repos=drivers.by_repository||[],top=Math.max(0,...repos.map(r=>r.cost));
-  parts.push(repos.length?`<h5>By repository</h5>${goalDriverRows(repos.map(r=>({...r,share:top?r.cost/top*100:0})),r=>`${goalValue(r.value,metric)} · ${f(r.lines)} lines · ${money(r.cost)}`)}`:'<p class=goalDriverNote>No repository had both measured Git coverage and agent spend in this period.</p>');
-  const coverage=drivers.repository_coverage;
-  if(coverage){
-   parts.push(`<p class=goalDriverNote>${f(coverage.included)} of ${f(coverage.discovered)} discovered repositories included${g.measurement?.counted_share!==null&&g.measurement?.counted_share!==undefined?` · ${g.measurement.counted_share.toFixed(0)}% of agent spend covered`:''}. All projects includes every eligible discovered repository, including those outside this preview.</p>`);
-   if(coverage.omitted)parts.push(`<p class=goalDriverNote>Showing the top ${f(repos.length)} by spend. ${f(coverage.omitted)} more comparable repositories contribute to the total.</p>`);
-   parts.push(`<details class=goalsPrevious><summary>Repository evidence</summary><p class=goalDriverNote>${esc(`${coverage.start} to ${coverage.end}. ${coverage.available?(coverage.stale?'Git history is stale.':'Git evidence available.'):'Git history unavailable.'} Repositories require spend evidence and measured Git coverage; membership does not depend on meeting the target.`)}</p>`
-    +((coverage.rows||[]).length?`<div class=deliveryTableWrap><table class=tbl><thead><tr><th>Repository</th><th>Evidence</th><th>Spend</th><th>Pushed lines</th></tr></thead><tbody>${coverage.rows.map(r=>{const evidence=deliveryProjectEvidence(r);return `<tr><td>${esc(r.label)}</td><td>${esc(evidence.label)}${r.availability.partial?' · partial':''}</td><td>${r.availability.cost?money(r.cost):'--'}</td><td>${r.availability.code_pushed?f(r.lines):'--'}</td></tr>`;}).join('')}</tbody></table></div>`:'<p class=emptyState>No published repository evidence yet.</p>')
-    +((coverage.limits||[]).length?`<p class=goalDriverNote>${esc(coverage.limits.map(code=>({repository_limit:'Repository discovery limit reached.',scan_limited:'Git history scan was limited.',no_push_history:'Some discovered history has no recorded push evidence.'})[code]).join(' '))}</p>`:'')
-    +'<p class=goalDriverNote>Zero lines means measured Git history with no changed lines in this period. “--” means unavailable. Discovery follows local agent activity, up to '+f(coverage.repository_limit)+' repositories; it does not scan every repository on disk. Sessions outside repository folders are not attributed. The Git page has its own selected history range.</p><a class=tbtn href="#git">Open Git</a></details>');
-  }
- }else if(metric==='tokens'){
-  const tokens=drivers.token_drivers||{};
-  if((tokens.by_model||[]).length)parts.push(`<h5>By model, share of tokens</h5>${goalDriverRows(tokens.by_model,r=>`${goalValue(r.tokens,metric)} · ${r.share.toFixed(0)}%`)}`);
-  if((tokens.by_agent||[]).length>1)parts.push(`<h5>By app</h5>${goalDriverRows(tokens.by_agent,r=>`${goalValue(r.tokens,metric)} · ${r.share.toFixed(0)}%`)}`);
-  if(tokens.omitted)parts.push(`<p class=goalDriverNote>${f(tokens.omitted)} more models contribute to the total.</p>`);
- }else{
-  const ratio=['output_per_dollar','context_load','reasoning_ratio'].includes(metric);
-  if((drivers.by_model||[]).length)parts.push(`<h5>By model, share of spend</h5>${goalDriverRows(drivers.by_model,r=>`${money(r.cost)} · ${r.share.toFixed(0)}%${ratio&&r.value!==null?` · ${goalValue(r.value,metric)}`:''}`)}`);
-  if((drivers.by_effort||[]).length)parts.push(`<h5>By reasoning effort</h5>${goalDriverRows(drivers.by_effort.map(r=>({...r,label:r.effort.charAt(0).toUpperCase()+r.effort.slice(1)})),r=>`${money(r.cost)} · ${r.share.toFixed(0)}%`)}`);
-  if((drivers.by_agent||[]).length>1)parts.push(`<h5>By app</h5>${goalDriverRows(drivers.by_agent,r=>`${money(r.cost)} · ${r.share.toFixed(0)}%`)}`);
-  if(drivers.cache_hit!==null&&drivers.cache_hit!==undefined)parts.push(`<p class=goalDriverNote>${esc(`${drivers.cache_hit.toFixed(0)}% of processed input came from cache.`)}</p>`);
- }
- return `<section class="card goalDetailCard"><h4>What is driving it</h4>${parts.join('')||'<p class=goalDriverNote>No breakdown is available for this period yet.</p>'}</section>`;
-}
-function goalCoachingCard(tips){
- const hasEstimate=(tips||[]).some(t=>t.estimate);
- return `<section class="card goalDetailCard"><h4>Coaching</h4>${(tips||[]).map(t=>`<article class=goalCoachTip><h5>${esc(t.title)}</h5><p>${esc(t.evidence)}</p><p><strong>Try:</strong> ${esc(t.action)}</p>${t.estimate?`<p class=goalCoachSaving>Could save up to ${esc(money(t.estimate))}<small>${esc(t.estimate_basis||'')}</small></p>`:''}</article>`).join('')}${hasEstimate?'<p class=goalDriverNote>Estimates are upper bounds from your own history. They can overlap, so do not add them together.</p>':''}</section>`;
-}
-function goalContributorsCard(g,contributors){
- const items=contributors?.items||[],basis=contributors?.basis||'cost';
- if(!items.length)return '';
- if(g.metric==='cost_per_1k_lines')return `<section class="card goalDetailCard"><h4>Biggest contributors</h4><p class=goalDriverNote>Repositories ranked by covered spend, ${esc(contributors.start)} to ${esc(contributors.end)}. ${f(contributors.repositories)} repositories in total; showing ${f(items.length)}. Lines pushed counts additions plus deletions. Rates require at least 50 lines and positive spend.</p><div class=deliveryTableWrap><table class=tbl><thead><tr><th>Repository</th><th>Spend</th><th>Lines pushed</th><th>Cost per 1K pushed lines</th><th>Spend share</th></tr></thead><tbody>${items.map(c=>`<tr><td>${esc(c.label)}${c.partial?' · partial':''}</td><td>${money(c.cost)}</td><td>${f(c.lines)}</td><td>${esc(goalValue(c.value,g.metric))}</td><td>${c.share===null?'--':c.share.toFixed(0)+'%'}</td></tr>`).join('')}</tbody><tfoot><tr><th>All included repositories</th><td>${money(contributors.total_cost)}</td><td>${f(contributors.total_lines)}</td><td>${esc(goalValue(g.measurement?.value,g.metric))}</td><td>${contributors.total_cost>0?'100%':'--'}</td></tr></tfoot></table></div></section>`;
- const amount=c=>basis==='cost'?money(c.cost||0):`${compactNumber(basis==='tokens'?c.tokens:basis==='input tokens'?c.input_tokens:c.reasoning_tokens)} tokens`;
- return `<section class="card goalDetailCard"><h4>Biggest contributors</h4><p class=goalDriverNote>${esc(`Sessions that moved this goal most this period, by ${basis}. ${contributors.sessions} sessions in total.`)}</p><table class=tbl><thead><tr><th>Session</th><th>Last day</th><th>Model</th><th>Effort</th><th>Executions</th><th>${esc(basis==='cost'?'Cost':'Tokens')}</th><th>Share</th><th></th></tr></thead><tbody>${items.map(c=>`<tr><td>${esc(c.title)}<br><small>${esc(c.agent)}</small></td><td>${esc(c.last_day)}</td><td>${esc(c.model)}</td><td>${esc(c.effort||'--')}</td><td>${f(c.executions)}</td><td>${esc(amount(c))}</td><td>${c.share.toFixed(0)}%</td><td><a href="${esc(sessionRoute(c.id))}">Open</a></td></tr>`).join('')}</tbody></table></section>`;
-}
-function renderGoalDetail(d){
- const g=d.goal,m=g.measurement||{},metric=g.metric,option=(GOALS.metrics[metric]?.options||[]).find(o=>o.id===g.target_option);
- const scope=metric==='cost_per_1k_lines'?`Across ${goalRepoText(m.projects||0,m.project_names)}`:g.scope_label;
- const tiles=[
-  ['Current',goalValue(m.value,metric),GOAL_CONFIDENCE[m.confidence]||''],
-  [g.comparison==='between'?'Target range':g.comparison==='at_most'?'Target, at most':'Target, at least',g.comparison==='between'?goalTargetText(g,metric):goalValue(g.target,metric),option?.label||'Custom'],
-  m.projected!==undefined?['Projected',goalValue(m.projected,metric),'At the current pace']:null,
-  g.baseline?.value!==null&&g.baseline?.value!==undefined?[g.baseline.label||'Reference',goalValue(g.baseline.value,metric),`${g.baseline.start} to ${g.baseline.end}`]:null,
- ].filter(Boolean);
- const reason=[g.status_reason,g.progress?.early?'Early in the period':'',goalGuardrail(g)?`Watch: ${goalGuardrail(g)}`:'',...goalNotes(g).filter(n=>!n.startsWith('Across '))].filter(Boolean).join(' · ');
- return `<div class=goalDetailHead>${goalBackLink(g)}<div class=goalDetailTitle><h3 id=goal-detail-heading tabindex=-1>${esc(goalTitle(g))}</h3><p class=goalMeta>${esc(scope)} · ${esc(goalLabel(metric))} · ${esc(g.start)} to ${esc(g.end)}${g.repeat?` · Repeats every ${esc(g.period)}`:''}</p></div><span class="chip goalStatus ${esc(g.status)}">${esc(GOAL_STATUS_LABELS[g.status]||g.status)}</span><button class=tbtn type=button data-goal-edit="${esc(g.id)}">Edit</button><button class=tbtn type=button data-goal-duplicate="${esc(g.id)}">Duplicate</button></div>`
-  +`<div class=goalDetailSummary>${tiles.map(([label,value,note])=>`<div class="card metric goalDetailMetric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`).join('')}</div>`
-  +(reason?`<p class=goalDetail>${esc(reason)}</p>`:'')
-  +`<section class="card goalDetailCard"><h4>${esc(goalLabel(metric))} to date</h4>${goalTrendChart(g,d.trend)}</section>`
-  +`<div class=goalDetailGrid>${goalDriversCard(g,d.drivers||{})}${goalCoachingCard(d.coaching)}</div>`
-  +(g.history?.length?`<section class="card goalDetailCard"><h4>Previous periods</h4>${goalHistory(g)}</section>`:'')
-  +goalContributorsCard(g,d.contributors);
-}
-function applyHashRoute(){
- const h=(location.hash||'').replace(/^#/,'');
- // Back on Learn by any route (button, browser Back, or the nav) means the way back is used up.
- if(tourReturn?.host==='learn'&&(h==='learn'||h==='learn-agent-access'))showTourReturn(null);
- const panel=PANEL_ALIAS[h]||h;
- const legacyGlobal=h==='global'||h==='global-logs'||/^global-(overview|evidence)$/.test(h);
- if(h==='subagents'||h==='sessions-subagents'){
-  if(pinned){sessionRequest++;pinned=null;CURRENT=LATEST;}
-  mountSubagentExplorer(h==='subagents'?'roles':'sessions');
-  if(h==='sessions-subagents'){
-   setSessionScope('subagents');
-   showTab('session');
-   showCurrentPanel('sessions');
-  }else showTab('subagents');
-  if(LATEST)renderSubagentExplorer(LATEST.xsession?.agent_usage);
-  return;
- }
- if(h==='sessions'||h==='sessions-all'||h==='sessions-compare'||h==='current-sessions'){
- const scope=h==='sessions-all'?'all':h==='sessions-compare'?'compare':'current',route=sessionScopeRoute(scope);
- if((routedSessionId()||h==='current-sessions')&&history.replaceState)history.replaceState(null,'',`/#${route}`);
- if(pinned){sessionRequest++;pinned=null;CURRENT=LATEST;}
- setSessionScope(scope);
- showTab('session');
- showCurrentPanel('sessions');
- renderCurrentSessions();
- return;
-}
-if(h==='logs'||legacyGlobal){
- if(history.replaceState)history.replaceState(null,'','/#sessions-all');
- setSessionScope('all');
- showTab('session');
- showCurrentPanel('sessions');
- return;
- }
-	 if(h==='daily')setHashRoute('spend',{replace:true,apply:false});
-	 if(h==='settings-budgets'||h==='budgets')setHashRoute('spend-budgets',{replace:true,apply:false});
-	 if(h==='spend'||h==='daily'||h==='spend-budgets'||h==='spend-discounts'||h==='settings-budgets'||h==='budgets'){
-  showTab('spend');
-  if(LATEST)renderSpendView(LATEST.xsession);
-  if(h==='spend-discounts')openDiscounts();
-  else if(h!=='spend'&&h!=='daily'){
-   setBudgetEditorOpen(true);
-   requestAnimationFrame(()=>$('spend-budgets').scrollIntoView({block:'start'}));
-  }
-  loadGoals();
-	  return;
-	 }
- if(h==='preview-settings'){
-  setHashRoute('settings',{replace:true,apply:false});
-  showTab('settings');
-  if(LATEST)renderSettings(LATEST.xsession);
-  loadAgentAccess();
-  return;
- }
- const legacyCurrentRoutes={preview:'summary','preview-run':'summary','preview-activity':'summary','preview-tools':'summary'};
- if(legacyCurrentRoutes[h]){
-  const canonical=legacyCurrentRoutes[h];
-  setHashRoute(canonical,{replace:true,apply:false});
-  showTab('session');
-  showCurrentPanel(canonical);
-  return;
- }
-	 if(h==='models'||h==='frustration'){
-	  if(h==='frustration')setHashRoute('models',{replace:true,apply:false});
-	  showTab('models');
-	  if(LATEST)renderActiveModelStats();
-	  return;
-	 }
- if(h==='goals')setHashRoute('efficiency-goals',{replace:true,apply:false});
- if(h.startsWith('efficiency-goals/')){
-  showTab('efficiency');
-  if(LATEST)renderActiveEfficiency();
-  loadGoalDetail(decodeURIComponent(h.slice('efficiency-goals/'.length)));
-  return;
- }
- if(h==='goals'||h==='efficiency-goals'){
-  showGoalDetail(false);
-  showTab('efficiency');
-  if(LATEST)renderActiveEfficiency();
-  loadGoals().then(()=>requestAnimationFrame(()=>$('efficiency-goals').scrollIntoView({block:'start'})));
-  return;
- }
- if(h==='efficiency'){
-  if(routedSessionId()){
-   showTab('session');
-   showCurrentPanel('summary');
-  }else{
-   showGoalDetail(false);
-   showTab('efficiency');
-   if(LATEST)renderActiveEfficiency();
-   loadGoals();
-  }
-  return;
- }
- if(h==='work'){
-  if(workSupported===false){location.hash='sessions';return;}
-  showTab('work');
-  loadWork();
-  loadGoals();
-  return;
- }
- if(h.startsWith('work-sessions')||h.startsWith('sessions-all?work=')){
-  // The sessions behind a Work cell, shown in All sessions with a removable Work filter.
-  applyWorkSessionFilter(new URLSearchParams(h.split('?')[1]||''));
-  return;
- }
- if(h==='delivery')setHashRoute('git',{replace:true,apply:false});
- if(h==='git'||h==='delivery'){
-  showTab('git');
-  loadDelivery();
-  loadGoals();
-  return;
- }
- if(h==='capabilities'){
-  showTab('capabilities');
-  if(LATEST)renderCapabilities(LATEST.xsession?.capabilities);
-  return;
- }
- if(h==='learn'||h==='learn-agent-access'){
-  showTab('learn');
-  if(h==='learn-agent-access')showDeckSlide('learn',DECK_SLIDES.findIndex(slide=>slide.id==='agent'),{animate:false});
-  else renderLearn(LATEST);
-  return;
- }
- if(h==='settings-agent-defaults'){
-  setHashRoute('settings',{replace:true,apply:false});
-  showTab('settings');
-  if(LATEST)renderSettings(LATEST.xsession);
-  loadAgentAccess();
-  return;
- }
- if(h==='settings'||h==='model-pricing'||h==='settings-updates'||h==='settings-appearance'||h==='settings-work-insights'){
-  showTab('settings');
-  if(LATEST)renderSettings(LATEST.xsession);
-  const card={'model-pricing':'model-pricing-settings','settings-updates':'update-settings','settings-work-insights':'work-insights-settings','settings-appearance':'appearance-settings'}[h];
-  if(card)scrollToSettingsCard(card);
-  else pendingSettingsScroll=null; // plain #settings: drop a scroll an earlier link left waiting
-  loadWorkSettings();
-  loadAgentAccess();
-  return;
- }
-if(!h||h==='session'){
-  setSessionScope('current');
-  showTab('session');
-  if(routedSessionId()){
-   showCurrentPanel('summary');
-   setHashRoute('summary',{replace:true,apply:false});
-  }else{
-   showCurrentPanel('sessions');
-   setHashRoute('sessions',{replace:true,apply:false});
-  }
-  return;
- }
- if(PANEL_KEYS.includes(panel)){
-  showTab('session');
-  showCurrentPanel(panel);
-  if(h!==panel)setHashRoute(panel,{replace:true,apply:false});
- }
-else{
-  setSessionScope('current');
- showTab('session');
- showCurrentPanel('sessions');
- setHashRoute('sessions',{replace:true,apply:false});
- }
-}
-function applyLocationRoute(){
- applyHashRoute();
- const id=routedSessionId();
- if(id){sessionReturnScope=normalizeSessionScope(history.state?.sessionScope);selectSession(id,{updateUrl:false,show:$('view-session').classList.contains('on'),returnScope:sessionReturnScope});return;}
- if(pinned){
-  pinned=null;
-  if(LATEST&&$('view-session').classList.contains('on'))renderSession(LATEST);
- }
-}
-function mountSubagentExplorer(destination){
- const roles=destination==='roles',home=roles?$('subagent-page-home'):$('preview-surface-sessions'),explorer=$('subagent-explorer');
- if(explorer.parentElement!==home)home.appendChild(explorer);
- explorer.hidden=false;
- explorer.setAttribute('role',roles?'region':'tabpanel');
- if(roles){explorer.setAttribute('aria-label','Subagent roles');explorer.removeAttribute('aria-labelledby');}
- else{explorer.removeAttribute('aria-label');explorer.setAttribute('aria-labelledby','session-scope-subagents');}
- $('subagent-model-distribution').hidden=roles;
-}
-applyLocationRoute();
-window.addEventListener('hashchange',applyHashRoute);
-window.addEventListener('popstate',applyLocationRoute);
-
-const canNotify=('Notification' in window);
-const notifySecure=window.isSecureContext||['localhost','127.0.0.1','::1'].includes(location.hostname);
-const notifyWanted=localStorage.getItem('tm_notify')==='1';
-let notifyOn=notifyWanted && canNotify && notifySecure && Notification.permission==='granted';
-if(notifyWanted&&!notifyOn) localStorage.setItem('tm_notify','0');
-let notifiedKeys=new Set();
-let notifyLog=[];
-try{
- notifyLog=JSON.parse(localStorage.getItem('tm_notify_log')||'[]')
-  .filter(n=>n&&n.title!=='Token insight'&&!(n.title==='Token Meter alert'&&String(n.body||'').startsWith('Last execution cost ')))
-  .slice(0,24);
- localStorage.setItem('tm_notify_log',JSON.stringify(notifyLog));
-}catch(e){ notifyLog=[]; }
-function notifyStamp(){ return new Date().toLocaleTimeString([], {hour:'2-digit', minute:'2-digit', second:'2-digit'}); }
-function setNotifyState(msg){ if($('notify-state')) $('notify-state').textContent=msg; }
-function saveNotifyLog(){ try{ localStorage.setItem('tm_notify_log',JSON.stringify(notifyLog.slice(0,24))); }catch(e){} }
-function renderNotifyLog(){
- const box=$('notify-log'); if(!box) return;
- box.innerHTML=notifyLog.length?notifyLog.map(n=>`<div class="logrow ${esc(n.kind||'')}"><div class=h><span>${esc(n.title)}</span><span class=mono>${esc(n.time)}</span></div><div class=b>${esc(n.body)}</div></div>`).join(''):'<div class=subline>no notifications yet</div>';
-}
-function showAppToast(entry){
- const box=$('toastbox'); if(!box) return;
- const toast=document.createElement('div');
- toast.className='toast '+(entry.kind||'');
- const head=document.createElement('div'); head.className='th';
- const title=document.createElement('span'); title.textContent=entry.title;
- const close=document.createElement('button'); close.type='button'; close.textContent='x'; close.setAttribute('aria-label','Dismiss');
- head.appendChild(title); head.appendChild(close);
- const body=document.createElement('div'); body.className='tb'; body.textContent=entry.body;
- toast.appendChild(head); toast.appendChild(body); box.appendChild(toast);
- close.onclick=()=>toast.remove();
- setTimeout(()=>toast.remove(),entry.sticky?9500:6500);
- while(box.children.length>4) box.firstElementChild.remove();
-}
-function agentActionToken(){return LATEST?.xsession?.capabilities?.actions?.token||'';}
-let SOFTWARE_UPDATE=null,softwareUpdateRequestBusy=false,softwareUpdatePollTimer=0,softwareUpdateTarget='';
-function softwareUpdateActionToken(){return SOFTWARE_UPDATE?.actions?.token||agentActionToken();}
-function softwareUpdateStamp(value){
- if(!value)return'';
- return new Date(Number(value)*1000).toLocaleString([],{
-  month:'short',day:'numeric',hour:'2-digit',minute:'2-digit',
- });
-}
-function scheduleSoftwareUpdatePoll(delay=1500){
- clearTimeout(softwareUpdatePollTimer);
- softwareUpdatePollTimer=setTimeout(refreshSoftwareUpdateStatus,delay);
-}
-function renderSoftwareUpdate(status){
- if(!status)return;
- SOFTWARE_UPDATE=status;
- const state=status.state||'waiting',enabled=!!status.enabled;
- $('update-enabled').checked=enabled;
- $('update-auto-install').checked=enabled&&status.auto_install===true;
- $('update-auto-install').disabled=!enabled;
- $('update-check').disabled=!enabled||status.checking||status.updating;
- $('update-check').textContent=status.checking?'Checking…':'Check now';
- const badge={
-  disabled:'Checks off',waiting:'Waiting',checking:'Checking',available:'Update ready',
-  updating:'Updating',updated:'Updated',current:'Up to date',attention:'Needs attention',
- }[state]||'Unavailable';
- $('update-settings-badge').textContent=badge;
- $('update-settings-status').className=`settingsStatus ${['attention'].includes(state)?'warn':['available','updated','current'].includes(state)?'good':''}`;
- $('update-settings-status').textContent=status.message||'Update status is unavailable.';
- const revisions=status.current_revision
-  ? `${status.current_revision.slice(0,12)}${status.latest_revision&&status.latest_revision!==status.current_revision?` → ${status.latest_revision.slice(0,12)}`:''}`
-  :'';
- const checked=softwareUpdateStamp(status.checked_at);
- $('update-settings-meta').textContent=[revisions,checked?`last checked ${checked}`:''].filter(Boolean).join(' · ');
- if(softwareUpdateTarget&&state==='attention'){
-  softwareUpdateTarget='';
-  showAppToast({title:'Update did not complete',body:status.message||'The source checkout needs attention.',kind:'warn',sticky:true});
- }
- const showNotice=Boolean(
-  (status.available&&status.can_update)
-  || (softwareUpdateTarget&&status.updating)
- );
- $('update-notice').hidden=!showNotice;
- $('update-notice').disabled=!!status.updating;
- $('update-notice').textContent=status.updating?'Updating…':'New update available';
- document.body.classList.toggle('updateReady',showNotice);
- if(softwareUpdateTarget&&['updated','current'].includes(state)
-    &&status.current_revision===softwareUpdateTarget){
-  try{localStorage.setItem('tm_update_completed',softwareUpdateTarget);}catch(error){}
-  softwareUpdateTarget='';
-  setTimeout(()=>location.reload(),350);
-  return;
- }
- if(status.checking||status.updating||softwareUpdateTarget)scheduleSoftwareUpdatePoll();
- const completed=localStorage.getItem('tm_update_completed')||'';
- if(completed&&status.current_revision===completed){
-  localStorage.removeItem('tm_update_completed');
-  showAppToast({title:'Token Meter updated',body:`Now running ${completed.slice(0,12)}.`,kind:'good',sticky:true});
- }
-}
-async function refreshSoftwareUpdateStatus(){
- if(softwareUpdateRequestBusy)return;
- softwareUpdateRequestBusy=true;
- try{
-  const response=await fetch('/updates/status',{cache:'no-store'});
-  if(!response.ok)throw new Error(`Update status failed (${response.status}).`);
-  renderSoftwareUpdate(await response.json());
- }catch(error){
-  if(softwareUpdateTarget)scheduleSoftwareUpdatePoll(2000);
- }finally{softwareUpdateRequestBusy=false;}
-}
-async function postSoftwareUpdate(path,payload={}){
- const token=softwareUpdateActionToken();
- if(!token)throw new Error('Update controls are not ready yet. Wait a moment and try again.');
- const response=await fetch(path,{
-  method:'POST',
-  headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},
-  body:JSON.stringify(payload),
- });
- let result={};
- try{result=await response.json();}catch(error){}
- if(!response.ok||!result.ok)throw new Error(result.error||'Token Meter could not complete the update action.');
- if(result.status)renderSoftwareUpdate(result.status);
- return result;
-}
-async function saveSoftwareUpdatePreferences(event){
- const enabled=$('update-enabled').checked;
- if(!enabled)$('update-auto-install').checked=false;
- const autoInstall=enabled&&$('update-auto-install').checked;
- $('update-enabled').disabled=true;
- $('update-auto-install').disabled=true;
- try{
-  const result=await postSoftwareUpdate('/settings/updates',{enabled,auto_install:autoInstall});
-  renderSoftwareUpdate(result.status);
-  const changedAutoInstall=event.target.id==='update-auto-install';
-  showAppToast({
-   title:changedAutoInstall
-    ?(autoInstall?'Automatic installation enabled':'Automatic installation disabled')
-    :(enabled?'Update checks enabled':'Update checks disabled'),
-   body:changedAutoInstall
-    ?(autoInstall?'Safe main updates will install automatically.':'Checks continue; available updates stay visible in the menu bar.')
-    :(enabled?'Token Meter is checking the tracked main branch now.':'Update checks and automatic installation are off.'),
-   kind:enabled?'good':'neutral',
-  });
- }catch(error){
-  renderSoftwareUpdate(SOFTWARE_UPDATE);
-  showAppToast({title:'Update setting could not be saved',body:error.message||String(error),kind:'warn',sticky:true});
- }finally{
-  $('update-enabled').disabled=false;
-  $('update-auto-install').disabled=!$('update-enabled').checked;
- }
-}
-$('update-enabled').onchange=saveSoftwareUpdatePreferences;
-let menubarSettingsBusy=false;
-function renderMenubarSettings(settings){
- if(!settings||menubarSettingsBusy)return;
- $('menubar-cache-timer').querySelectorAll('button').forEach(button=>{
-  button.setAttribute('aria-pressed',String(button.dataset.cacheTimer===settings.cache_timer));
- });
-}
-$('menubar-cache-timer').onclick=async event=>{
- const button=event.target.closest('button[data-cache-timer]');
- if(!button||menubarSettingsBusy)return;
- const status=$('menubar-settings-status'),token=softwareUpdateActionToken();
- if(!token){status.textContent='Settings are not ready yet. Wait a moment and try again.';return;}
- menubarSettingsBusy=true;status.textContent='Saving…';
- try{
-  const response=await fetch('/settings/menubar',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({cache_timer:button.dataset.cacheTimer})});
-  let result={};try{result=await response.json();}catch(error){}
-  if(!response.ok||!result.ok)throw new Error(result.error||'Token Meter could not save the menu bar setting.');
-  menubarSettingsBusy=false;renderMenubarSettings(result.menubar);
-  status.textContent='Saved';
- }catch(error){
-  menubarSettingsBusy=false;status.textContent=error.message;
- }
-};
-$('update-auto-install').onchange=saveSoftwareUpdatePreferences;
-$('update-check').onclick=async()=>{
- const button=$('update-check'),original=button.textContent;
- button.disabled=true;button.textContent='Checking…';
- try{
-  await postSoftwareUpdate('/updates/check');
-  scheduleSoftwareUpdatePoll();
- }catch(error){
-  showAppToast({title:'Update check failed',body:error.message||String(error),kind:'warn',sticky:true});
-  button.disabled=false;button.textContent=original;
- }
-};
-$('update-notice').onclick=async()=>{
- if(!SOFTWARE_UPDATE?.can_update||SOFTWARE_UPDATE.updating)return;
- softwareUpdateTarget=SOFTWARE_UPDATE.latest_revision||'';
- $('update-notice').disabled=true;$('update-notice').textContent='Starting update…';
- try{
-  const result=await postSoftwareUpdate('/updates/install');
-  renderSoftwareUpdate(result.status);
-  scheduleSoftwareUpdatePoll();
- }catch(error){
-  softwareUpdateTarget='';
-  $('update-notice').disabled=false;$('update-notice').textContent='New update available';
-  showAppToast({title:'Update could not start',body:error.message||String(error),kind:'warn',sticky:true});
- }
-};
-const MODEL_PRICE_FIELDS=['input','output','cache_write','cache_read'];
-let modelPricingState=null,modelPricingSelected=new Set(),modelPricingTab='all';
-function modelPriceKey(provider,model){return `${provider}:${model}`;}
-function renderModelPriceTabs(){
- const rows=modelPricingState?.models||[],providers=new Map();
- for(const row of rows){
-  const entry=providers.get(row.provider)||{label:row.provider_label||row.provider,count:0,edited:false};
-  entry.count++;if(modelPricingSelected.has(modelPriceKey(row.provider,row.model)))entry.edited=true;
-  providers.set(row.provider,entry);
- }
- if(modelPricingTab!=='all'&&!providers.has(modelPricingTab))modelPricingTab='all';
- const tabs=[['all',{label:'All',count:rows.length,edited:modelPricingSelected.size>0}],...providers];
- $('model-price-tabs').innerHTML=rows.length?tabs.map(([id,tab])=>{
-  const on=id===modelPricingTab;
-  return `<button type=button role=tab id="model-price-tab-${esc(id)}" aria-selected=${on} aria-controls=model-price-table-wrap tabindex=${on?0:-1} data-model-price-tab="${esc(id)}">${esc(tab.label)}<span class=count>${f(tab.count)}</span>${tab.edited?'<span class=edited title="Unsaved edits" aria-label="Unsaved edits"></span>':''}</button>`;
- }).join(''):'';
- $('model-price-tabs').querySelectorAll('[data-model-price-tab]').forEach(button=>{
-  button.onclick=()=>selectModelPriceTab(button.dataset.modelPriceTab);
-  button.onkeydown=event=>{
-   const buttons=[...$('model-price-tabs').querySelectorAll('[data-model-price-tab]')],index=buttons.indexOf(button);
-   const next=event.key==='ArrowRight'?index+1:event.key==='ArrowLeft'?index-1:event.key==='Home'?0:event.key==='End'?buttons.length-1:null;
-   if(next===null)return;
-   event.preventDefault();
-   selectModelPriceTab(buttons[(next+buttons.length)%buttons.length].dataset.modelPriceTab);
-  };
- });
- applyModelPriceTab();
-}
-function applyModelPriceTab(){
- for(const root of $('model-pricing-rows').querySelectorAll('[data-model-price-key]'))root.hidden=modelPricingTab!=='all'&&root.dataset.modelPriceProvider!==modelPricingTab;
- const active=$('model-price-tabs').querySelector('[aria-selected=true]');
- if(active)$('model-price-table-wrap').setAttribute('aria-labelledby',active.id);
-}
-function selectModelPriceTab(tab){
- if(tab===modelPricingTab)return;
- const hadFocus=$('model-price-tabs').contains(document.activeElement);
- modelPricingTab=tab;
- renderModelPriceTabs();
- $('model-price-table-wrap').scrollTop=0;
- if(hadFocus)$('model-price-tabs').querySelector('[aria-selected=true]')?.focus();
-}
-function modelPriceSelectionState(count){
- const selected=Math.max(0,Number(count)||0),noun=selected===1?'model':'models';
- return {summary:selected?`${selected} ${noun} selected`:'No models selected',button:selected?`Save ${selected} ${noun}`:'Save models',disabled:selected===0};
-}
-function modelPriceScope(){return document.querySelector('input[name="model-price-scope"]:checked')?.value||'from_now';}
-function modelPriceAllHistory(){return modelPriceScope()==='all_history';}
-function modelPriceEffectiveFrom(){
- if(modelPriceScope()!=='from_date')return null;
- const raw=$('model-price-effective-from').value;
- if(!raw)throw new Error('Choose the date when these prices should start.');
- const timestamp=new Date(raw).getTime()/1000;
- if(!Number.isFinite(timestamp))throw new Error('Choose a valid effective date and time.');
- if(timestamp>Date.now()/1000+60)throw new Error('The effective date cannot be in the future.');
- return timestamp;
-}
-function modelPriceScopePayload(scopeOverride=null){
- const scope=scopeOverride||modelPriceScope(),payload={apply_to_all_history:scope==='all_history'};
- if(scope==='from_date')payload.effective_from=modelPriceEffectiveFrom();
- return payload;
-}
-function modelPriceSource(row){
- const source=row.source||'built-in',periods=Number(row.periods||0);
- const label=source==='built-in'?'':source;
- if(!periods)return label;
- if(row.effective_from==null)return label?`${label} · all history`:'all history';
- const date=new Date(Number(row.effective_from)*1000);
- if(Number.isNaN(date.getTime()))return label;
- const effective=`from ${date.toLocaleString([], {dateStyle:'medium',timeStyle:'short'})}`;
- return label?`${label} · ${effective}`:effective;
-}
-function updateModelPriceScope(){
- const scope=modelPriceScope(),history=scope==='all_history',fromDate=scope==='from_date';
- $('model-price-scope').classList.toggle('history',history);
- $('model-price-effective-from').disabled=!fromDate;
- $('model-price-scope-note').textContent=history?'All matching session estimates will be recalculated.':(fromDate?'Choose the date; session estimates from then are recalculated and older session estimates keep their prior prices.':'Changes start when you save; older session estimates keep their prior prices.');
-}
-function confirmModelPriceHistory(action,model){
- if(modelPriceAllHistory())return confirm(`${action} for ${model} across all recorded history? Older cost estimates will be recalculated and the previous price timeline will be replaced.`);
- const effective=modelPriceEffectiveFrom();
- if(effective==null)return true;
- const when=new Date(effective*1000).toLocaleString([], {dateStyle:'medium',timeStyle:'short'});
- return confirm(`${action} for ${model} from ${when}? Sessions at or after that time will be recalculated; earlier sessions keep their prices.`);
-}
-function modelPriceNumber(value){
- const number=Number(value);
- return Number.isFinite(number)?String(number):'0';
-}
-function modelPriceValues(root){
- const prices={};
- for(const field of MODEL_PRICE_FIELDS){
-  const input=root.querySelector(`[data-price-field="${field}"]`);
-  const value=Number(input?.value);
-  if(!input||input.value.trim()===''||!Number.isFinite(value)||value<0)throw new Error('Enter a non-negative number for every price.');
-  prices[field]=value;
- }
- return prices;
-}
-function modelPriceRowForRoot(root){
- const key=root?.dataset.modelPriceKey||'';
- return (modelPricingState?.models||[]).find(row=>modelPriceKey(row.provider,row.model)===key);
-}
-function restoreModelPriceRow(root){
- const row=modelPriceRowForRoot(root),prices=row?.prices||{};
- if(!row)return;
- for(const field of MODEL_PRICE_FIELDS){
-  const input=root.querySelector(`[data-price-field="${field}"]`);
-  if(input)input.value=modelPriceNumber(prices[field]);
- }
-}
-function setModelPriceSelected(root,selected,restore=true){
- const key=root?.dataset.modelPriceKey;
- if(!key)return;
- if(selected)modelPricingSelected.add(key);else{
-  modelPricingSelected.delete(key);
-  if(restore)restoreModelPriceRow(root);
- }
- root.classList.toggle('selected',selected);
- const checkbox=root.querySelector('[data-model-price-select]');
- if(checkbox)checkbox.checked=selected;
- updateModelPriceSelectionState();
-}
-function updateModelPriceSelectionState(){
- const state=modelPriceSelectionState(modelPricingSelected.size),button=$('model-price-save-changes');
- $('model-price-selection-count').textContent=state.summary;
- button.disabled=state.disabled;button.textContent=state.button;
- renderModelPriceTabs();
-}
-function renderModelPricing(pricing,force=false){
- if(!pricing)return;
- modelPricingState=pricing;
- $('model-pricing-reviewed').textContent=pricing.reviewed_on||'not recorded';
- const sources=Array.isArray(pricing.sources)?pricing.sources:[];
- $('model-pricing-sources').innerHTML=sources.length?sources.map(source=>`<a href="${esc(source.url||'#')}" target=_blank rel="noreferrer">${esc(source.label||source.provider||'Source')}</a>`).join(' · '):'No source links available';
- const custom=Number(pricing.custom_models||0),retired=Number(pricing.retired_custom_models||0),overrides=Number(pricing.overrides||0);
- const badge=$('model-pricing-badge'),hasCustomPricing=!!(custom||overrides||retired);
- badge.hidden=!hasCustomPricing;
- badge.textContent=hasCustomPricing?`${f(custom)} custom · ${f(overrides)} ${countWord(overrides,'override')}${retired?` · ${f(retired)} retired`:''}`:'';
- if(modelPricingSelected.size&&!force)return;
- const drafts=new Map();
- if(force)for(const root of $('model-pricing-rows').querySelectorAll('[data-model-price-key]')){
-  if(modelPricingSelected.has(root.dataset.modelPriceKey)){
-   try{drafts.set(root.dataset.modelPriceKey,modelPriceValues(root));}catch(error){}
-  }
- }
- const rows=pricing.models||[];
- $('model-pricing-rows').innerHTML=rows.length?rows.map(row=>{
-  const prices=row.prices||{},key=modelPriceKey(row.provider,row.model),sourceLabel=modelPriceSource(row),selected=modelPricingSelected.has(key);
-  const lifecycleAction=modelPriceLifecycle(row),lifecycle=lifecycleAction?`<button class=modelPriceLifecycle data-model-price-lifecycle type=button>${lifecycleAction.label}</button>`:'';
-  const fieldLabels={input:'Input',output:'Output',cache_write:'Cache write',cache_read:'Cached input'};
-  return `<tr${selected?' class=selected':''} data-model-price-key="${esc(key)}" data-model-price-provider="${esc(row.provider)}"><td class=modelPriceSelectCell data-label="Select"><input data-model-price-select type=checkbox${selected?' checked':''} aria-label="${esc(`Select ${row.model} for price update`)}"></td><td data-label="Provider"><span class="badge ${esc(row.provider)}">${esc(row.provider_label||row.provider)}</span></td><td data-label="Model id"><div class=modelPriceModel><code>${esc(row.model)}</code>${sourceLabel?`<span class=modelPriceSource>${esc(sourceLabel)}</span>`:''}${lifecycle}</div></td>${MODEL_PRICE_FIELDS.map(field=>`<td class=num data-label="${fieldLabels[field]}"><input class=modelPriceInput data-price-field="${field}" type=number min=0 max=1000000 step=any value="${esc(modelPriceNumber(prices[field]))}" aria-label="${esc(`${row.model} ${field.replace('_',' ')} price`)}"></td>`).join('')}</tr>`;
- }).join(''):'<tr><td colspan=7 class=modelPricingEmpty>No model prices configured.</td></tr>';
- for(const root of $('model-pricing-rows').querySelectorAll('[data-model-price-key]')){
-  const draft=drafts.get(root.dataset.modelPriceKey);
-  if(draft)for(const field of MODEL_PRICE_FIELDS)root.querySelector(`[data-price-field="${field}"]`).value=modelPriceNumber(draft[field]);
- }
- $('model-pricing-rows').querySelectorAll('.modelPriceInput').forEach(input=>input.addEventListener('input',()=>{
-  const root=input.closest('[data-model-price-key]');setModelPriceSelected(root,true,false);$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent='Unsaved price changes';
- }));
- $('model-pricing-rows').querySelectorAll('[data-model-price-select]').forEach(checkbox=>checkbox.addEventListener('change',()=>{
-  const root=checkbox.closest('[data-model-price-key]');setModelPriceSelected(root,checkbox.checked,true);
-  $('model-pricing-status').className=modelPricingSelected.size?'settingsStatus warn':'settingsStatus';$('model-pricing-status').textContent=modelPricingSelected.size?'Selected model prices are ready to edit.':'';
- }));
- $('model-pricing-rows').querySelectorAll('[data-model-price-lifecycle]').forEach(button=>button.onclick=()=>applyModelPriceLifecycle(button));
- updateModelPriceSelectionState();
- updateModelPriceScope();
-}
-async function requestModelPrice(payload,scopeOverride=null){
- const token=agentActionToken();
- if(!token)throw new Error('Settings are not ready yet. Wait for live state and try again.');
- const response=await fetch('/settings/model-pricing',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({...payload,...modelPriceScopePayload(scopeOverride)})});
- const result=await response.json();
- if(!response.ok||!result.ok)throw new Error(result.error||'Could not save model pricing.');
- if(LATEST?.xsession)LATEST.xsession.model_pricing=result.model_pricing;
- return result;
-}
-function modelPriceRowFor(button){
- return modelPriceRowForRoot(button.closest('[data-model-price-key]'));
-}
-async function saveModelPriceChanges(){
- const button=$('model-price-save-changes'),keys=[...modelPricingSelected];
- if(!keys.length)return;
- try{
-  const changes=keys.map(key=>{
-   const row=(modelPricingState?.models||[]).find(item=>modelPriceKey(item.provider,item.model)===key),root=[...$('model-pricing-rows').querySelectorAll('[data-model-price-key]')].find(item=>item.dataset.modelPriceKey===key);
-   if(!row||!root)throw new Error('Reload Settings and try saving these model prices again.');
-   return {provider:row.provider,model:row.model,prices:modelPriceValues(root)};
-  });
-  if(!confirmModelPriceHistory(`Apply ${changes.length} price ${countWord(changes.length,'change')}`,'the selected models'))return;
-  const original=button.textContent;button.disabled=true;button.textContent='Saving…';
-  try{
-   const result=await requestModelPrice({changes});
-   keys.forEach(key=>modelPricingSelected.delete(key));
-   renderModelPricing(result.model_pricing,true);
-   $('model-pricing-status').className='settingsStatus good';
-   $('model-pricing-status').textContent=result.effective_scope==='all_history'?'Saved · matching session estimates recalculated':(result.effective_scope==='selected_time'?'Saved from the selected date':'Saved from now');
-   showAppToast({title:'Model prices updated',body:`Saved ${changes.length} ${countWord(changes.length,'change')}.`,kind:'good'});
-   await refreshLiveState();
-  }finally{button.textContent=original;updateModelPriceSelectionState();}
- }catch(error){$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent=error.message||String(error);showAppToast({title:'Model pricing could not be saved',body:error.message||String(error),kind:'warn',sticky:true});}
-}
-function modelPriceLifecycle(row){
- if(row.custom)return {label:'Remove custom model',scope:row.active?null:'all_history'};
- if(row.overridden||Number(row.periods||0)>0)return {label:'Restore built-in price',scope:null};
- return null;
-}
-async function applyModelPriceLifecycle(button){
- const row=modelPriceRowFor(button),action=row&&modelPriceLifecycle(row);
- if(!action)return;
- const scopeOverride=action.scope;
- if(!row.custom&&!row.overridden&&modelPriceScope()==='from_now'){
-  // Already built-in from now; only All history clears the saved periods.
-  const guidance=`${row.model} already uses built-in prices from now. Choose All history, then restore to clear its earlier saved prices.`;
-  $('model-pricing-status').className='settingsStatus';
-  $('model-pricing-status').textContent=guidance;
-  showAppToast({title:'Already on built-in prices',body:guidance});
-  return;
- }
- if(row.custom&&!row.active){if(!confirm(`Delete ${row.model} from all saved pricing history?`))return;}
- else if(!confirmModelPriceHistory(row.custom?'Retire this custom price':'Restore built-in pricing',row.model))return;
- const original=button.textContent;button.disabled=true;button.textContent=row.custom?'Removing…':'Restoring…';
- try{
-  const result=await requestModelPrice({provider:row.provider,model:row.model,remove:true},scopeOverride);
-  modelPricingSelected.delete(modelPriceKey(row.provider,row.model));
-  renderModelPricing(result.model_pricing,true);
-  $('model-pricing-status').className='settingsStatus good';$('model-pricing-status').textContent=row.custom?'Custom price updated.':'Default price restored.';
-  showAppToast({title:row.custom?'Custom price changed':'Default price restored',body:result.effective_scope==='all_history'?(row.custom?`${row.model} was removed from all pricing history.`:`${row.model} uses built-in prices across all history.`):(result.effective_scope==='selected_time'?(row.custom?`${row.model} is retired from the selected time; earlier sessions retain its price.`:`${row.model} uses built-in pricing from the selected time.`):(row.custom?`${row.model} is retired from now; older sessions retain its price.`:`${row.model} uses Token Meter’s built-in price from now.`)),kind:'good'});
-  await refreshLiveState();
- }catch(error){$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent=error.message||String(error);showAppToast({title:'Model pricing could not be changed',body:error.message||String(error),kind:'warn',sticky:true});}
- finally{button.disabled=false;button.textContent=original;}
-}
-$('model-price-add-form').addEventListener('submit',async event=>{
- event.preventDefault();
- const button=$('model-price-add'),model=$('model-price-model').value.trim();
- try{
-  const root=event.currentTarget,prices={
-   input:Number($('model-price-input').value),output:Number($('model-price-output').value),
-   cache_write:Number($('model-price-cache-write').value),cache_read:Number($('model-price-cache-read').value),
- };
- for(const [field,value] of Object.entries(prices))if(root.querySelector(`#model-price-${field.replaceAll('_','-')}`)?.value.trim()===''||!Number.isFinite(value)||value<0)throw new Error('Enter a non-negative number for every price.');
-  if(!confirmModelPriceHistory('Add this custom price',model))return;
-  const original=button.textContent;button.disabled=true;button.textContent='Adding…';
-  let result;
-  try{result=await requestModelPrice({provider:$('model-price-provider').value,model,prices});}
-  finally{button.disabled=false;button.textContent=original;}
-  renderModelPricing(result.model_pricing,true);
-  $('model-price-model').value='';$('model-price-input').value='';$('model-price-output').value='';$('model-price-cache-write').value='0';$('model-price-cache-read').value='0';
-  showAppToast({title:'Model price added',body:result.effective_scope==='all_history'?`${model} now prices all matching history.`:(result.effective_scope==='selected_time'?`${model} is priced from the selected time; earlier sessions are unchanged.`:`${model} is priced from now; older sessions are unchanged.`),kind:'good'});
-  await refreshLiveState();
- }catch(error){$('model-pricing-status').className='settingsStatus warn';$('model-pricing-status').textContent=error.message||String(error);showAppToast({title:'Model could not be added',body:error.message||String(error),kind:'warn',sticky:true});}
-});
-document.querySelectorAll('input[name="model-price-scope"]').forEach(input=>input.addEventListener('change',updateModelPriceScope));
-$('model-price-save-changes').addEventListener('click',saveModelPriceChanges);
-updateModelPriceScope();
-const DEFAULT_RUNTIME_BUDGET=0;
-let defaultSessionBudget=10;
-let budgetSettingsDirty=false;
-function budgetNumber(id){const raw=$(id).value.trim();return raw===''?0:Number(raw);}
-function budgetRuntimeIds(){
- const catalogIds=Object.entries(RUNTIME_CATALOG).filter(([id])=>id!=='unknown-runtime').map(([id])=>id);
- return catalogIds.length?catalogIds:[...document.querySelectorAll('.budgetRuntime[data-runtime-id]')].map(row=>row.dataset.runtimeId);
-}
-function ensureBudgetRuntimeRows(){
- const list=$('budget-runtimes');
- budgetRuntimeIds().forEach(provider=>{
-  if($(`budget-runtime-${provider}`))return;
-  const label=runtimeLabel({provider});
-  list.insertAdjacentHTML('beforeend',`<div class=budgetRuntime id="budget-runtime-${esc(provider)}" data-runtime-id="${esc(provider)}"><span class=budgetRuntimeName>${esc(label)}</span><span class=budgetRuntimeValue><b class=mono id="budget-runtime-spend-${esc(provider)}">$0.00</b><small id="budget-runtime-share-${esc(provider)}">0% of spend</small></span><span class=budgetRuntimeTrack id="budget-runtime-track-${esc(provider)}"><i></i></span><label class=budgetRuntimeInput><span>Budget</span><input id="budget-input-${esc(provider)}" aria-label="${esc(label)} budget" type=number min=0 max=100000000 step=any value=0></label></div>`);
- });
-}
-function parsedBudgetThresholds(){
- const values=[...document.querySelectorAll('[data-budget-threshold]')].map(input=>Number(input.value.trim())).filter(value=>Number.isFinite(value));
- return [...new Set(values)].sort((a,b)=>a-b);
-}
-function paintBudgetSettings(settings){
-  settings=settings||{default_session_budget:10,monthly_total:0,allocations:{},thresholds:[80,90,100],native_notifications:true};
-  if(budgetSettingsDirty)return;
- defaultSessionBudget=Number(settings.default_session_budget||10);
- $('budget-input-session-default').value=formatBudgetInput(defaultSessionBudget);
- ensureBudgetRuntimeRows();
- budgetRuntimeIds().forEach(provider=>{$(`budget-input-${provider}`).value=Number(settings.allocations?.[provider]??DEFAULT_RUNTIME_BUDGET);});
- const thresholds=settings.thresholds||[80,90,100];
- [$('budget-input-threshold-early'),$('budget-input-threshold-mid'),$('budget-input-threshold-full')].forEach((input,index)=>{input.value=thresholds[index]??[80,90,100][index];});
- $('budget-input-notifications').checked=settings.native_notifications!==false;
-}
-function budgetAlertState(){
- try{const value=JSON.parse(localStorage.getItem('tm_monthly_budget_alerts')||'{}');return value&&typeof value==='object'?value:{};}catch(error){return {};}
-}
-function budgetExceededAlertState(){
- try{const value=JSON.parse(localStorage.getItem('tm_monthly_budget_exceeded_alerts')||'{}');return value&&typeof value==='object'?value:{};}catch(error){return {};}
-}
-function observeBudgetThresholds(status){
- if(!status?.configured)return;
- const state=budgetAlertState(),crossed=status.thresholds_crossed||[],previous=state[status.month];
- const seen=Array.isArray(previous)?previous:(Array.isArray(previous?.thresholds)?previous.thresholds:[]);
- const firstObservation=previous===undefined,over=Number((status.alert_percent??status.percent)||0)>=1;
- const exceededState=budgetExceededAlertState(),monthExceeded=exceededState[status.month]||{};
- const inAppNotified=monthExceeded.inApp===true,browserNotified=monthExceeded.browser===true;
- const fresh=crossed.filter(value=>!seen.includes(value));
- const alertExceeded=over&&!inAppNotified;
- const browserReady=notifyOn&&canNotify&&Notification.permission==='granted';
- const deliverMissedBrowserAlert=over&&!browserNotified&&browserReady;
- const threshold=alertExceeded||deliverMissedBrowserAlert?100:(!firstObservation&&fresh.length?fresh[fresh.length-1]:null);
- const lower=status.lower_bound?'At least ':'',isExceeded=alertExceeded||deliverMissedBrowserAlert;
- if(threshold!==null){
-  const title=isExceeded?'Monthly budget exceeded':`Monthly budget reached ${threshold}%`;
-  const body=isExceeded
-   ? `${lower}${money(status.spend)} of ${money(status.budget)} recorded for ${status.month} (${pct(status.percent)} used).`
-   : `${lower}${money(status.spend)} of ${money(status.budget)} recorded for ${status.month}.`;
-  if(browserReady)fireNotification(isExceeded?'Token Meter budget exceeded':'Token Meter monthly budget',body,`monthly:${status.month}:${isExceeded?'over':threshold}`,{dedupe:true,requireInteraction:isExceeded});
-  else pushAppNotice(title,body,isExceeded?'warn':'neutral',{sticky:isExceeded,status:title});
- }
- state[status.month]=[...new Set([...seen,...crossed])];
- localStorage.setItem('tm_monthly_budget_alerts',JSON.stringify(state));
- exceededState[status.month]={
-  inApp:inAppNotified||alertExceeded,
-  browser:browserNotified||deliverMissedBrowserAlert,
- };
- localStorage.setItem('tm_monthly_budget_exceeded_alerts',JSON.stringify(exceededState));
-}
-function renderCurrentBudgetWarning(status){
- const banner=$('current-budget-warning'),rows=status?.exceeded_runtimes||[];
- banner.classList.toggle('on',rows.length>0);
- if(!rows.length){$('current-budget-warning-msg').textContent='';return;}
- const lower=status.lower_bound?'At least ':'';
- $('current-budget-warning-msg').textContent=rows.map(row=>{
-  const over=Number(row.over_by||0),verb=over>0?'exceeded':'reached';
-  return `⚠︎ ${row.label} monthly budget ${verb}: ${lower}${money(row.spend||0)} spent against ${money(row.allocation||0)} (${pct(row.percent||0)} used).`;
- }).join(' ');
-}
-$('current-budget-settings').onclick=()=>setHashRoute('spend-budgets');
-function budgetMonthLabel(month){
- const match=/^(\d{4})-(\d{2})$/.exec(String(month||''));
- if(!match)return 'This month';
- return new Date(Number(match[1]),Number(match[2])-1,1).toLocaleDateString(undefined,{month:'long',year:'numeric'});
-}
-function renderBudgets(xs){
- if(!xs)return;
- const status=xs.budget||{},settings=xs.budgets||status.settings||{};
- const configured=!!status.configured,lower=status.lower_bound?'At least ':'',allocations=settings.allocations||{};
- const runtimeExceeded=status.exceeded_runtimes||[],runtimeAttention=runtimeExceeded.length>0;
- const allocatedTotal=Object.values(allocations).reduce((sum,value)=>sum+Number(value||0),0);
- $('budget-spend').textContent=wholeMoney(status.spend||0);
- $('budget-spend-qualifier').hidden=!status.lower_bound;
- $('budget-month').textContent=budgetMonthLabel(status.month);
- $('budget-spend-note').textContent=`${status.active_days||0} active spend ${countWord(status.active_days||0,'day')}`;
- $('budget-total').textContent=configured?wholeMoney(status.budget):'Not set';
- const runtimeNames=budgetRuntimeIds().map(provider=>runtimeLabel({provider})).join(' + ');
- $('budget-total').title=allocatedTotal?runtimeNames:'';
- $('budget-total-note').textContent=allocatedTotal?`across ${Object.values(allocations).filter(value=>Number(value)>0).length} runtime budgets`:configured?'Legacy total · set runtime budgets to replace':'Add runtime budgets to enable tracking';
- $('budget-remaining').textContent=configured?wholeMoney(status.remaining||0):'--';
- $('budget-remaining').className=`v mono${configured&&Number(status.percent||0)>=.8?' warn':''}`;
- $('budget-remaining-note').textContent=status.lower_bound?'Coverage is partial; true remaining may be lower':configured?`${status.days_remaining||0} calendar days left`:'No monthly limit';
- $('budget-projected').textContent=status.projection_ready?wholeMoney(status.projected_spend):'--';
- $('budget-projected').className=`v mono${status.projection_ready&&status.projected_spend>status.budget?' warn':''}`;
- $('budget-projected-note').textContent=status.projection_ready?`${wholeMoney(Math.abs(status.projected_spend-status.budget))} ${status.projected_spend>status.budget?'over':'under'} budget at current pace`:`Shown after ${status.projection_min_active_days||3} active spend days`;
- const ratio=configured?Math.max(0,Number(status.percent||0)):0,progress=$('budget-progress');
- progress.querySelector('i').style.width=Math.min(100,100*ratio)+'%';progress.setAttribute('aria-valuenow',String(Math.round(100*ratio)));progress.classList.toggle('warn',ratio>=.8);
- $('budget-progress-markers').innerHTML=configured?(settings.thresholds||[]).filter(value=>value>0&&value<=100).map(value=>`<span style="left:${value}%"></span>`).join(''):'';
- const attentionState=runtimeAttention?'over':(status.state||'unconfigured');
- const stateLabel=runtimeAttention?`${runtimeExceeded.map(row=>row.label).join(', ')} over budget`:{unconfigured:'Not configured',on_track:'On track',warning:'Threshold crossed',over:'Budget exceeded'}[status.state]||'Current month';
- $('budget-state').textContent=stateLabel;
- $('budget-state').className=`agentAccessBadge chip budgetState ${attentionState}`;
- budgetConfigured=configured;
- paintBudgetEditorToggle();
- $('budget-current-note').textContent=runtimeAttention
-  ? runtimeExceeded.map(row=>Number(row.over_by||0)>0
-    ? `${row.label} ${pct(row.percent||0)} used · ${wholeMoney(row.over_by||0)} over its runtime budget`
-    : `${row.label} ${pct(row.percent||0)} used · runtime budget reached`).join(' · ')
-  : configured?`${pct(ratio)} used · ${status.next_threshold?`${status.next_threshold}% next threshold`:'all thresholds crossed'}`:'Add runtime budgets to start tracking';
- $('budget-coverage').className=`budgetCoverage${status.lower_bound?' warn':''}`;
- const alertExcluded=Number(status.alert_excluded_spend||0);
- $('budget-coverage').textContent=(status.lower_bound?'Partial cost coverage: recorded spend is a lower bound.':status.estimated?'Includes labeled local cost estimates.':'')+(alertExcluded>0?` Antigravity length-based estimates (${money(alertExcluded)}) are shown but don't trigger budget notifications.`:'');
- const runtimes=status.runtimes||[],hasAllocations=runtimes.some(row=>Number(row.allocation||0)>0),runtimeSpend=Math.max(0,Number(status.spend||0));
- $('budget-allocation-note').textContent=hasAllocations?`${lower}${wholeMoney(status.spend||0)} / ${wholeMoney(status.budget)}`:'Add runtime budgets';
- ensureBudgetRuntimeRows();
-  const runtimeRows=new Map(runtimes.map(row=>[row.provider,row]));
-  budgetRuntimeIds().forEach(provider=>{
-  const row=runtimeRows.get(provider)||{provider,spend:0,allocation:Number(allocations[provider]||0)};
-  const spend=Number(row.spend||0),allocated=Number(row.allocation||0),percent=allocated?spend/allocated:(runtimeSpend?spend/runtimeSpend:0),over=row.exceeded===true||Boolean(allocated&&spend>=allocated);
-  const shareLabel=allocated?`${pct(percent)} of budget`:`${pct(percent)} of spend`;
-  const color=over?'var(--bad)':providerColor(row.provider);
-  const runtime=$(`budget-runtime-${provider}`);
-  runtime.style.setProperty('--provider-color',color);
-  $(`budget-runtime-spend-${provider}`).textContent=wholeMoney(spend);
-  $(`budget-runtime-share-${provider}`).textContent=shareLabel;
-  $(`budget-runtime-track-${provider}`).querySelector('i').style.width=`${Math.min(100,100*percent)}%`;
- });
- paintBudgetSettings(settings);
- observeBudgetThresholds(status);
-}
-let settingsPointerActive=false;
-const settingsView=$('view-settings');
-settingsView.addEventListener('pointerdown',()=>{settingsPointerActive=true;});
-$('spend-budgets').addEventListener('pointerdown',()=>{settingsPointerActive=true;});
-window.addEventListener('pointerup',()=>{settingsPointerActive=false;});
-window.addEventListener('pointercancel',()=>{settingsPointerActive=false;});
-function settingsInteractionActive(){return viewInteractionActive($('view-settings'));}
-function budgetInteractionActive(){return viewInteractionActive($('spend-budgets'));}
-function viewInteractionActive(root){
- const active=document.activeElement,selection=window.getSelection?.();
- const editing=active&&root.contains(active)&&active.matches('input,textarea,select,[contenteditable=true]');
- const selecting=selection&&!selection.isCollapsed&&selection.rangeCount&&(
-  (selection.anchorNode&&root.contains(selection.anchorNode))||(selection.focusNode&&root.contains(selection.focusNode))
- );
- return settingsPointerActive||Boolean(editing)||Boolean(selecting);
-}
-function renderSettings(xs){
- if(!xs||settingsInteractionActive())return;
- renderModelPricing(xs.model_pricing);
-}
-function renderSpendView(xs){
- renderSpend(xs);
- if(xs&&!budgetInteractionActive())renderBudgets(xs);
- if(xs?.cost_discounts&&!discountEditInProgress())renderDiscounts(xs.cost_discounts);
-}
-let budgetConfigured=false;
-function paintBudgetEditorToggle(){
- const planJump=$('budget-plan-jump'),open=!$('budget-config').hidden;
- planJump.textContent=open?'Close editor':budgetConfigured?'Edit budgets':'Set budgets';
- planJump.setAttribute('aria-expanded',String(open));
- planJump.setAttribute('aria-label',open?'Close runtime budget editor':budgetConfigured?'Edit runtime budgets':'Set runtime budgets');
-}
-function setBudgetEditorOpen(open,focus=false){
- const config=$('budget-config');
- config.hidden=!open;
- $('spend-discounts').hidden=!open;
- paintBudgetEditorToggle();
- if(!open)return;
- config.classList.remove('attention');
- void config.offsetWidth;
- config.classList.add('attention');
- setTimeout(()=>config.classList.remove('attention'),1400);
- if(!focus)return;
- const input=config.querySelector('.budgetRuntimeInput input');
- config.scrollIntoView({behavior:window.matchMedia('(prefers-reduced-motion: reduce)').matches?'auto':'smooth',block:'nearest'});
- input.focus({preventScroll:true});
- if(input.value)input.select();
-}
-$('budget-plan-jump').onclick=()=>setBudgetEditorOpen($('budget-config').hidden,true);
-const DISCOUNT_LISTS={anthropic:['Anthropic','claude'],openai:['OpenAI','codex'],cursor:['Cursor','cursor'],kiro:['Kiro','kiro'],opencode:['OpenCode','opencode']};
-const DISCOUNT_BILLED={direct:'The provider',bedrock:'AWS Bedrock',vertex:'Google Vertex',azure:'Microsoft Azure',any:'Anyone'};
-const DISCOUNT_OWN_LISTS=new Set(['cursor','kiro','opencode']);
-const DISCOUNT_CUE_KEY='tm_discount_cue_dismissed';
-let discountTab='all',discountSettings=null,discountPollSeq=0;
-function discountRuleState(rule,now=Date.now()/1000){
- if(rule.end!=null&&rule.end<=now)return 'ended';
- if(rule.start!=null&&rule.start>now)return 'starts later';
- return 'active';
-}
-function discountActiveRules(){return (discountSettings?.rules||[]).filter(rule=>discountRuleState(rule)==='active');}
-function discountDay(seconds){return new Date(seconds*1000).toLocaleDateString(undefined,{year:'numeric',month:'short',day:'numeric'});}
-// A date input is a local calendar day: send its local midnight with this browser's offset.
-function discountLocalMidnightIso(day){
- if(!day)return null;
- const offset=-new Date(`${day}T00:00`).getTimezoneOffset(),sign=offset<0?'-':'+',abs=Math.abs(offset);
- return `${day}T00:00:00${sign}${String(Math.floor(abs/60)).padStart(2,'0')}:${String(abs%60).padStart(2,'0')}`;
-}
-function discountSay(text,tone=''){const status=$('discount-status');status.className='settingsStatus'+(tone?' '+tone:'');status.textContent=text;}
-// Rendering never touches the add row's inputs, so only a half-typed discount pauses it.
-let discountFormDirty=false;
-function discountEditInProgress(){
- return discountFormDirty&&Boolean(discountSettings)&&viewInteractionActive($('spend-discounts'));
-}
-function openDiscounts(){
- const settings=LATEST?.cost_discounts||LATEST?.xsession?.cost_discounts;
- if(settings)renderDiscounts(settings);
- setBudgetEditorOpen(true);
- requestAnimationFrame(()=>{$('spend-discounts').scrollIntoView({block:'start',behavior:window.matchMedia('(prefers-reduced-motion: reduce)').matches?'auto':'smooth'});$('d-pct').focus({preventScroll:true});});
-}
-let discountCueSignature='',discountCardSignature='';
-// Live refreshes re-render only when what a reader sees would change, and keep keyboard focus.
-function discountFocusKey(){
- const active=document.activeElement;
- if(!active?.dataset)return '';
- return active.dataset.dremove?`dremove:${active.dataset.dremove}`:active.dataset.dtab?`dtab:${active.dataset.dtab}`:active.hasAttribute('data-open-discounts')?'open':'';
-}
-function restoreDiscountFocus(key){
- if(!key)return;
- const [kind,value]=key.split(':');
- const target=kind==='dremove'?document.querySelector(`[data-dremove="${CSS.escape(value)}"]`):kind==='dtab'?document.querySelector(`[data-dtab="${CSS.escape(value)}"]`):document.querySelector('#discount-cue [data-open-discounts]');
- target?.focus({preventScroll:true});
-}
-function renderDiscountCue(){
- const cue=$('discount-cue'),active=discountActiveRules();
- if(active.length)localStorage.removeItem(DISCOUNT_CUE_KEY);
- const hidden=!discountSettings||(!active.length&&localStorage.getItem(DISCOUNT_CUE_KEY)==='1');
- const signature=JSON.stringify([hidden,active.map(rule=>[rule.id,rule.price_list,rule.percent])]);
- if(signature===discountCueSignature)return;
- discountCueSignature=signature;
- if(hidden){cue.hidden=true;return;}
- const focus=discountFocusKey();
- cue.hidden=false;cue.classList.toggle('active',active.length>0);
- cue.innerHTML=active.length
-  ?`<div class=discountCueText><b>Spend includes your discounts</b><span class=discountCueList>${active.map(rule=>`<span class="badge ${(DISCOUNT_LISTS[rule.price_list]||['','other'])[1]}">${esc((DISCOUNT_LISTS[rule.price_list]||[rule.price_list])[0])} ${esc(rule.percent)}%</span>`).join('')}<span>Costs before discounts are shown beside each total.</span></span></div><div class=discountCueActions><button class=tbtn type=button data-open-discounts>Manage discounts</button></div>`
-  :`<div class=discountCueText><b>Spend uses public list prices.</b><span>Pay a negotiated or company rate? Add a discount so spend and budgets match your bill.</span></div><div class=discountCueActions><button class=discountLink type=button data-dismiss-discounts>Not now</button><button class="tbtn go" type=button data-open-discounts>Add a discount</button></div>`;
- cue.querySelector('[data-open-discounts]').onclick=openDiscounts;
- const dismiss=cue.querySelector('[data-dismiss-discounts]');
- if(dismiss)dismiss.onclick=()=>{localStorage.setItem(DISCOUNT_CUE_KEY,'1');renderDiscountCue();};
- restoreDiscountFocus(focus);
-}
-// After Remove, focus moves to the next row's Remove button, else the previous one, else the heading.
-async function removeDiscount(button){
- const buttons=[...$('discount-rows').querySelectorAll('[data-dremove]')],index=buttons.indexOf(button);
- const neighbours=[buttons[index+1],buttons[index-1]].filter(Boolean).map(item=>item.dataset.dremove);
- const removed=await saveDiscountOps([{op:'delete',id:button.dataset.dremove}],button);
- if(!removed)return;
- const next=neighbours.map(id=>document.querySelector(`[data-dremove="${CSS.escape(id)}"]`)).find(Boolean);
- (next||$('discount-title')).focus({preventScroll:true});
-}
-function discountRuleName(rule){
- return `${(DISCOUNT_LISTS[rule.price_list]||[rule.price_list])[0]} ${rule.percent}% discount`;
-}
-function renderDiscounts(settings){
- if(settings)discountSettings=settings;
- const rules=discountSettings?.rules||[];
- const invalid=Number(discountSettings?.invalid_rules||0),readOnly=discountSettings?.read_only===true;
- const signature=JSON.stringify([discountSettings?.revision,discountTab,invalid,readOnly,rules.map(rule=>[rule.id,discountRuleState(rule)])]);
- if(signature!==discountCardSignature){
-  discountCardSignature=signature;
-  const focus=discountFocusKey();
-  const counts={all:rules.length};
-  rules.forEach(rule=>{counts[rule.price_list]=(counts[rule.price_list]||0)+1;});
-  $('discount-tabs').innerHTML=['all',...Object.keys(DISCOUNT_LISTS)].map(id=>`<button type=button role=tab aria-selected=${id===discountTab} data-dtab=${id}>${id==='all'?'All':DISCOUNT_LISTS[id][0]}<span class=count>${counts[id]||0}</span></button>`).join('');
-  $('discount-tabs').querySelectorAll('[data-dtab]').forEach(button=>button.onclick=()=>{discountTab=button.dataset.dtab;renderDiscounts();});
-  const shown=rules.filter(rule=>discountTab==='all'||rule.price_list===discountTab);
-  $('discount-rows').innerHTML=shown.length?shown.map(rule=>{
-   const list=DISCOUNT_LISTS[rule.price_list]||[rule.price_list,'other'];
-   return `<tr><td data-label="Models from"><span class="badge ${list[1]}">${esc(list[0])}</span></td><td data-label="Billed by">${esc(DISCOUNT_OWN_LISTS.has(rule.price_list)?list[0]:DISCOUNT_BILLED[rule.channel]||rule.channel)}</td><td class="num mono" data-label="Discount">${esc(rule.percent)}%</td><td data-label="From">${rule.start!=null?esc(discountDay(rule.start)):'All past usage'}</td><td data-label="Until">${rule.end!=null?esc(discountDay(rule.end)):'No end'}</td><td data-label="Note"><div class=modelPriceModel>${esc(rule.label||'—')}<span class=modelPriceSource>${discountRuleState(rule)}</span><button class=modelPriceLifecycle type=button data-dremove="${esc(rule.id)}" aria-label="${esc(`Remove ${discountRuleName(rule)}`)}"${readOnly?' disabled':''}>Remove</button></div></td><td data-label="Set by"><span class=chip>${esc(rule.set_by||'')}</span></td></tr>`;
-  }).join(''):'<tr><td colspan=7 class=modelPricingEmpty>No discounts yet. Costs use public list prices.</td></tr>';
-  $('discount-rows').querySelectorAll('[data-dremove]').forEach(button=>button.onclick=()=>removeDiscount(button));
-  const active=discountActiveRules().length;
-  $('discount-badge').textContent=active?`${active} active`:'List prices';
-  const notes=[];
-  if(invalid)notes.push(`${invalid} saved ${invalid===1?'discount is':'discounts are'} invalid and ignored`);
-  if(readOnly)notes.push(discountSettings?.read_only_reason==='newer_version'?'Discounts were saved by a newer Token Meter. Update Token Meter to change them.':"Discounts in settings.json can't be changed by this version.");
-  $('discount-invalid').hidden=!notes.length;$('discount-invalid').textContent=notes.join(' · ');
-  $('d-add').disabled=readOnly;
-  document.querySelectorAll('[data-runtime-channel]').forEach(select=>{select.disabled=readOnly;});
-  restoreDiscountFocus(focus);
- }
- const channels=discountSettings?.runtime_channels||{};
- document.querySelectorAll('[data-runtime-channel]').forEach(select=>{if(document.activeElement!==select)select.value=channels[select.dataset.runtimeChannel]||'auto';});
- renderDiscountCue();
-}
-async function pollPricingRevision(target){
- const seq=++discountPollSeq,deadline=Date.now()+10*60*1000;
- while(seq===discountPollSeq&&Date.now()<deadline){
-  await new Promise(resolve=>setTimeout(resolve,1500));
-  try{
-   const health=await (await fetch('/health',{cache:'no-store'})).json();
-   if(health.pricing_revision===target){
-    if(seq!==discountPollSeq)return;
-    discountSay('All costs were recalculated.','good');
-    await refreshLiveState();
-    if(LATEST?.xsession)renderSpendView(LATEST.xsession);
-    return;
-   }
-  }catch(_error){/* The server may be busy recalculating; keep polling. */}
- }
-}
-// /state carries discounts read fresh from settings; the snapshot's copy lags while history reprices.
-function adoptFreshDiscounts(state){
- if(!state?.cost_discounts)return;
- if(state.xsession)state.xsession.cost_discounts=state.cost_discounts;
- else if(!discountEditInProgress())renderDiscounts(state.cost_discounts);
-}
-// Typing pauses live renders; clearing every add-row field again resumes them.
-function discountAddRowHasInput(){return DISCOUNT_ADD_FIELDS.some(id=>String($(id)?.value||'').trim()!=='');}
-const DISCOUNT_ADD_FIELDS=['d-pct','d-start','d-end','d-note'];
-$('discount-form').addEventListener('input',()=>{discountFormDirty=discountAddRowHasInput();});
-async function reloadDiscounts(){
- const token=agentActionToken();
- if(!token)return;
- try{
-  const response=await fetch('/api/v1/cost-discounts',{headers:{'X-Token-Meter-Action':token},cache:'no-store'});
-  const settings=await response.json();
-  if(response.ok&&settings.ok){if(LATEST)LATEST.cost_discounts=settings;renderDiscounts(settings);}
- }catch(_error){/* Keep the current view; the next live refresh carries fresh discounts. */}
-}
-async function saveDiscountOps(ops,button=null){
- const token=agentActionToken();
- if(!token){discountSay('Settings are not ready yet. Wait for live state and try again.','warn');return false;}
- const original=button?.textContent;
- if(button){button.disabled=true;button.textContent='Saving…';}
- try{
-  const response=await fetch('/settings/cost-discounts',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({ops,expected_revision:discountSettings?.revision})});
-  const result=await response.json().catch(()=>({}));
-  if(!response.ok||!result.ok){
-   discountSay(result.error||'The discount could not be saved.','warn');
-   if(response.status===409)await reloadDiscounts();
-   return false;
-  }
-  discountSettings={...(discountSettings||{}),rules:result.rules,revision:result.revision};
-  if(LATEST?.xsession)LATEST.xsession.cost_discounts=discountSettings;
-  if(LATEST)LATEST.cost_discounts=discountSettings;
-  renderDiscounts();
-  if(!result.changed){discountSay('No changes to save.');return true;}
-  discountSay('Discount saved. Costs are being recalculated.');
-  pollPricingRevision(result.pricing_revision);
-  return true;
- }catch(error){discountSay(error.message||String(error),'warn');return false;}
- finally{if(button){button.disabled=false;button.textContent=original;}}
-}
-$('d-list').onchange=()=>{const own=DISCOUNT_OWN_LISTS.has($('d-list').value);$('d-channel').disabled=own;if(own)$('d-channel').value='any';};
-$('d-add').onclick=async()=>{
- const percent=Number($('d-pct').value),start=$('d-start').value,end=$('d-end').value;
- if(!(percent>0&&percent<100)){discountSay('Enter a discount above 0% and below 100%.','warn');return;}
- if(start&&end&&start>=end){discountSay('"Until" must be after "From".','warn');return;}
- const saved=await saveDiscountOps([{op:'upsert',rule:{price_list:$('d-list').value,channel:$('d-channel').value,percent,start:discountLocalMidnightIso(start),end:discountLocalMidnightIso(end),label:$('d-note').value.trim()}}],$('d-add'));
- if(saved){discountFormDirty=false;$('d-pct').value='';$('d-start').value='';$('d-end').value='';$('d-note').value='';}
-};
-document.querySelectorAll('[data-runtime-channel]').forEach(select=>select.onchange=()=>saveDiscountOps([{op:'set_runtime_channels',[select.dataset.runtimeChannel]:select.value}]));
-$('discount-rotate').onclick=async()=>{
- if(!confirm('Issue a new API token? Tools using the current token stop working until they read the new one.'))return;
- const token=agentActionToken();
- if(!token){discountSay('Settings are not ready yet. Wait for live state and try again.','warn');return;}
- try{
-  const response=await fetch('/api/v1/api-token/rotate',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:'{}'});
-  const result=await response.json().catch(()=>({}));
-  if(!response.ok||!result.ok)throw new Error(result.error||'A new token could not be issued.');
-  discountSay('New token issued. Tools using the old token must read the new one.','warn');
- }catch(error){discountSay(error.message||String(error),'warn');}
-};
-function budgetAllocationsFromInputs(){
- const allocations={};
- budgetRuntimeIds().forEach(provider=>{allocations[provider]=budgetNumber(`budget-input-${provider}`);});
- return allocations;
-}
-function previewCalculatedBudget(){
- const total=Object.values(budgetAllocationsFromInputs()).reduce((sum,value)=>sum+(Number.isFinite(value)?Math.max(0,value):0),0);
- $('budget-total').textContent=total?wholeMoney(total):'Not set';
- $('budget-total-note').textContent=total?'draft total':'Add runtime budgets to enable tracking';
-}
-$('budget-form').addEventListener('input',event=>{budgetSettingsDirty=true;if(event.target.closest('.budgetRuntimeInput'))previewCalculatedBudget();$('budget-settings-status').className='settingsStatus warn';$('budget-settings-status').textContent='Unsaved changes';});
-$('budget-form').onsubmit=async event=>{
- event.preventDefault();
- const button=$('budget-save'),allocations=budgetAllocationsFromInputs();
-	 const payload={currency:'USD',default_session_budget:budgetNumber('budget-input-session-default'),allocations,thresholds:parsedBudgetThresholds(),native_notifications:$('budget-input-notifications').checked};
- button.disabled=true;button.textContent='Saving…';
- try{
-  const response=await fetch('/settings/budgets',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':agentActionToken()},body:JSON.stringify(payload)});
-	  const result=await response.json();if(!response.ok||!result.ok)throw new Error(result.error||'Could not save budget settings.');
-  budgetSettingsDirty=false;
-	  if(LATEST?.xsession){LATEST.xsession.budgets=result.budgets;LATEST.xsession.budget=result.budget;LATEST.xsession.monthly=result.monthly;}
-	  renderBudgets(LATEST?.xsession||result);
-	  if(CURRENT)loadBudgetForSession(CURRENT);
-	  $('budget-settings-status').className='settingsStatus good';$('budget-settings-status').textContent='Saved';
-	  const total=Number(result.budgets?.monthly_total||0);
-	  const sessionDefault=Number(result.budgets?.default_session_budget||10);
-	  showAppToast({title:'Budget settings updated',body:total?`${money(sessionDefault)} per session by default · ${money(total)} per month.`:`${money(sessionDefault)} per session by default · monthly tracking is unconfigured.`,kind:'good'});
- }catch(error){$('budget-settings-status').className='settingsStatus warn';$('budget-settings-status').textContent=error.message||String(error);showAppToast({title:'Budget could not be saved',body:error.message||String(error),kind:'warn',sticky:true});}
- finally{button.disabled=false;button.textContent='Save budgets';}
-};
-function agentSkillsView(row){
- const skills=row.skills||{}, managed=(skills.managed||0)>0;
- const remove={label:'Remove',enabled:false};
- if(!skills.available)return{text:'Not included in this install',cls:'',buttons:[{label:'Install',enabled:true,disabled:true}]};
- if(!skills.detected)return managed
-  ?{text:`${skills.target||'Client'} not found · Token Meter skills still installed`,cls:'warn',buttons:[remove]}
-  :{text:`${skills.target||'Client'} not found`,cls:'',buttons:[{label:'Install',enabled:true,disabled:true}]};
- if(skills.state==='installed')return{text:`${skills.total===1?'1 skill installed':`${skills.total} skills installed`} · available in new sessions`,cls:'connected',buttons:[remove]};
- if(skills.state==='outdated')return{text:'Update available',cls:'warn',buttons:[{label:'Update',enabled:true},remove]};
- if(skills.state==='partial'){
-  const installable=(skills.missing||[]).length+(skills.outdated||[]).length>0;
-  const fresh=!(skills.unmanaged||[]).length&&!(skills.outdated||[]).length&&(skills.missing||[]).length;
-  return{text:(skills.unmanaged||[]).length?'Partly installed · a skill you created or edited uses one of the names':fresh?`New skills available · ${skills.installed} of ${skills.total} installed`:'Partly installed',cls:'warn',buttons:installable?[{label:(skills.missing||[]).length?'Install':'Update',enabled:true},remove]:[remove]};
- }
- if(skills.state==='conflict')return{text:'A skill you created or edited already uses this name',cls:'warn',buttons:[{label:'Install',enabled:true,disabled:true}]};
- return{text:'Usage review, budget pacing, and skill hygiene',cls:'',buttons:[{label:'Install',enabled:true}]};
-}
-function agentSkillsRow(row){
- const view=agentSkillsView(row);
- const buttons=view.buttons.map(b=>`<button class="tbtn ${b.enabled?'':'danger'}" type=button data-agent-skills="${esc(row.id)}" data-agent-enabled="${b.enabled?'true':'false'}" ${b.disabled?'disabled':''}>${b.label}</button>`).join('');
- return `<div class="agentClientPart agentClientSkills"><div><div class=agentClientName>Token Meter skills</div><div class="agentClientState ${view.cls}">${esc(view.text)}</div></div><div class=agentClientActions>${buttons}</div></div>`;
-}
-function openAgentSkillsDialog(client,enabled){
- const row=(AGENT_ACCESS?.clients||[]).find(item=>item.id===client);
- if(!row?.skills)return;
- const skills=row.skills, folder=client==='codex'?'~/.codex/skills':'~/.claude/skills';
- const skip=new Set([...(skills.unmanaged||[]),...(enabled?[]:(skills.missing||[]))]);
- const keep=enabled?new Set((skills.names||[]).filter(name=>!(skills.missing||[]).includes(name)&&!(skills.outdated||[]).includes(name))):new Set();
- const names=(skills.names||[]).filter(name=>!skip.has(name)&&!keep.has(name));
- const verb=!enabled?'Remove':skills.state==='outdated'?'Update':'Install';
- pendingAgentAccess={kind:'skills',client,enabled,row,verb};
- $('agent-dialog-title').textContent=`${verb} Token Meter skills for ${skills.target}?`;
- $('agent-dialog-sub').textContent=enabled?`Copy Token Meter's skills into ${folder}.`:`Delete only Token Meter's own skill files from ${folder}.`;
- $('agent-dialog-evidence').innerHTML=enabled
-  ? '<div>Skills run only when you ask. They read numbers through the <code>tokenmeter</code> MCP, so connect it too.</div><div>A skill with the same name that you created or edited is never changed.</div><div>Token Meter updates its unedited copies when it updates; remove them here at any time.</div>'
-  : '<div>Your MCP connection, dashboard, and history stay unchanged.</div><div>Skills you created or edited are never deleted.</div>';
- $('agent-dialog-command-label').textContent=enabled?'Files to write':'Files to delete';
- $('agent-dialog-command').textContent=names.map(name=>`${folder}/${name}/SKILL.md`).join('\n');
- $('agent-dialog-note').textContent='Only unedited files Token Meter installed are managed. Start a new agent session after the change.';
- $('agent-confirm').textContent=verb;
- $('agent-confirm').classList.toggle('danger',!enabled);
- $('agent-dialog').showModal();
-}
-function renderAgentAccess(status){
- AGENT_ACCESS=status;
- const clients=status?.clients||[];
- $('agent-clients').innerHTML=clients.map(row=>{
-  const stateClass=row.connected?'connected':row.conflict?'warn':'';
-  const label=row.connected?'Disconnect':row.conflict?'Repair':'Connect';
-  const disabled=!row.connected&&!row.available;
-  const detail=!row.detected?(row.id==='claude'?row.status:'CLI not found'):!row.available?'Token Meter launcher unavailable':row.status;
-  return `<div class=agentClient><div class=agentClientPart><div><div class=agentClientName>${esc(row.label)} MCP</div><div class="agentClientState ${stateClass}">${esc(detail)}${row.connected?' · available in new sessions':''}</div></div><button class="tbtn ${row.connected?'danger':''}" type=button data-agent-client="${esc(row.id)}" data-agent-enabled="${row.connected?'false':'true'}" ${disabled?'disabled':''}>${label}</button></div>${agentSkillsRow(row)}</div>`;
- }).join('')||'<div class=agentClient><div><div class=agentClientName>Status unavailable</div><div class=agentClientState>Refresh Token Meter and try again.</div></div></div>';
- const dismissed=localStorage.getItem('tm_agent_discovery_dismissed')==='1';
- $('agent-discovery').hidden=!!(dismissed||!status?.any_detected||status?.any_connected);
-}
-async function loadAgentAccess(){
- if(agentAccessLoading)return false;
- agentAccessLoading=true;
- try{
-  const response=await fetch('/agent-access/status',{cache:'no-store'});
-  if(!response.ok)throw new Error(`Connection status failed (${response.status}).`);
-  renderAgentAccess(await response.json());
-  return true;
- }catch(error){
-  $('agent-clients').innerHTML='<div class=agentClient><div><div class=agentClientName>Could not read connection status</div><div class=agentClientState>Token Meter will retry when you reopen this view.</div></div></div>';
-  $('agent-discovery').hidden=true;
-  return false;
- }finally{agentAccessLoading=false;}
-}
-function openAgentAccessDialog(client,enabled){
- const row=(AGENT_ACCESS?.clients||[]).find(item=>item.id===client);
- if(!row)return;
- const repairing=!!(enabled&&row.conflict);
- pendingAgentAccess={client,enabled,row};
- $('agent-dialog-title').textContent=`${repairing?'Repair':enabled?'Connect':'Disconnect'} ${row.label}?`;
- $('agent-dialog-sub').textContent=repairing
-  ? 'Replace only the existing user-level tokenmeter entry with the launcher from this Token Meter install.'
-  : enabled?'Add Token Meter as a user-level, local stdio MCP server.':'Remove only Token Meter’s exact user-level MCP entry.';
- $('agent-dialog-evidence').innerHTML=repairing
-  ? '<div>The existing tokenmeter entry will be removed, recreated with this install’s launcher, and verified.</div><div>No other MCP entries or agent settings are changed.</div><div>Existing agent sessions keep their loaded tool list until restarted.</div>'
-  : enabled
-  ? '<div>Read-only and on demand; no background agent monitoring.</div><div>Prompts, messages, reasoning, tool arguments, tool results, credentials, config values, and named history are excluded.</div><div>Returned metrics enter this agent’s context and may be processed by its model provider.</div>'
-  : '<div>Your Token Meter dashboard and local history stay unchanged.</div><div>Existing agent sessions keep their loaded tool list until restarted.</div>';
- $('agent-dialog-command-label').textContent='Exact local command';
- $('agent-dialog-note').innerHTML='Only Token Meter&rsquo;s exact <code>tokenmeter</code> entry is managed. Start a new agent session after the change.';
- $('agent-dialog-command').textContent=repairing?`${row.disconnect_command}\n${row.connect_command}`:enabled?row.connect_command:row.disconnect_command;
- $('agent-confirm').textContent=repairing?'Repair':enabled?'Connect':'Disconnect';
- $('agent-confirm').classList.toggle('danger',!enabled);
- $('agent-dialog').showModal();
-}
-$('agent-clients').onclick=async e=>{
- const skillsButton=e.target.closest('[data-agent-skills]');
- if(skillsButton){if(!skillsButton.disabled)openAgentSkillsDialog(skillsButton.dataset.agentSkills,skillsButton.dataset.agentEnabled==='true');return;}
- const button=e.target.closest('[data-agent-client]');
- if(!button||button.disabled)return;
- const client=button.dataset.agentClient;
- if((AGENT_ACCESS?.clients||[]).find(item=>item.id===client)?.blocked){
-  if(agentAccessRechecking)return;
-  agentAccessRechecking=true;
-  let refreshed=false;
-  try{refreshed=await loadAgentAccess();}finally{agentAccessRechecking=false;}
-  if(!refreshed)return;
-  const row=(AGENT_ACCESS?.clients||[]).find(item=>item.id===client);
-  if(row?.blocked){
-   const action=row.connected?'Disconnect':row.conflict?'Repair':'Connect';
-   showAppToast(row.unreadable
-    ? {title:'Claude app settings could not be read',body:`Token Meter left the Claude app's settings file unchanged. Fix or replace that file, then click ${action} here again.`,kind:'warn',sticky:true}
-    : {title:'Quit the Claude app first',body:`The Claude app rewrites its settings while it is open, so Token Meter cannot change them yet. Quit it with ⌘Q (closing the window is not enough), then click ${action} here again.`,kind:'warn',sticky:true});
-   return;
-  }
-  if(row)openAgentAccessDialog(client,!row.connected);
-  return;
- }
- openAgentAccessDialog(client,button.dataset.agentEnabled==='true');
-};
-$('agent-cancel').onclick=()=>{$('agent-dialog').close();pendingAgentAccess=null;};
-$('agent-dialog').addEventListener('cancel',()=>{pendingAgentAccess=null;});
-$('agent-confirm').onclick=async()=>{
- if(!pendingAgentAccess)return;
- const token=agentActionToken();
- if(!token){showAppToast({title:'Connection not ready',body:'Wait for Token Meter’s live state, then try again.',kind:'warn'});return;}
- const button=$('agent-confirm'), action=pendingAgentAccess;
- if(action.kind==='skills'){
-  button.disabled=true;button.textContent=action.verb==='Update'?'Updating…':action.enabled?'Installing…':'Removing…';
-  try{
-   const response=await fetch('/agent-skills/toggle',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({client:action.client,enabled:action.enabled})});
-   const result=await response.json();
-   if(!response.ok||!result.ok)throw new Error(result.error||'Skill change failed.');
-   $('agent-dialog').close();pendingAgentAccess=null;
-   await loadAgentAccess();
-   showAppToast({title:result.partial?'Skills partly installed':action.verb==='Update'?'Skills updated':action.enabled?'Skills installed':'Skills removed',body:result.message||'Start a new agent session for the change to take effect.',kind:result.partial?'warn':action.enabled?'good':'neutral',sticky:true});
-  }catch(error){
-   await loadAgentAccess();
-   showAppToast({title:'Skill change failed',body:error.message||String(error),kind:'warn',sticky:true});
-  }finally{button.disabled=false;if(pendingAgentAccess)button.textContent=pendingAgentAccess.verb;}
-  return;
- }
- const repairing=!!(action.enabled&&action.row.conflict);
- button.disabled=true;button.textContent=repairing?'Repairing…':action.enabled?'Connecting…':'Disconnecting…';
- try{
-  const response=await fetch('/agent-access/toggle',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({client:action.client,enabled:action.enabled,repair:repairing})});
-  const result=await response.json();
-  if(!response.ok||!result.ok)throw new Error(result.error||'Connection change failed.');
-  localStorage.setItem('tm_agent_discovery_dismissed','1');
-  $('agent-dialog').close();pendingAgentAccess=null;
-  await loadAgentAccess();
-  showAppToast({title:result.repaired?'Connection repaired':action.enabled?'Agent connected':'Agent disconnected',body:result.message||'Start a new agent session for the change to take effect.',kind:action.enabled?'good':'neutral',sticky:true});
- }catch(error){
-  showAppToast({title:'Connection change failed',body:error.message||String(error),kind:'warn',sticky:true});
- }finally{button.disabled=false;if(pendingAgentAccess)button.textContent=pendingAgentAccess.enabled?(pendingAgentAccess.row.conflict?'Repair':'Connect'):'Disconnect';}
-};
-$('agent-discovery-open').onclick=()=>{setHashRoute('settings');setTimeout(()=>$('agent-access').scrollIntoView({behavior:'smooth',block:'start'}),30);};
-$('agent-discovery-close').onclick=()=>{localStorage.setItem('tm_agent_discovery_dismissed','1');$('agent-discovery').hidden=true;};
-function pushAppNotice(title,body,kind='neutral',opts={}){
- const entry={title,body:body||'',kind,time:notifyStamp(),sticky:!!opts.sticky};
- notifyLog.unshift(entry); notifyLog=notifyLog.slice(0,24); saveNotifyLog(); renderNotifyLog(); showAppToast(entry);
- $('notify')?.classList.add('hasnew');
- setNotifyState((opts.status||'Notification logged')+' at '+entry.time+'.');
- return entry;
-}
-function browserBlockReason(){
- if(!canNotify) return 'Browser notifications are not supported here.';
- if(!notifySecure) return 'Notifications require localhost or a secure origin.';
- if(Notification.permission==='denied') return 'Notifications are blocked in browser or system settings.';
- if(Notification.permission!=='granted') return 'Browser notification permission is not granted.';
- return '';
-}
-function notifyBlockReason(){
- if(!notifyOn) return 'Browser notifications are off.';
- return browserBlockReason();
-}
-function paintNotify(){
- let browserReason=browserBlockReason();
- if(notifyOn&&browserReason){
-  notifyOn=false;
-  localStorage.setItem('tm_notify','0');
- }
- const control=$('notify');
- if(control){control.classList.toggle('on',notifyOn);control.setAttribute('aria-checked',String(notifyOn));}
- browserReason=browserBlockReason();
- if($('notifytxt'))$('notifytxt').textContent=notifyOn?'Budget alerts':(!canNotify?'Unavailable':(Notification.permission==='denied'?'Blocked':'Budget alerts'));
- if(notifyOn) setNotifyState('Browser notifications ready.');
- else setNotifyState(browserReason||'Browser notifications are off.');
-}
-function fireNotification(title,body,key,opts={}){
- const reason=notifyBlockReason();
- if(reason){
-  if(reason!=='Browser notifications are off.'){
-   notifyOn=false;
-   localStorage.setItem('tm_notify','0');
-   paintNotify();
-  }
-  setNotifyState(reason);
-  return false;
- }
- const k=opts.dedupe===false?(key||title)+':'+Date.now():(key||title+body);
- if(notifiedKeys.has(k)) return false;
- try{
-  const n=new Notification(title,{body,tag:k,renotify:!!opts.renotify,requireInteraction:!!opts.requireInteraction,timestamp:Date.now()});
-  n.onclick=()=>{ try{ window.focus(); n.close(); }catch(e){} };
-  notifiedKeys.add(k);
-  const entry=pushAppNotice(title,body,opts.kind||'neutral',{sticky:opts.requireInteraction,status:'Browser notification sent'});
-  setNotifyState('Browser notification sent at '+entry.time+'.');
-  return true;
- }catch(e){
-  pushAppNotice('Browser notification failed',`${title}: ${body}`,'warn',{sticky:true,status:'Browser notification failed'});
-  setNotifyState('Browser notification failed: '+(e&&e.message?e.message:'browser rejected it')+'.');
-  return false;
- }
-}
-function sendTestNotification(){
- return fireNotification('Token Meter test','Notifications are working for this dashboard.','test',{dedupe:false,requireInteraction:true,renotify:true});
-}
-function applyPermission(p,after){
- if(p==='granted'){
-  notifyOn=true;
-  localStorage.setItem('tm_notify','1');
-  paintNotify();
-  notifiedKeys.clear();
-  if(after==='test') sendTestNotification(); else fireNotification('Token Meter','Notifications enabled.','enabled:'+Date.now(),{dedupe:false,renotify:true});
-  if(CURRENT&&!pinned) setTimeout(()=>notifyAlertForSession(CURRENT,{forceCurrent:true}),350);
- }
- else{
-  notifyOn=false;
-  localStorage.setItem('tm_notify','0');
-  paintNotify();
-  if(p==='denied') pushAppNotice('Browser notifications blocked','Enable notifications in browser or system settings, then toggle again.','warn',{sticky:true,status:'Browser notifications blocked'});
-  else pushAppNotice('Browser notifications not enabled','Permission was not granted for browser notifications.','warn',{status:'Permission not granted'});
- }
-}
-function requestNotify(after){
- if(!canNotify){ setNotifyState('Browser notifications are not supported here.'); pushAppNotice('Browser notifications unavailable','This browser does not support notifications.','warn',{sticky:true,status:'Browser notifications unavailable'}); return; }
- if(!notifySecure){ setNotifyState('Notifications require localhost or a secure origin.'); pushAppNotice('Browser notifications unavailable','Notifications require localhost or a secure origin.','warn',{sticky:true,status:'Browser notifications unavailable'}); return; }
- const req=Notification.requestPermission();
- if(req&&typeof req.then==='function') req.then(p=>applyPermission(p,after)); else applyPermission(req,after);
-}
-paintNotify();
-renderNotifyLog();
-
-const SESSION_BUDGET_SLIDER_MIN=0.5;
-const SESSION_BUDGET_SLIDER_BASE_MAX=100;
-let legacySessionBudgets={};
-const sessionBudgetWrites=new Map();
-try{legacySessionBudgets=JSON.parse(localStorage.getItem('tm_session_budgets')||'{}')||{};}catch(e){legacySessionBudgets={};}
-localStorage.removeItem('tm_budget');
-// A subagent run spends against its root session's cap, which the server names.
-function budgetSessionKey(s){return String(s?.session_budget?.id||s?.source?.id||s?.session||'unknown');}
-function saveLegacySessionBudgets(){try{localStorage.setItem('tm_session_budgets',JSON.stringify(legacySessionBudgets));}catch(e){}}
-function sessionBudgetForSession(s){
- const saved=parseFloat(s?.session_budget?.budget_usd);
- if(Number.isFinite(saved)&&saved>0)return saved;
- const legacy=parseFloat(legacySessionBudgets[budgetSessionKey(s)]);
- if(Number.isFinite(legacy)&&legacy>0)return legacy;
- return defaultSessionBudget;
-}
-function sessionBudgetSource(s){return s?.session_budget?.source||'legacy';}
-// A session family (root plus child runs) shares one cap; the server reports
-// its combined spend, which is a lower bound when any member lacks evidence.
-function sessionCapSpend(s){
- const b=s?.session_budget;
- if(b&&Object.prototype.hasOwnProperty.call(b,'cost_partial')){
-  const spend=Number(b.spend_usd),available=b.cost_available!==false&&b.spend_usd!=null&&Number.isFinite(spend);
-  return {available,spend:available?spend:0,partial:available&&!!b.cost_partial};
- }
- return {available:metricAvailable(s||{},'cost'),spend:Number(s?.total_cost)||0,partial:false};
-}
-async function persistSessionBudget(s,value,{migrating=false}={}){
- const sessionId=budgetSessionKey(s),response=await fetch('/settings/session-budget',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':agentActionToken()},body:JSON.stringify({session_id:sessionId,budget_usd:value})});
- const result=await response.json();
- if(!response.ok||!result.ok)throw new Error(result.error||'Could not save session budget.');
- if(s)s.session_budget=result.session_budget;
- if(migrating){delete legacySessionBudgets[sessionId];saveLegacySessionBudgets();}
- return result.session_budget;
-}
-function queueSessionBudget(s,value,{migrating=false}={}){
- const sessionId=budgetSessionKey(s);
- let entry=sessionBudgetWrites.get(sessionId);
- if(!entry){entry={pending:false,saving:false,write:null,promise:null};sessionBudgetWrites.set(sessionId,entry);}
- entry.write={value,migrating};entry.pending=true;
- if(entry.saving)return entry.promise;
- entry.saving=true;
- entry.promise=(async()=>{
-  let finalError=null;
-  while(entry.pending){
-   const write=entry.write;entry.pending=false;
-   try{await persistSessionBudget(s,write.value,{migrating:write.migrating});finalError=null;}
-   catch(error){finalError=error;}
-  }
-  entry.saving=false;
-  if(sessionBudgetWrites.get(sessionId)===entry)sessionBudgetWrites.delete(sessionId);
-  if(finalError)throw finalError;
- })();
- return entry.promise;
-}
-function migrateLegacySessionBudget(s){
- const sessionId=budgetSessionKey(s),legacy=parseFloat(legacySessionBudgets[sessionId]);
- if(sessionBudgetSource(s)!=='default'||!Number.isFinite(legacy)||legacy<=0)return;
- queueSessionBudget(s,legacy,{migrating:true}).then(()=>{if(s===CURRENT)syncSessionBudgetControls(sessionBudgetForSession(s),s);}).catch(()=>{});
-}
-function sessionBudgetSliderMax(s,value){
- const reference=Math.max(defaultSessionBudget,Number(value)||0,sessionCapSpend(s).spend);
- return Math.max(SESSION_BUDGET_SLIDER_BASE_MAX,Math.ceil(reference*1.5/10)*10);
-}
-function syncSessionBudgetControls(value,s=CURRENT){
- const n=Math.max(0.5,Number(value)||defaultSessionBudget);
- const slider=$('budget-slider'),max=sessionBudgetSliderMax(s,n);
- $('budget').value=formatBudgetInput(n);
- slider.max=String(max);
- slider.value=String(Math.min(max,Math.max(SESSION_BUDGET_SLIDER_MIN,n)));
- const min=Number(slider.min)||SESSION_BUDGET_SLIDER_MIN;
- slider.style.setProperty('--budget-fill',`${Math.max(0,Math.min(100,100*(Number(slider.value)-min)/(max-min||1)))}%`);
-  $('budget-slider-min').textContent=money(min);
- $('budget-slider-max').textContent=money(max);
- const capSpend=sessionCapSpend(s);
- $('session-budget-spend').textContent=capSpend.available?`Session spend ${capSpend.partial?'at least ':''}${money(capSpend.spend)}${s?.cost_approx?' est':''}`:'Session spend unavailable';
-}
-function loadBudgetForSession(s){
- syncSessionBudgetControls(sessionBudgetForSession(s),s);
- migrateLegacySessionBudget(s);
-}
-let sessionBudgetStatusTimer=0;
-function saveBudgetForSession(value){
- if(!CURRENT)return;
- const n=parseFloat(value);
- if(!Number.isFinite(n)||n<=0)return;
- syncSessionBudgetControls(n,CURRENT);
- queueSessionBudget(CURRENT,n).then(()=>{const status=$('session-budget-status');status.textContent='Saved';clearTimeout(sessionBudgetStatusTimer);sessionBudgetStatusTimer=setTimeout(()=>{status.textContent='';},2500);}).catch(error=>showAppToast({title:'Session budget could not be saved',body:error.message||String(error),kind:'warn',sticky:true}));
- return n;
-}
-$('budget').value=String(defaultSessionBudget);
-$('budget').addEventListener('input',()=>saveBudgetForSession($('budget').value));
-$('budget').addEventListener('change',()=>{if(CURRENT)renderSession(CURRENT);});
-$('budget-slider').addEventListener('input',()=>saveBudgetForSession($('budget-slider').value));
-$('budget-slider').addEventListener('change',()=>{if(CURRENT)renderSession(CURRENT);});
-function dollarInputValue(id,fallback=1e9){
- const n=parseFloat($(id)?.value);
- return Number.isFinite(n)&&n>0?n:fallback;
-}
-function formatBudgetInput(n){
- n=Math.max(0,Math.ceil((n||0)*2)/2);
- return Number.isInteger(n)?String(n):n.toFixed(1);
-}
-function setBudgetCap(n){
- const value=formatBudgetInput(n);
- return saveBudgetForSession(value)||parseFloat(value);
-}
-function extendBudget(){
- if(!CURRENT) return;
- const add=parseFloat($('budget-add').value);
- if(!Number.isFinite(add)||add<=0){ setNotifyState('Enter a positive budget amount.'); return; }
- const currentCost=sessionCapSpend(CURRENT).spend;
- const currentCap=dollarInputValue('budget',0);
- const next=setBudgetCap(Math.max(currentCap,currentCost)+add);
- setNotifyState('Budget raised to '+money(next)+'.');
- pushAppNotice('Budget updated','Session budget raised to '+money(next)+'.','neutral',{status:'Budget updated'});
- renderSession(CURRENT);
-}
-$('budget-add-btn').onclick=extendBudget;
-$('budget-add').addEventListener('keydown',e=>{ if(e.key==='Enter') extendBudget(); });
-
-const CHART_SCALES=['linear','cumulative'];
-let chartScale=localStorage.getItem('tm_chart_scale')||'linear';
-if(!CHART_SCALES.includes(chartScale)){
- chartScale='linear';
- localStorage.setItem('tm_chart_scale',chartScale);
-}
-function paintScale(){
- [...$('scale').querySelectorAll('button')].forEach(b=>{
-  const selected=b.dataset.scale===chartScale;
-  b.classList.toggle('on',selected);
-  b.setAttribute('aria-pressed',selected?'true':'false');
- });
-}
-$('scale').onclick=e=>{ if(e.target.dataset.scale){ chartScale=e.target.dataset.scale; localStorage.setItem('tm_chart_scale',chartScale); paintScale(); if(CURRENT) drawIO(CURRENT.series||[]); } };
-paintScale();
-
-const CHART_MODES=['tokens','cost','context','tools','steps','wait'];
-const requestedChartMode=new URLSearchParams(location.search).get('chart');
-let chartMode=CHART_MODES.includes(requestedChartMode)?requestedChartMode:'tokens';
-if(chartMode==='cache'){
- chartMode='tokens';
- localStorage.setItem('tm_chart_mode',chartMode);
-}
-if(!CHART_MODES.includes(chartMode)){
- chartMode='tokens';
- localStorage.setItem('tm_chart_mode',chartMode);
-}
-function paintChartMode(){
- [...$('chart-mode').querySelectorAll('button')].forEach(b=>b.classList.toggle('on',b.dataset.chart===chartMode));
-}
-$('chart-mode').onclick=e=>{ if(e.target.dataset.chart){ chartMode=e.target.dataset.chart; localStorage.setItem('tm_chart_mode',chartMode); paintChartMode(); if(CURRENT) drawIO(CURRENT.series||[]); } };
-paintChartMode();
-
-let globalSearch=localStorage.getItem('tm_global_search')||'';
-let globalSort=localStorage.getItem('tm_global_sort')||'recent';
-let globalApp=localStorage.getItem('tm_global_app')||'';
-if(['claude_code','claude_desktop'].includes(globalApp)){
- globalApp='claude';
- localStorage.setItem('tm_global_app',globalApp);
-}
-let globalProject=localStorage.getItem('tm_global_project')||'';
-let globalTime=localStorage.getItem('tm_global_time')||DEFAULT_TIME_FILTER_WINDOW;
-let globalShowChildren=localStorage.getItem('tm_global_children')==='show';
-let childSessionMap=new Map();
-let subagentUsageDimension=localStorage.getItem('tm_subagent_usage_dimension')||'runtimes';
-if(!['runtimes','models','depths','kinds','roles'].includes(subagentUsageDimension))subagentUsageDimension='runtimes';
-let subagentUsageSort=localStorage.getItem('tm_subagent_usage_sort')||'cost';
-if(!['cost','tokens','agents','output'].includes(subagentUsageSort))subagentUsageSort='cost';
-let subagentView=localStorage.getItem('tm_subagent_view')||'roles';
-if(!['issues','sessions','roles'].includes(subagentView))subagentView='roles';
-let subagentRoleChartMode=localStorage.getItem('tm_subagent_role_chart')||'average';
-if(!['spend','average','runs'].includes(subagentRoleChartMode))subagentRoleChartMode='average';
-let subagentFilters={
- query:localStorage.getItem('tm_subagent_filter_search')||'',
- role:localStorage.getItem('tm_subagent_filter_role')||'',
- kind:localStorage.getItem('tm_subagent_filter_kind')||'',
- runtime:localStorage.getItem('tm_subagent_filter_app')||'',
- project:localStorage.getItem('tm_subagent_filter_project')||'',
- model:localStorage.getItem('tm_subagent_filter_model')||'',
- status:localStorage.getItem('tm_subagent_filter_status')||'all',
- signal:localStorage.getItem('tm_subagent_filter_signal')||'all',
- window:localStorage.getItem('tm_subagent_filter_time')||DEFAULT_TIME_FILTER_WINDOW,
- sort:localStorage.getItem('tm_subagent_filter_sort')||'recent',
-};
-if(subagentFilters.sort==='elapsed'){
- subagentFilters.sort='work';
- localStorage.setItem('tm_subagent_filter_sort','work');
-}
-if(subagentFilters.window==='24h'){
- subagentFilters.window='today';
- localStorage.setItem('tm_subagent_filter_time','today');
-}
-if(!TIME_FILTER_WINDOWS.includes(subagentFilters.window)){
- subagentFilters.window=DEFAULT_TIME_FILTER_WINDOW;
- localStorage.removeItem('tm_subagent_filter_time');
-}
-const SUBAGENT_PAGE_SIZE=50;
-let subagentVisibleLimit=SUBAGENT_PAGE_SIZE,selectedSubagentId='',expandedSubagentRoot=null;
-let subagentAdvancedOpen=Boolean(subagentFilters.model||subagentFilters.status!=='all'||subagentFilters.signal!=='all'||subagentFilters.sort!=='recent');
-const logHtmlCache=new WeakMap();
-function setLogText(element,value){
- value=String(value??'');
- if(element.textContent!==value)element.textContent=value;
-}
-function setLogAttribute(element,name,value){
- value=String(value??'');
- if(element.getAttribute(name)!==value)element.setAttribute(name,value);
-}
-function setLogHtml(element,html){
- if(logHtmlCache.get(element)===html)return;
- element.innerHTML=html;
- logHtmlCache.set(element,html);
-}
-function setLogSelectOptions(element,html,value){
- setLogHtml(element,html);
- if(element.value!==value)element.value=value;
-}
-async function loadAllSessions(){
- if(allSessionsRequest)return allSessionsRequest;
- allSessionsRequest=fetch('/logs',{cache:'no-store'}).then(response=>{
-  if(!response.ok)throw new Error(`All sessions request failed (${response.status}).`);
-  return response.json();
- }).then(payload=>{
-  allSessionInventory=payload.sessions||[];
-  allSessionInventoryAt=Number(payload.generated_at||0);
-  if(LATEST&&$('view-session').classList.contains('on')&&sessionScope==='all')renderAllSessions(LATEST.xsession);
-  if(LATEST&&($('view-subagents').classList.contains('on')||($('view-session').classList.contains('on')&&sessionScope==='subagents')))renderSubagentExplorer(LATEST.xsession?.agent_usage);
-  return allSessionInventory;
- }).catch(()=>allSessionInventory||[]).finally(()=>{allSessionsRequest=null;});
- return allSessionsRequest;
-}
-function loadProjectModelFilterMap(){
- const stored=localStorage.getItem('tm_model_project_filters');
- if(!stored)return {};
- try{
-  const parsed=JSON.parse(stored);
-  return parsed&&typeof parsed==='object'&&!Array.isArray(parsed)?parsed:{};
- }catch(error){return {};}
-}
-function loadModelFilters(project=''){
- if(project){
-  const scoped=loadProjectModelFilterMap(),values=scoped[project];
-  return Array.isArray(values)?[...new Set(values.filter(value=>typeof value==='string'&&value))]:[];
- }
- const stored=localStorage.getItem('tm_model_filters');
- if(stored!==null){try{const parsed=JSON.parse(stored);if(Array.isArray(parsed))return [...new Set(parsed.filter(value=>typeof value==='string'&&value))];}catch(error){}}
- const legacy=localStorage.getItem('tm_model_filter')||'';
- return legacy?[legacy]:[];
-}
-function saveActiveModelFilters(){
- if(!modelProject)localStorage.setItem('tm_model_filters',JSON.stringify(modelFilters));
- else{
-  const scoped=loadProjectModelFilterMap();
-  scoped[modelProject]=modelFilters;
-  localStorage.setItem('tm_model_project_filters',JSON.stringify(scoped));
- }
- localStorage.removeItem('tm_model_filter');
-}
-let modelProject=localStorage.getItem('tm_model_project')||'';
-let modelFilters=loadModelFilters(modelProject);
-const MODEL_RANGES=['today','yesterday','7','30','90','month','last_month','all'];
-let modelRange=localStorage.getItem('tm_model_range')||'30';
-let modelTrendMetric=localStorage.getItem('tm_model_trend_metric')||'speed';
-const MODEL_MIX_KEYS=['cost','output','executions'];
-let modelMixMetric=localStorage.getItem('tm_model_mix_metric');if(!MODEL_MIX_KEYS.includes(modelMixMetric))modelMixMetric='cost';
-const MODEL_SORT_KEYS=['model','cost','cost_per_exec','cache','executions','output','speed','wait','pushback'];
-let modelSort=(()=>{try{const stored=JSON.parse(localStorage.getItem('tm_model_sort')||'null');if(stored&&MODEL_SORT_KEYS.includes(stored.key)&&['asc','desc'].includes(stored.direction))return {key:stored.key,direction:stored.direction};}catch(error){}return {key:'cost',direction:'desc'};})();
-const modelExpandedGroups=new Set();
-const MODEL_SPEED_MAX_SERIES=8;
-let modelSpeedSelection=(()=>{try{const stored=JSON.parse(localStorage.getItem('tm_model_speed_models')||'null');return Array.isArray(stored)?[...new Set(stored.filter(value=>typeof value==='string'&&value))].slice(0,MODEL_SPEED_MAX_SERIES):null;}catch(error){return null;}})();
-let activeModelStats=null,activeModelScope='',activeModelGeneration=0;
-let modelProjectRequest=0,modelProjectLoadingKey='';
-const modelProjectCache=new Map();
-const OTHER_LOCAL_SESSIONS_PROJECT='__other_local_sessions__';
-function projectFilterValue(value){
- const project=String(value||'').trim().replaceAll('\\','/');
- return project&&(project.startsWith('/')&&!project.startsWith('/private/')||project.startsWith('~/')&&!project.startsWith('~/.codex/')&&!project.startsWith('~/Library/')&&!project.startsWith('~/Documents/Codex/')||/^[A-Za-z]:\//.test(project))?project:OTHER_LOCAL_SESSIONS_PROJECT;
-}
-function projectFilterLabel(value){return value===OTHER_LOCAL_SESSIONS_PROJECT?'Other local sessions':value;}
-function storedModelFilterId(value){return typeof value==='string'&&value.length<=200&&!/[\\/\x00-\x1F\x7F]/.test(value)&&/^[^:]+::[^:]+(?:::[^:]+)?$/.test(value);}
-function migrateStoredProjectFilters(key,scoped=false){
- const stored=localStorage.getItem(key);if(!stored)return scoped?undefined:'';
- if(!scoped){const project=projectFilterValue(stored);if(project!==stored)localStorage.setItem(key,project);return project;}
- let parsed={};try{const value=JSON.parse(stored);if(value&&typeof value==='object'&&!Array.isArray(value))parsed=value;}catch(error){return;}
- const grouped={};Object.entries(parsed).forEach(([project,values])=>{if(!Array.isArray(values))return;const group=projectFilterValue(project);grouped[group]=[...new Set([...(grouped[group]||[]),...values.filter(storedModelFilterId)])];});
- if(JSON.stringify(grouped)!==JSON.stringify(parsed))localStorage.setItem(key,JSON.stringify(grouped));
-}
-migrateStoredProjectFilters('tm_model_project_filters',true);
-migrateStoredProjectFilters('tm_efficiency_project_filters',true);
-globalProject=migrateStoredProjectFilters('tm_global_project');
-modelProject=migrateStoredProjectFilters('tm_model_project');
-modelFilters=loadModelFilters(modelProject);
-if(!['recent','cost','tokens','executions','wait'].includes(globalSort)) globalSort='recent';
-if(globalTime!==normalizeTimeFilterWindow(globalTime)){globalTime=normalizeTimeFilterWindow(globalTime);if(globalTime===DEFAULT_TIME_FILTER_WINDOW)localStorage.removeItem('tm_global_time');else localStorage.setItem('tm_global_time',globalTime);}
-if(!MODEL_RANGES.includes(modelRange)){modelRange='30';localStorage.setItem('tm_model_range',modelRange);}
-if(!['speed','wait','avg_input','avg_output'].includes(modelTrendMetric))modelTrendMetric='speed';
-$('m-range').value=modelRange;
-function modelScopeLabel(project=modelProject){return project?projectFilterLabel(project):'All projects';}
-function paintModelProjects(stats){
- const projects=(stats?.projects||[]).filter(project=>typeof project==='string'&&project);
- if(modelProject&&!projects.includes(modelProject)){
-  modelProject='';modelFilters=loadModelFilters('');
-  localStorage.removeItem('tm_model_project');
- }
- const projectSelect=$('m-project'),projectOptions='<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(projectFilterLabel(project))}</option>`).join('');
- setLogSelectOptions(projectSelect,projectOptions,modelProject);
- const projectTitle=stats?.projects_truncated?'Showing the first 500 discovered projects.':'';
- if(projectSelect.title!==projectTitle)projectSelect.title=projectTitle;
-}
-function setModelProjectLoading(loading){
- const projectSelect=$('m-project');
- if(loading)projectSelect.setAttribute('aria-busy','true');
- else projectSelect.removeAttribute('aria-busy');
-}
-function commitModelStats(stats,scope,generation){
- activeModelStats=stats;activeModelScope=scope;activeModelGeneration=generation;
- setModelProjectLoading(false);
- $('m-project-status').textContent='';$('m-project-status').classList.remove('warn');
- renderModelStats(stats);
-}
-async function renderActiveModelStats(){
- if(!LATEST)return;
- const machine=LATEST.xsession?.model_stats||{models:[],projects:[]},generation=Number(LATEST.xsession?.generated_at||0);
- paintModelProjects(machine);
- if(!modelProject){
-  modelProjectRequest++;modelProjectLoadingKey='';
-  setModelProjectLoading(false);
-  commitModelStats(machine,'',generation);
-  return;
- }
- const project=modelProject,key=`${generation}\n${project}`,cached=modelProjectCache.get(key);
- if(cached){commitModelStats(cached,project,generation);return;}
- if(modelProjectLoadingKey===key)return;
- $('m-project-status').textContent='';
- $('m-project-status').classList.remove('warn');
- setModelProjectLoading(true);
- modelProjectLoadingKey=key;
- const request=++modelProjectRequest;
- try{
-  const response=await fetch('/model-stats?project='+encodeURIComponent(project),{cache:'no-store'});
-  const payload=await response.json();
-  if(!response.ok||!payload.ok)throw new Error('Project model stats are unavailable.');
-  if(request!==modelProjectRequest||project!==modelProject)return;
-  const responseGeneration=Number(payload.generated_at||generation);
-  modelProjectCache.set(key,payload.model_stats);
-  modelProjectCache.set(`${responseGeneration}\n${project}`,payload.model_stats);
-  commitModelStats(payload.model_stats,project,responseGeneration);
- }catch(error){
-  if(request!==modelProjectRequest||project!==modelProject)return;
-  $('m-project-status').textContent=`Could not load ${projectFilterLabel(project)}${activeModelStats?` · still showing ${modelScopeLabel(activeModelScope)}`:''}`;
-  $('m-project-status').classList.add('warn');
- }finally{
-  if(modelProjectLoadingKey===key){modelProjectLoadingKey='';setModelProjectLoading(false);}
- }
-}
-function rerenderActiveModelStats(){
- if(activeModelStats&&activeModelScope===modelProject)renderModelStats(activeModelStats);
- else renderActiveModelStats();
-}
-$('m-project').addEventListener('change',event=>{
- modelProject=event.target.value;
- modelFilters=loadModelFilters(modelProject);
- if(modelProject)localStorage.setItem('tm_model_project',modelProject);else localStorage.removeItem('tm_model_project');
- modelProjectRequest++;modelProjectLoadingKey='';
- renderActiveModelStats();
-});
-$('m-model-options').addEventListener('change',event=>{
- const input=event.target.closest('input[data-model-choice]');if(!input)return;
- if(input.dataset.modelChoice==='all')modelFilters=[];
- else if(input.checked)modelFilters=[...new Set([...modelFilters,input.value])];
- else modelFilters=modelFilters.filter(name=>name!==input.value);
- saveActiveModelFilters();
- if(LATEST)rerenderActiveModelStats();
-});
-$('m-model-picker').addEventListener('keydown',event=>{if(event.key==='Escape')$('m-model-picker').removeAttribute('open');});
-document.addEventListener('pointerdown',event=>{const picker=$('m-model-picker');if(picker.open&&!picker.contains(event.target))picker.removeAttribute('open');});
-function positionModelPickerMenu(){
- const picker=$('m-model-picker'),menu=$('m-model-options');
- if(!picker.open){picker.classList.remove('opensUp');menu.style.maxHeight='';return;}
- const trigger=picker.querySelector('summary'),rect=trigger.getBoundingClientRect(),margin=12;
- const above=Math.max(0,rect.top-margin),below=Math.max(0,window.innerHeight-rect.bottom-margin),preferred=Math.min(360,menu.scrollHeight||360);
- const opensUp=below<preferred&&above>below,available=opensUp?above:below;
- picker.classList.toggle('opensUp',opensUp);
- menu.style.maxHeight=`${Math.min(360,available)}px`;
-}
-$('m-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionModelPickerMenu));
-window.addEventListener('resize',()=>{if($('m-model-picker').open)positionModelPickerMenu();});
-$('m-mix-metric').onclick=event=>{const metric=event.target.closest('[data-model-mix]')?.dataset.modelMix;if(!MODEL_MIX_KEYS.includes(metric))return;modelMixMetric=metric;localStorage.setItem('tm_model_mix_metric',metric);if(LATEST)rerenderActiveModelStats();};
-$('m-table').querySelector('thead').onclick=event=>{const key=event.target.closest('[data-model-sort]')?.dataset.modelSort;if(!MODEL_SORT_KEYS.includes(key))return;modelSort=modelSort.key===key?{key,direction:modelSort.direction==='asc'?'desc':'asc'}:{key,direction:key==='model'?'asc':'desc'};localStorage.setItem('tm_model_sort',JSON.stringify(modelSort));if(LATEST)rerenderActiveModelStats();};
-$('m-table').querySelector('tbody').onclick=event=>{const button=event.target.closest('[data-model-expand]');if(!button)return;const key=button.dataset.modelExpand;if(modelExpandedGroups.has(key))modelExpandedGroups.delete(key);else modelExpandedGroups.add(key);if(LATEST)rerenderActiveModelStats();};
-$('m-spend').onclick=event=>{
- if(event.target.closest('[data-model-clear]')){modelFilters=[];saveActiveModelFilters();if(LATEST)rerenderActiveModelStats();return;}
- const ids=event.target.closest('[data-model-ids]')?.dataset.modelIds;if(!ids)return;
- modelFilters=ids.split('\n').filter(Boolean);saveActiveModelFilters();if(LATEST)rerenderActiveModelStats();
-};
-$('m-speedchart-options').addEventListener('change',event=>{
- const input=event.target.closest('input[data-model-speed-choice]');if(!input)return;
- const boxes=[...$('m-speedchart-options').querySelectorAll('input[data-model-speed-choice]')],visible=new Set(boxes.map(box=>box.dataset.modelSpeedChoice));
- const hidden=(modelSpeedSelection||[]).filter(key=>!visible.has(key)),checked=boxes.filter(box=>box.checked).map(box=>box.dataset.modelSpeedChoice);
- const next=[...new Set([...checked,...hidden])].slice(0,MODEL_SPEED_MAX_SERIES);
- modelSpeedSelection=checked.length?next:null;
- if(modelSpeedSelection)localStorage.setItem('tm_model_speed_models',JSON.stringify(modelSpeedSelection));else localStorage.removeItem('tm_model_speed_models');
- if(LATEST)rerenderActiveModelStats();
-});
-$('m-speedchart-reset').onclick=()=>{modelSpeedSelection=null;localStorage.removeItem('tm_model_speed_models');if(LATEST)rerenderActiveModelStats();};
-$('m-speedchart-picker').addEventListener('keydown',event=>{if(event.key==='Escape')$('m-speedchart-picker').removeAttribute('open');});
-document.addEventListener('pointerdown',event=>{const picker=$('m-speedchart-picker');if(picker.open&&!picker.contains(event.target))picker.removeAttribute('open');});
-$('m-diagnostics').open=localStorage.getItem('tm_model_diagnostics_open')==='1';
-$('m-diagnostics').addEventListener('toggle',()=>localStorage.setItem('tm_model_diagnostics_open',$('m-diagnostics').open?'1':'0'));
-$('m-range').addEventListener('change',e=>{modelRange=e.target.value;localStorage.setItem('tm_model_range',modelRange);if(LATEST)rerenderActiveModelStats();});
-$('m-metric').onclick=event=>{const metric=event.target.dataset.modelMetric;if(!metric)return;modelTrendMetric=metric;localStorage.setItem('tm_model_trend_metric',metric);if(LATEST)rerenderActiveModelStats();};
-function paintGlobalSort(){
- [...$('g-sort').querySelectorAll('button')].forEach(b=>b.classList.toggle('on',b.dataset.gsort===globalSort));
- const label={recent:'recent activity',cost:'highest cost',tokens:'most tokens',executions:'most executions'}[globalSort]||'recent activity';
- $('g-hint').textContent=label;
-}
-function paintGlobalChildren(){
- [...$('g-children').querySelectorAll('button')].forEach(b=>{
-  const on=(b.dataset.gchildren==='show')===globalShowChildren;
-  b.classList.toggle('on',on);
-  b.setAttribute('aria-pressed',on?'true':'false');
- });
-}
-$('g-children').onclick=event=>{
- const button=event.target.closest('[data-gchildren]');
- if(!button)return;
- globalShowChildren=button.dataset.gchildren==='show';
- localStorage.setItem('tm_global_children',globalShowChildren?'show':'hide');
- paintGlobalChildren();
- if(LATEST)renderAllSessions(LATEST.xsession);
-};
-$('g-search').value=globalSearch;
-$('g-time').value=globalTime;
-paintGlobalChildren();
-function paintGlobalFilters(){
- const disabled=!(globalSearch.trim()||globalApp||globalProject||globalTime!==DEFAULT_TIME_FILTER_WINDOW);
- if($('g-clear').disabled!==disabled)$('g-clear').disabled=disabled;
-}
-$('g-search').addEventListener('input',e=>{ globalSearch=e.target.value; localStorage.setItem('tm_global_search',globalSearch); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
-$('g-app').addEventListener('change',e=>{ globalApp=e.target.value; localStorage.setItem('tm_global_app',globalApp); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
-$('g-project').addEventListener('change',e=>{ globalProject=e.target.value; localStorage.setItem('tm_global_project',globalProject); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
-$('g-time').addEventListener('change',e=>{ globalTime=e.target.value; localStorage.setItem('tm_global_time',globalTime); paintGlobalFilters(); if(LATEST) renderAllSessions(LATEST.xsession); });
-$('g-clear').onclick=()=>{
- globalSearch='';globalApp='';globalProject='';globalTime=DEFAULT_TIME_FILTER_WINDOW;
- $('g-search').value='';$('g-app').value='';$('g-project').value='';$('g-time').value=DEFAULT_TIME_FILTER_WINDOW;
- ['tm_global_search','tm_global_app','tm_global_project','tm_global_time'].forEach(key=>localStorage.removeItem(key));
- paintGlobalFilters();
- if(LATEST)renderAllSessions(LATEST.xsession);
-};
-$('g-active-filters').onclick=event=>{
- const key=event.target.closest('button[data-clear-log-filter]')?.dataset.clearLogFilter;
- if(!key)return;
- if(key==='search'){globalSearch='';$('g-search').value='';localStorage.removeItem('tm_global_search');}
- if(key==='app'){globalApp='';$('g-app').value='';localStorage.removeItem('tm_global_app');}
- if(key==='project'){globalProject='';$('g-project').value='';localStorage.removeItem('tm_global_project');}
- if(key==='time'){globalTime=DEFAULT_TIME_FILTER_WINDOW;$('g-time').value=DEFAULT_TIME_FILTER_WINDOW;localStorage.removeItem('tm_global_time');}
- if(key==='work'){workSessionFilter=null;workFilterRequest++;}
- paintGlobalFilters();
- if(LATEST)renderAllSessions(LATEST.xsession);
-};
-$('g-sort').onclick=e=>{ if(e.target.dataset.gsort){ globalSort=e.target.dataset.gsort; localStorage.setItem('tm_global_sort',globalSort); paintGlobalSort(); if(LATEST) renderAllSessions(LATEST.xsession); } };
-paintGlobalSort();
-paintGlobalFilters();
-
-const cssVar=name=>getComputedStyle(document.documentElement).getPropertyValue(name).trim();
-// viewBox font size that renders at least `px` CSS pixels in a scaled SVG; never shrinks text.
-const svgTextPx=(svg,VW,VH,px=11)=>{const box=svg.getBoundingClientRect(),scale=Math.min(box.width/VW||1,box.height/VH||1);return +(px/Math.min(1,scale)).toFixed(1);};
-const tint=(name,alpha)=>`rgb(${cssVar(`--${name}-rgb`)}/${alpha})`;
-const CHART={};
-function readChartTokens(){Object.assign(CHART,{
- ink:cssVar('--bg'),input:cssVar('--c-input'),output:cssVar('--c-output'),tool:cssVar('--toolcall'),side:cssVar('--signal-mid'),
- cacheRead:cssVar('--c-cache-read'),cacheWrite:cssVar('--c-cache-write'),cost:cssVar('--c-cost'),context:cssVar('--c-context'),
- reason:cssVar('--reason'),muted:tint('tint',.26),
- costFill:cssVar('--chart-cost-fill'),
- axis:cssVar('--chart-axis'),grid:cssVar('--chart-grid'),lbl:cssVar('--chart-label'),
- tip:cssVar('--chart-tip'),tipHead:cssVar('--chart-tip-head'),tipLine:cssVar('--chart-tip-line')
-});}
-readChartTokens();
-function scaledY(v,maxV){
- if(maxV<=0)return 1;
- return Math.max(0,v)/maxV;
-}
-function integerTicks(maxV){
- const top=Math.max(1,Math.ceil(maxV||1));
- if(top<=6) return Array.from({length:top+1},(_,i)=>i);
- const raw=top/4, pow=10**Math.floor(Math.log10(raw));
- const n=raw/pow;
- const step=(n<=1?1:n<=2?2:n<=5?5:10)*pow;
- const hi=Math.ceil(top/step)*step, out=[];
- for(let v=0;v<=hi;v+=step) out.push(v);
- return out;
-}
-function ticks(maxV){
- return [0,.25,.5,.75,1].map(x=>x*maxV);
-}
-function moneyTick(n){
- return money(n);
-}
-function tipAttrs(text){
- const safe=esc(text);
- return `class=fieldtip tabindex=0 aria-description="${safe}" data-tip="${safe}"`;
-}
-function legendField(label,color,tip){
- return `<span ${tipAttrs(tip)}><i class=dot style="background:${color}"></i>${esc(label)}</span>`;
-}
-function chartLegendHtml(mode,cumulative=false){
- const cursor=CURRENT?.provider==='cursor';
- const cumulativeLabel=cumulative?'cumulative ':'';
- const cumulativeTip=cumulative?' Running total through each execution.':'';
- const eventMarks=[
-  legendField('user message','var(--fg)','Execution points with a captured user message preview. The diamond marker sits on the active chart series.'),
-  legendField('notable tools','var(--toolcall)','Executions with unusually high tool-call count for this log/thread.'),
-  legendField('notable reasoning','var(--reason)','Executions with unusually high reasoning tokens for this log/thread.'),
-  legendField('coordination','var(--coord)','Subagent or coordination executions when the log marks them separately.'),
- ].join('');
- if(mode==='context') return [
-  legendField('context','var(--c-context)','Input tokens as a share of the model context window for each execution.'),
-  legendField('70% watch','var(--warn)','Watch threshold: context is getting large enough to consider summarizing or narrowing tool output.'),
-  legendField('85% high','var(--bad)','High threshold: context is close to the model window limit.'),
- ].join('')+eventMarks;
- if(mode==='tokens') return [
-  legendField(cumulativeLabel+(cursor?'input context est':'input total'),'var(--c-input)',(cursor?'One trace-visible context snapshot per Cursor execution; this is a local proxy, not billable input.':'Total input/context tokens for each execution, including uncached input and prompt-cache tokens.')+cumulativeTip),
-  legendField(cumulativeLabel+(cursor?'visible output est':'output'),'var(--c-output)',(cursor?'Model-authored text persisted in Cursor bubbles, estimated at four characters per token.':'Model output tokens produced by the execution.')+cumulativeTip),
-  legendField(cumulativeLabel+'cache read','var(--c-cache-read)','Input tokens served from the provider prompt cache. These are usually cheaper than uncached input.'+cumulativeTip),
-  legendField(cumulativeLabel+'cache write','var(--c-cache-write)','Input tokens written into the provider prompt cache for possible reuse later. Some providers may report zero.'+cumulativeTip),
-  legendField(cumulativeLabel+'uncached input','var(--c-input)','Input tokens charged as normal input because they were new or did not hit prompt cache.'+cumulativeTip),
- ].join('')+eventMarks;
- if(mode==='tools') return [
-  legendField('tool calls','var(--toolcall)','Number of tool calls observed in each execution.'),
- ].join('')+eventMarks;
- if(mode==='steps') return [
-  legendField('steps','var(--toolcall)','Number of executions grouped under each captured user message.'),
-  legendField('request cost','var(--c-cost)','Total estimated cost for the executions in that request.'),
-  legendField('request message','var(--fg)','The user message that started the request, shown in hover.'),
- ].join('');
- if(mode==='wait') return [
-  legendField('wait time','var(--accent)','Wall-clock time from the user prompt until the completed response, including reasoning and tool use.'),
-  legendField('request message','var(--fg)','The captured user message associated with the timed request, when available.'),
- ].join('');
- if(mode==='cost') return legendField(cumulative?(cursor?'cumulative local cost est':'cumulative cost'):(cursor?'local execution estimate':'execution cost'),'var(--c-cost)',(cursor?'Context-and-visible-output proxy priced with the persisted model variant; cache and hidden model work are excluded.':'Estimated USD cost for this execution using the configured public API rates.')+cumulativeTip)+eventMarks;
- return chartLegendHtml('context');
-}
-function chartParts(s){
- let read=+(s.cache_read||0), write=+(s.cache_write||0);
- const legacyCache=+(s.cache||0);
- if(!read&&!write&&legacyCache) read=legacyCache;
- const cache=read+write, rawFresh=s.fresh_input;
- const fresh=Number.isFinite(+rawFresh)?Math.max(0,+rawFresh):Math.max(0,+(s.in||0)-cache);
- const total=Math.max(+(s.in||0),fresh+cache);
- const ctx=s.context_pct===undefined||s.context_pct===null?null:+s.context_pct;
- return {fresh,read,write,cache,total,out:+(s.out||0),cost:+(s.cost||0),context:ctx,reason:+(s.reasoning||0),tools:+(s.tools||0)};
-}
-function cumulativeChartParts(parts,mode){
- const keys=mode==='cost'?['cost']:['fresh','read','write','cache','total','out'];
- const sums=Object.fromEntries(keys.map(key=>[key,0]));
- return parts.map(part=>{
-  keys.forEach(key=>{sums[key]+=Math.max(0,Number(part[key]||0));});
-  return {...part,...sums};
- });
-}
-function requestStepGroups(series){
- const groups=[];
- let cur=null;
- (series||[]).forEach((s,idx)=>{
-  const msg=String(s.user_message||s.user_input||'').trim();
-  const exec=s.i??idx+1;
-  if(msg||!cur){
-   cur={i:groups.length+1,message:msg||'No user message captured',hasMessage:!!msg,start:exec,end:exec,steps:0,cost:0,input:0,output:0,tools:0,peakContext:null};
-   groups.push(cur);
-  }
-  const p=chartParts(s);
-  cur.steps++;
-  cur.end=exec;
-  cur.cost+=p.cost;
-  cur.input+=p.total;
-  cur.output+=p.out;
-  cur.tools+=p.tools;
-  if(p.context!==null&&Number.isFinite(p.context)) cur.peakContext=Math.max(cur.peakContext??0,p.context);
- });
- return groups;
-}
-function drawStepsChart(series){
- const svg=$('iochart'), tip=$('chart-tip'), VW=Math.max(320,Math.round(svg.clientWidth||1040)), VH=Math.max(160,Math.round(svg.clientHeight||244)), MR=16, MT=14, MB=42;
- svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- const groups=requestStepGroups(series);
- if(!groups.length){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">no user requests yet</text>'; if(tip)tip.style.display='none'; return;}
- const n=groups.length, rawMax=Math.max(1,...groups.map(g=>g.steps)), tickVals=integerTicks(rawMax), maxV=tickVals[tickVals.length-1];
- const fmtY=v=>f(v), widestTick=tickVals.reduce((a,v)=>Math.max(a,String(fmtY(v)).length),0);
- const ML=Math.min(98,Math.max(58,widestTick*7+18)), PW=VW-ML-MR, PH=VH-MT-MB;
- const x=i=>ML+(n<=1?PW/2:i/(n-1)*PW);
- const y=v=>MT+PH-(Math.max(0,v)/maxV)*PH;
- const T=`font:${svgTextPx(svg,VW,VH)}px var(--font-mono);fill:${CHART.lbl}`;
- let grid='',ylbl='';
- tickVals.forEach(v=>{ const yy=y(v).toFixed(1); grid+=`<line x1=${ML} y1=${yy} x2=${VW-MR} y2=${yy} stroke="${CHART.grid}" stroke-dasharray="3 4"/>`; ylbl+=`<text x=${ML-8} y=${(+yy+4).toFixed(1)} text-anchor=end style="${T}">${fmtY(v)}</text>`; });
- const axes=`<line x1=${ML} y1=${MT} x2=${ML} y2=${MT+PH} stroke="${CHART.axis}"/><line x1=${ML} y1=${MT+PH} x2=${VW-MR} y2=${MT+PH} stroke="${CHART.axis}"/>`;
- let xlbl=''; [0,n-1,Math.floor((n-1)/2),Math.floor((n-1)/4),Math.floor(3*(n-1)/4)].forEach(i=>{ if(i>=0&&i<n) xlbl+=`<text x=${x(i).toFixed(1)} y=${VH-16} text-anchor=middle style="${T}">#${groups[i].i}</text>`; });
- const bw=Math.max(8,Math.min(34,PW/Math.max(1,n)/1.8));
- const bars=groups.map((g,i)=>{ const yy=y(g.steps), h=MT+PH-yy; return `<rect x="${(x(i)-bw/2).toFixed(1)}" y="${yy.toFixed(1)}" width="${bw.toFixed(1)}" height="${Math.max(1,h).toFixed(1)}" rx="3" fill="${tint('signal',.28)}" stroke="${CHART.tool}" stroke-width="1"/>`; }).join('');
- let d=''; groups.forEach((g,i)=>{ d+=(i?' L':'M')+x(i).toFixed(1)+' '+y(g.steps).toFixed(1); });
- const line=d?`<path d="${d}" fill="none" stroke="${CHART.tool}" stroke-width="2.6" stroke-linejoin="round" stroke-linecap="round"/>`:'';
- const costMax=Math.max(.001,...groups.map(g=>g.cost));
- const costMarks=groups.map((g,i)=>{ const h=4+Math.min(14,(g.cost/costMax)*14); return `<circle cx="${x(i).toFixed(1)}" cy="${(MT+PH+7).toFixed(1)}" r="${h/2}" fill="${CHART.cost}" opacity=".78"/>`; }).join('');
- const titles=`<text x=${(ML+PW/2).toFixed(1)} y=${VH-1} text-anchor=middle style="${T}">user request</text><text x=14 y=${(MT+PH/2).toFixed(1)} text-anchor=middle transform="rotate(-90 14 ${(MT+PH/2).toFixed(1)})" style="${T}">steps</text>`;
- const hover=`<rect id=ch-hit x=${ML} y=${MT} width=${PW} height=${PH} fill="transparent" pointer-events="all"/><g id=chart-hover opacity=0 style="pointer-events:none"><line id=ch-x y1=${MT} y2=${MT+PH} stroke="${CHART.tipLine}" stroke-dasharray="4 4"/><circle id=ch-a r=4.8 fill="${CHART.tool}" stroke="${CHART.ink}" stroke-width=2/></g>`;
- svg.innerHTML=grid+axes+ylbl+xlbl+bars+line+costMarks+titles+hover;
- const hoverGroup=svg.querySelector('#chart-hover'), hit=svg.querySelector('#ch-hit');
- const setAttr=(id,attrs)=>{const el=svg.querySelector(id); Object.entries(attrs).forEach(([k,v])=>el.setAttribute(k,v));};
- function hoverAt(clientX,clientY){
-  const pt=svg.createSVGPoint(); pt.x=clientX; pt.y=clientY;
-  const curPt=pt.matrixTransform(svg.getScreenCTM().inverse());
-  const idx=Math.max(0,Math.min(n-1,Math.round((curPt.x-ML)/PW*(n-1))));
-  const g=groups[idx], xx=x(idx), yy=y(g.steps);
-  hoverGroup.setAttribute('opacity','1');
-  setAttr('#ch-x',{x1:xx.toFixed(1),x2:xx.toFixed(1)});
-  setAttr('#ch-a',{cx:xx.toFixed(1),cy:yy.toFixed(1),opacity:1});
-  if(tip){
-   const sx=svg.clientWidth/VW, sy=svg.clientHeight/VH, w=360, h=244;
-   const left=Math.min(Math.max(xx*sx+14,8),Math.max(8,svg.clientWidth-w-8));
-   const top=Math.min(Math.max(yy*sy-108,8),Math.max(8,svg.clientHeight-h-8));
-   tip.style.display='block'; tip.style.left=left+'px'; tip.style.top=top+'px';
-   const row=(cls,name,val)=>`<div class="r ${cls}"><span>${name}</span><b>${val}</b></div>`;
-   const execRange=g.start===g.end?`#${g.start}`:`#${g.start}-${g.end}`;
-   const messageBlock=g.hasMessage?`<div class=prompt><span>user message</span><b>${esc(g.message)}</b></div>`:'';
-   const est=CURRENT?.provider==='cursor'?' est':'';
-   tip.innerHTML=`<div class=h>request #${g.i}</div>${row('tools','steps',f(g.steps))}${row('in','executions',execRange)}${row('cost','cost',metricAvailable(CURRENT,'cost')?money(g.cost)+est:'--')}${row('in',est?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(g.input)+est:'--')}${row('out',est?'visible output':'output',metricAvailable(CURRENT,'output_tokens')?f(g.output)+est:'--')}${row('tools','tool calls',f(g.tools))}${row('context','peak context',g.peakContext===null?'--':pct(g.peakContext))}${messageBlock}`;
-  }
- }
- hit.addEventListener('mousemove',e=>hoverAt(e.clientX,e.clientY));
- hit.addEventListener('mouseleave',()=>{hoverGroup.setAttribute('opacity','0'); if(tip)tip.style.display='none';});
- hit.addEventListener('touchmove',e=>{ if(e.touches[0]) hoverAt(e.touches[0].clientX,e.touches[0].clientY); },{passive:true});
-}
-function drawWaitChart(samples,series){
- const svg=$('iochart'),tip=$('chart-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||244)),MR=16,MT=14,MB=42;
- svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- samples=samples||[];
- if(!samples.length){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">no completed wait timing yet</text>';if(tip)tip.style.display='none';return;}
- const groups=requestStepGroups(series||[]),n=samples.length,rawMax=Math.max(1,...samples.map(row=>Number(row.duration_s||0))),tickVals=ticks(rawMax),maxV=rawMax;
- const fmtY=value=>waitFmt(value),widestTick=tickVals.reduce((width,value)=>Math.max(width,fmtY(value).length),0);
- const ML=Math.min(110,Math.max(62,widestTick*7+18)),PW=VW-ML-MR,PH=VH-MT-MB;
- const x=index=>ML+(n<=1?PW/2:index/(n-1)*PW),y=value=>MT+PH-PH*(Math.max(0,Number(value||0))/maxV);
- const T=`font:${svgTextPx(svg,VW,VH)}px var(--font-mono);fill:${CHART.lbl}`;
- let grid='',labels='';
- tickVals.forEach(value=>{const yy=y(value).toFixed(1);grid+=`<line x1=${ML} y1=${yy} x2=${VW-MR} y2=${yy} stroke="${CHART.grid}" stroke-dasharray="3 4"/>`;labels+=`<text x=${ML-8} y=${(+yy+4).toFixed(1)} text-anchor=end style="${T}">${fmtY(value)}</text>`;});
- const axes=`<line x1=${ML} y1=${MT} x2=${ML} y2=${MT+PH} stroke="${CHART.axis}"/><line x1=${ML} y1=${MT+PH} x2=${VW-MR} y2=${MT+PH} stroke="${CHART.axis}"/>`;
- const barWidth=Math.max(8,Math.min(34,PW/Math.max(1,n)/1.8));
- const bars=samples.map((row,index)=>{const yy=y(row.duration_s),height=MT+PH-yy;return `<rect x="${(x(index)-barWidth/2).toFixed(1)}" y="${yy.toFixed(1)}" width="${barWidth.toFixed(1)}" height="${Math.max(1,height).toFixed(1)}" rx="3" fill="${tint('signal',.28)}" stroke="${CHART.context}" stroke-width="1.2"/>`;}).join('');
- const line=samples.length>1?`<path d="${samples.map((row,index)=>`${index?'L':'M'}${x(index).toFixed(1)},${y(row.duration_s).toFixed(1)}`).join(' ')}" fill="none" stroke="${CHART.context}" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>`:'';
- const every=Math.max(1,Math.ceil(n/8));
- let xlabels='';samples.forEach((row,index)=>{if(index===n-1||index%every===0)xlabels+=`<text x=${x(index).toFixed(1)} y=${VH-16} text-anchor=middle style="${T}">#${index+1}</text>`;});
- const titles=`<text x=${(ML+PW/2).toFixed(1)} y=${VH-1} text-anchor=middle style="${T}">user request</text><text x=14 y=${(MT+PH/2).toFixed(1)} text-anchor=middle transform="rotate(-90 14 ${(MT+PH/2).toFixed(1)})" style="${T}">wait time</text>`;
- const hover=`<rect id=ch-hit x=${ML} y=${MT} width=${PW} height=${PH} fill="transparent" pointer-events="all"/><g id=chart-hover opacity=0 style="pointer-events:none"><line id=ch-x y1=${MT} y2=${MT+PH} stroke="${CHART.tipLine}" stroke-dasharray="4 4"/><circle id=ch-a r=4.8 fill="${CHART.context}" stroke="${CHART.ink}" stroke-width=2/></g>`;
- svg.innerHTML=grid+axes+labels+xlabels+bars+line+titles+hover;
- const hoverGroup=svg.querySelector('#chart-hover'),hit=svg.querySelector('#ch-hit'),cross=svg.querySelector('#ch-x'),dot=svg.querySelector('#ch-a');
- function hoverAt(clientX,clientY){
-  const point=svg.createSVGPoint();point.x=clientX;point.y=clientY;
-  const local=point.matrixTransform(svg.getScreenCTM().inverse()),index=Math.max(0,Math.min(n-1,Math.round((local.x-ML)/PW*(n-1))));
-  const row=samples[index],xx=x(index),yy=y(row.duration_s),group=groups[index];
-  hoverGroup.setAttribute('opacity','1');cross.setAttribute('x1',xx);cross.setAttribute('x2',xx);dot.setAttribute('cx',xx);dot.setAttribute('cy',yy);
-  if(tip){const rect=svg.parentElement.getBoundingClientRect(),message=group?.hasMessage?`<div class=prompt><span>user message</span><b>${esc(group.message)}</b></div>`:'',cursor=CURRENT?.provider==='cursor';tip.innerHTML=`<div class=h>request #${index+1}</div><div class="r context"><span>wait time</span><b>${waitFmt(row.duration_s)}</b></div><div class=r><span>model</span><b>${esc(row.model||'unknown')}</b></div><div class="r tools"><span>tool calls</span><b>${f(row.tool_calls)}</b></div><div class="r out"><span>${cursor?'visible output est':'output'}</span><b>${metricAvailable(CURRENT,'output_tokens')?f(row.output_tokens)+' tok'+(cursor?' est':''):'--'}</b></div><div class=r><span>timing</span><b>${esc(row.timing_basis||'observed')}</b></div>${message}`;tip.style.display='block';tip.style.left=Math.min(rect.width-tip.offsetWidth-8,Math.max(8,clientX-rect.left+12))+'px';tip.style.top=Math.max(8,clientY-rect.top-tip.offsetHeight-10)+'px';}
- }
- hit.addEventListener('mousemove',event=>hoverAt(event.clientX,event.clientY));
- hit.addEventListener('mouseleave',()=>{hoverGroup.setAttribute('opacity','0');if(tip)tip.style.display='none';});
- hit.addEventListener('touchmove',event=>{if(event.touches[0])hoverAt(event.touches[0].clientX,event.touches[0].clientY);},{passive:true});
-}
-function drawIO(series){
- const svg=$('iochart'), VW=Math.max(320,Math.round(svg.clientWidth||1040)), VH=Math.max(160,Math.round(svg.clientHeight||244)), MR=16, MT=14, MB=42;
- svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- const tip=$('chart-tip');
- const mode=CHART_MODES.includes(chartMode)?chartMode:'context';
- const cumulativeTokens=mode==='tokens'&&chartScale==='cumulative';
- const cumulativeCost=mode==='cost'&&chartScale==='cumulative';
- const cumulativeValues=cumulativeTokens||cumulativeCost;
- const legend=$('chart-legend'); if(legend) legend.innerHTML=chartLegendHtml(mode,cumulativeValues);
- const profileHint=$('exec-profile-hint'), activity=CURRENT?.tools?.activity||{};
- const executionCoverage=CURRENT?.execution_coverage||{},hermesAggregate=executionCoverage.basis==='session_aggregate';
- if(profileHint) profileHint.textContent=hermesAggregate
-  ? `${f(executionCoverage.recorded_executions||0)} recorded executions · one Hermes session aggregate · per-execution token breakdown unavailable`
-  : mode==='tools'
-  ? `${f(activity.total_calls)} total calls · ${f(activity.observed_unique)} observed types · peak ${f(activity.peak_calls_per_execution)}/execution`
-  : mode==='wait'
-   ? `${f(CURRENT?.wait_time?.sample_count||0)} completed timed ${countWord(CURRENT?.wait_time?.sample_count||0,'request')} · lower is better`
-   : cumulativeCost
-    ? 'running estimated cost through each execution'
-   : cumulativeTokens
-    ? 'running token totals through each execution'
-   : 'per execution or request';
- if(mode==='wait'){drawWaitChart(CURRENT?.wait_time?.samples||[],series);return;}
- const n=series.length; if(!n){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">no executions yet</text>'; if(tip)tip.style.display='none'; return;}
- if(mode==='steps'){ drawStepsChart(series); return; }
- if((mode==='tokens'&&!metricAvailable(CURRENT,'tokens'))||(mode==='cost'&&!metricAvailable(CURRENT,'cost'))){svg.innerHTML='<text x='+Math.round(VW/2)+' y='+Math.round(VH/2)+' text-anchor=middle fill="'+CHART.lbl+'">'+(mode==='cost'?'cost estimate':'token evidence')+' unavailable in this trace</text>';if(tip)tip.style.display='none';return;}
- const rawParts=series.map(chartParts), parts=cumulativeValues?cumulativeChartParts(rawParts,mode):rawParts;
- const maxCache=Math.max(10,...parts.map(p=>Math.max(p.total,p.cache,p.fresh,p.out)));
- const maxCost=Math.max(.001,...parts.map(p=>p.cost));
- const maxTools=Math.max(1,...parts.map(p=>p.tools));
- const rawMaxV=mode==='cost'?maxCost:(mode==='context'?1:(mode==='tools'?maxTools:maxCache));
- const tickVals=mode==='tools'?integerTicks(rawMaxV):ticks(rawMaxV);
- const maxV=mode==='tools'?tickVals[tickVals.length-1]:rawMaxV;
- const fmtY=v=>mode==='cost'?moneyTick(v):(mode==='context'?pct(v):f(v));
- const widestTick=tickVals.reduce((a,v)=>Math.max(a,String(fmtY(v)).length),0);
- const ML=Math.min(98,Math.max(58,widestTick*7+18)), PW=VW-ML-MR, PH=VH-MT-MB;
- const x=i=>ML+(n<=1?PW/2:i/(n-1)*PW);
- const y=v=>MT+PH-scaledY(v,maxV)*PH;
- const T=`font:${svgTextPx(svg,VW,VH)}px var(--font-mono);fill:${CHART.lbl}`;
- let grid='',ylbl='';
- tickVals.forEach(v=>{ const yy=y(v).toFixed(1); grid+=`<line x1=${ML} y1=${yy} x2=${VW-MR} y2=${yy} stroke="${CHART.grid}" stroke-dasharray="3 4"/>`; ylbl+=`<text x=${ML-8} y=${(+yy+4).toFixed(1)} text-anchor=end style="${T}">${fmtY(v)}</text>`; });
- const axes=`<line x1=${ML} y1=${MT} x2=${ML} y2=${MT+PH} stroke="${CHART.axis}"/><line x1=${ML} y1=${MT+PH} x2=${VW-MR} y2=${MT+PH} stroke="${CHART.axis}"/>`;
- const xTickIndexes=[...new Set([0,n-1,Math.floor((n-1)/2),Math.floor((n-1)/4),Math.floor(3*(n-1)/4)])];
- let xlbl=''; xTickIndexes.forEach(i=>{ if(i>=0&&i<n) xlbl+=`<text x=${x(i).toFixed(1)} y=${VH-16} text-anchor=middle style="${T}">${series[i].i}</text>`; });
- const lineVals=(vals,col,w=2.4,dash='')=>{
-  let d='',open=false;
-  const validPoints=[];
-  vals.forEach((v,i)=>{ if(v===null||v===undefined||Number.isNaN(v)){open=false;return;} validPoints.push([i,v]); d+=(open?' L':'M')+x(i).toFixed(1)+' '+y(v).toFixed(1); open=true; });
-  const line=d?`<path d="${d}" fill="none" stroke="${col}" stroke-width="${w}" stroke-linejoin="round" stroke-linecap="round"${dash?` stroke-dasharray="${dash}"`:''}/>`:'';
-  const singlePoint=validPoints.length===1?`<circle cx="${x(validPoints[0][0]).toFixed(1)}" cy="${y(validPoints[0][1]).toFixed(1)}" r="3.8" fill="${col}" stroke="${CHART.ink}" stroke-width="1.6"/>`:'';
-  return line+singlePoint;
- };
- const band=(top,bottom,col,opacity)=>{
-  let d='';
-  top.forEach((v,i)=>{ d+=(i?' L':'M')+x(i).toFixed(1)+' '+y(v||0).toFixed(1); });
-  for(let i=bottom.length-1;i>=0;i--) d+=' L'+x(i).toFixed(1)+' '+y(bottom[i]||0).toFixed(1);
-  return `<path d="${d} Z" fill="${col}" fill-opacity="${opacity}"/>`;
- };
- const bars=(vals,col)=>{
-  const bw=Math.max(2,Math.min(22,PW/Math.max(1,n)/1.85));
-  return vals.map((v,i)=>{ const yy=y(v||0), h=MT+PH-yy; return `<rect x="${(x(i)-bw/2).toFixed(1)}" y="${yy.toFixed(1)}" width="${bw.toFixed(1)}" height="${Math.max(1,h).toFixed(1)}" rx="2" fill="${col}"/>`; }).join('');
- };
- const zeros=parts.map(()=>0), fresh=parts.map(p=>p.fresh), inputTotals=parts.map(p=>p.total);
- const cacheRead=parts.map(p=>p.read), cacheTop=parts.map(p=>p.cache), output=parts.map(p=>p.out), costs=parts.map(p=>p.cost), contexts=parts.map(p=>p.context), toolCalls=parts.map(p=>p.tools);
- const nonZeroSorted=(vals)=>vals.filter(v=>v>0).sort((a,b)=>a-b);
- const percentile=(vals,q,fallback=0)=>{ vals=nonZeroSorted(vals); return vals.length?vals[Math.min(vals.length-1,Math.floor((vals.length-1)*q))]:fallback; };
- const toolCut=Math.max(3,percentile(rawParts.map(p=>p.tools),.85,0));
- const reasonCut=Math.max(1000,percentile(rawParts.map(p=>p.reason),.85,0));
- const primaryFor=p=>{
-  if(mode==='tokens') return {value:p.total,color:CHART.input};
-  if(mode==='cost') return {value:p.cost,color:CHART.cost};
-  if(mode==='context') return {value:p.context,color:CHART.context};
-  if(mode==='tools') return {value:p.tools,color:CHART.tool};
-  return {value:p.total,color:CHART.input};
- };
- let plot='';
- if(mode==='context'){
-  plot+=`<rect x="${ML}" y="${y(1).toFixed(1)}" width="${PW}" height="${(y(.85)-y(1)).toFixed(1)}" fill="${tint('red',.08)}"/><rect x="${ML}" y="${y(.85).toFixed(1)}" width="${PW}" height="${(y(.7)-y(.85)).toFixed(1)}" fill="${tint('orange',.07)}"/>`;
-  plot+=`<line x1="${ML}" y1="${y(.85).toFixed(1)}" x2="${VW-MR}" y2="${y(.85).toFixed(1)}" stroke="${CHART.cost}" stroke-dasharray="5 5" opacity=".75"/><line x1="${ML}" y1="${y(.7).toFixed(1)}" x2="${VW-MR}" y2="${y(.7).toFixed(1)}" stroke="${CHART.cacheWrite}" stroke-dasharray="5 5" opacity=".75"/>`;
-  plot+=contexts.some(v=>v!==null)?lineVals(contexts,CHART.context,2.7):`<text x=${Math.round(VW/2)} y=${Math.round(VH/2)} text-anchor=middle fill="${CHART.lbl}">context data unavailable</text>`;
- }else if(mode==='tokens'){
-  plot+=band(cacheRead,zeros,CHART.cacheRead,.18)+band(cacheTop,cacheRead,CHART.cacheWrite,.18);
-  plot+=lineVals(inputTotals,CHART.input,2.7)+lineVals(output,CHART.output,2.1)+lineVals(cacheTop,CHART.cacheRead,1.7,'4 4')+lineVals(fresh,CHART.input,1.5,'5 4');
- }else if(mode==='tools'){
-  plot+=bars(toolCalls,tint('signal',.24))+lineVals(toolCalls,CHART.tool,2.6);
- }else{
-  plot+=bars(costs,CHART.costFill)+lineVals(costs,CHART.cost,2.4);
- }
- let marks='';
- series.forEach((s,i)=>{
-  const p=parts[i], xx=x(i), y0=MT+PH+6;
-  if(p.tools>=toolCut) marks+=`<line x1="${(xx-3).toFixed(1)}" y1="${(y0-7).toFixed(1)}" x2="${(xx-3).toFixed(1)}" y2="${y0.toFixed(1)}" stroke="${CHART.tool}" stroke-width="2.2" stroke-linecap="round" opacity=".75"/>`;
-  if(p.reason>=reasonCut) marks+=`<line x1="${(xx+3).toFixed(1)}" y1="${(y0-7).toFixed(1)}" x2="${(xx+3).toFixed(1)}" y2="${y0.toFixed(1)}" stroke="${CHART.reason}" stroke-width="2.2" stroke-linecap="round" opacity=".75"/>`;
-  if(s.side) marks+=`<circle cx="${xx.toFixed(1)}" cy="${(y0-3).toFixed(1)}" r="3" fill="${CHART.side}" opacity=".85"/>`;
-  if(s.user_message||s.user_input){
-   const u=primaryFor(p);
-   if(u.value!==null&&u.value!==undefined&&!Number.isNaN(u.value)){
-    const yy=y(u.value);
-    marks+=`<path d="M ${xx.toFixed(1)} ${(yy-5).toFixed(1)} L ${(xx+5).toFixed(1)} ${yy.toFixed(1)} L ${xx.toFixed(1)} ${(yy+5).toFixed(1)} L ${(xx-5).toFixed(1)} ${yy.toFixed(1)} Z" fill="${CHART.tip}" stroke="${u.color}" stroke-width="2" opacity=".96"/>`;
-   }
-  }
- });
- const yTitle=mode==='cost'?(cumulativeCost?'cumulative usd':'usd'):(mode==='context'?'context':(mode==='tools'?'tool calls':(cumulativeTokens?'cumulative tokens':'tokens')));
- const titles=`<text x=${(ML+PW/2).toFixed(1)} y=${VH-1} text-anchor=middle style="${T}">execution</text><text x=14 y=${(MT+PH/2).toFixed(1)} text-anchor=middle transform="rotate(-90 14 ${(MT+PH/2).toFixed(1)})" style="${T}">${yTitle}</text>`;
- const hover=`<rect id=ch-hit x=${ML} y=${MT} width=${PW} height=${PH} fill="transparent" pointer-events="all"/><g id=chart-hover opacity=0 style="pointer-events:none">
-  <line id=ch-x y1=${MT} y2=${MT+PH} stroke="${CHART.tipLine}" stroke-dasharray="4 4"/>
-  <circle id=ch-a r=4.8 fill="${CHART.input}" stroke="${CHART.ink}" stroke-width=2/>
-  <circle id=ch-b r=4.4 fill="${CHART.output}" stroke="${CHART.ink}" stroke-width=2/>
- </g>`;
- svg.innerHTML=grid+axes+ylbl+xlbl+plot+marks+titles+hover;
- const hoverGroup=svg.querySelector('#chart-hover'), hit=svg.querySelector('#ch-hit');
- const setAttr=(id,attrs)=>{const el=svg.querySelector(id); Object.entries(attrs).forEach(([k,v])=>el.setAttribute(k,v));};
- function hoverAt(clientX,clientY){
-  const pt=svg.createSVGPoint(); pt.x=clientX; pt.y=clientY;
-  const cur=pt.matrixTransform(svg.getScreenCTM().inverse());
-  const idx=Math.max(0,Math.min(n-1,Math.round((cur.x-ML)/PW*(n-1))));
-  const s=series[idx], p=parts[idx], xx=x(idx);
-  const primaryInfo=primaryFor(p);
-  let primary=primaryInfo.value, primaryColor=primaryInfo.color, secondary=p.out, secondaryColor=CHART.output;
-  if(mode!=='tokens') secondary=null;
-  const yPrimary=primary===null||primary===undefined?MT+PH:y(primary), ySecondary=secondary===null||secondary===undefined?null:y(secondary);
-  hoverGroup.setAttribute('opacity','1');
-  setAttr('#ch-x',{x1:xx.toFixed(1),x2:xx.toFixed(1)});
-  setAttr('#ch-a',{cx:xx.toFixed(1),cy:yPrimary.toFixed(1),fill:primaryColor,opacity:primary===null||primary===undefined?0:1});
-  setAttr('#ch-b',{cx:xx.toFixed(1),cy:(ySecondary??yPrimary).toFixed(1),fill:secondaryColor,opacity:ySecondary===null?0:1});
-  if(tip){
-   const sx=svg.clientWidth/VW, sy=svg.clientHeight/VH, w=360, h=272;
-   const left=Math.min(Math.max(xx*sx+14,8),Math.max(8,svg.clientWidth-w-8));
-   const top=Math.min(Math.max(Math.min(yPrimary,ySecondary??yPrimary)*sy-112,8),Math.max(8,svg.clientHeight-h-8));
-   tip.style.display='block';
-   tip.style.left=left+'px';
-   tip.style.top=top+'px';
-   const row=(cls,name,val)=>`<div class="r ${cls}"><span>${name}</span><b>${val}</b></div>`;
-   const userMessage=s.user_message||s.user_input||'';
-   const markers=[userMessage?'user message':null,p.tools?`${f(p.tools)} tool calls`:null,p.reason?`${f(p.reason)} reasoning`:null,s.side?'coordination':null].filter(Boolean).join(' / ');
-   const prompt=userMessage?esc(userMessage):'--';
-   const promptBlock=userMessage?`<div class=prompt><span>user message</span><b>${prompt}</b></div>`:'';
-   const cursor=CURRENT?.provider==='cursor',est=cursor?' est':'';
-   const costLabel=cumulativeCost?'cumulative cost':'cost';
-   const common=[
-    row('context','context',p.context===null?'--':pct(p.context)),
-    row('cost',costLabel,metricAvailable(CURRENT,'cost')?money(p.cost)+est:'--'),
-   ];
-   const tokenPrefix=cumulativeTokens?'cumulative ':'';
-   const tokenRows=[
-    row('in',tokenPrefix+(cursor?'input context':'input total'),metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),
-    row('out',tokenPrefix+(cursor?'visible output':'output'),metricAvailable(CURRENT,'output_tokens')?f(p.out)+est:'--'),
-    row('fresh',tokenPrefix+'uncached input',metricAvailable(CURRENT,'cache')?f(p.fresh):'--'),
-    row('cacheRead',tokenPrefix+'cache read',metricAvailable(CURRENT,'cache')?f(p.read):'--'),
-    row('cacheWrite',tokenPrefix+'cache write',metricAvailable(CURRENT,'cache')?f(p.write):'--'),
-   ];
-   const toolRows=[
-    row('tools','tool calls',f(p.tools)),
-    row('in',cursor?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),
-    row('out',cursor?'visible output':'output',metricAvailable(CURRENT,'output_tokens')?f(p.out)+est:'--'),
-   ];
-   const rows=mode==='tools'?[...toolRows,...common]:mode==='tokens'?[...tokenRows,row('tools','tool calls',f(p.tools)),...common]:mode==='context'?[row('context','context',p.context===null?'--':pct(p.context)),row('in',cursor?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),row('tools','tool calls',f(p.tools)),row('cost','cost',metricAvailable(CURRENT,'cost')?money(p.cost)+est:'--')]:[row('cost',costLabel,metricAvailable(CURRENT,'cost')?money(p.cost)+est:'--'),row('in',cursor?'input context':'input total',metricAvailable(CURRENT,'input_tokens')?f(p.total)+est:'--'),row('out',cursor?'visible output':'output',metricAvailable(CURRENT,'output_tokens')?f(p.out)+est:'--'),row('tools','tool calls',f(p.tools))];
-   const heading=s.aggregate?`session aggregate · ${f(CURRENT?.execution_coverage?.recorded_executions||0)} executions`:`execution #${esc(s.i??idx+1)}`;
-   tip.innerHTML=`<div class=h>${heading}</div>${rows.join('')}${markers?`<div class=r><span>markers</span><b>${esc(markers)}</b></div>`:''}${promptBlock}`;
-  }
- }
- hit.addEventListener('mousemove',e=>hoverAt(e.clientX,e.clientY));
- hit.addEventListener('mouseleave',()=>{hoverGroup.setAttribute('opacity','0'); if(tip)tip.style.display='none';});
- hit.addEventListener('touchmove',e=>{ if(e.touches[0]) hoverAt(e.touches[0].clientX,e.touches[0].clientY); },{passive:true});
-}
-
-function renderOverview(s){
- const ex=s.executions||[], avg=s.turns?s.total_cost/s.turns:0, peak=Math.max(0,...(s.series||[]).map(x=>x.in||0)),costAvailable=metricAvailable(s,'cost'),estimate=s.provider==='cursor'?' est':'';
- const timing=s.timing||{}, wait=s.wait_time||{}, context=s.context||{}, tools=s.tools||{};
- $('exec-hint').textContent=(s.source?.label||s.provider||'')+' · '+(s.primary_model||'');
- $('cost-start').textContent=dt12(timing.start_local)||'--';
- $('cost-end-label').textContent=timing.end_label||'Last activity';
- $('cost-end').textContent=dt12(timing.end_local)||'--';
- $('ov-duration').textContent=wait.available?waitFmt(wait.total_s):'--';
- $('ov-idle').textContent=wait.available?`${waitFmt(wait.avg_s)} avg · ${f(wait.sample_count)} completed ${countWord(wait.sample_count,'request')}`:'completed wait timing unavailable';
- $('ov-context').textContent=f(context.latest||0);
- $('ov-contextsm').textContent=context.window?`${pct(context.latest_pct)} of ${f(context.window)} window${s.provider==='cursor'?' · context snapshot':''}`:'latest input tokens';
- $('ov-loaded-label').textContent=tools.loaded_known?'Catalog advertised':'Tool types observed';
- $('ov-loaded').textContent=f(tools.loaded||0);
- $('ov-loadedsm').textContent=tools.loaded_known?`${f(tools.eager||0)} eager · ${f(tools.deferred||0)} deferred · partial catalog`:`${f(tools.unique_used||0)} observed · catalog unavailable`;
- $('ov-exec').textContent=f(s.turns); $('ov-model').textContent=s.primary_model||'';
- for(const [key,id] of [['skills','ov-skills'],['mcp_servers','ov-mcp']]){
-  const counts=capabilityCounts(s.capabilities,key);
-  $(id).textContent=capabilityRatio(counts);
-  $(id+'sm').textContent=counts.loaded==null?'loaded list not recorded':`${f(counts.used)} used of ${f(counts.loaded)} ${counts.basis==='configured'?'configured now':'loaded'}`;
- }
- setCostValue('ov-avg',money(avg)+estimate,costAvailable);
- $('ov-tools').textContent=f(tools.total_calls||0); $('ov-tooltok').textContent=f(tools.total_output_tokens||0)+' returned tok';
- $('ov-peak').textContent=f(peak);
- $('ov-peak').textContent=f(context.peak||peak);
- $('ov-peak').nextElementSibling.textContent=context.window?`${pct(context.peak_pct)} of model window`:'max input tokens';
- setCostValue('ov-big',money(s.biggest_turn?.cost||0)+estimate,costAvailable); $('ov-bigsm').textContent=costAvailable?(s.biggest_turn?'execution #'+s.biggest_turn.idx+(estimate?' · local estimate':''):''):'billing unavailable';
-}
-function setCapabilityStatBar(id,value){
- const bar=$(id);
- if(!bar)return;
- const normalized=Math.min(1,Math.max(0,Number(value)||0)),label=pct(normalized),fill=bar.querySelector('i');
- if(fill)fill.style.width=`${normalized*100}%`;
- bar.setAttribute('aria-valuenow',String(Math.round(normalized*100)));
- bar.setAttribute('aria-valuetext',label);
-}
-function renderCurrentOptimization(s){
- const tools=s.tools||{}, activity=tools.activity||{}, optional=s.optional_capabilities||{};
- const observed=activity.observed_unique??tools.unique_used??0, calls=activity.total_calls??tools.total_calls??0;
- const peak=activity.peak_calls_per_execution??tools.peak_calls_per_execution??0;
- $('ov-activity-tools').textContent=f(observed);
- $('ov-activity-note').textContent=`observed types · ${f(calls)} calls · peak ${f(peak)}/execution`;
- const enabled=optional.enabled||0, used=optional.used||0;
- $('ov-optional-use').textContent=`${f(used)}/${f(enabled)}`;
- setCapabilityStatBar('ov-optional-bar',enabled?used/enabled:0);
- $('ov-optional-note').textContent=enabled
-  ? `skill packs ${f(optional.skill_packs_used)}/${f(optional.skill_packs_enabled)} · MCPs are read-only`
-  : 'no removable groups enabled for this runtime';
- $('ov-unused-packs').textContent=f(optional.unused||0);
- $('ov-unused-packs-note').textContent=optional.unused
-  ? 'enabled packs with no activation in this run'
-  : 'no unused user-installed packs in this run';
-}
-function sessionAlert(s){
- const source=s.source||{},capSpend=sessionCapSpend(s);
- if(!capSpend.available)return {type:'',msg:'',key:''};
- if(s.provider==='cursor')return {type:'',msg:'',key:''};
- const budget=dollarInputValue('budget',10);
- if(capSpend.spend>budget) return {type:'budget',msg:`This session passed your ${money(budget)} cap - now ${capSpend.partial?'at least ':''}${money(capSpend.spend)}`,key:`${source.id||s.session}:budget:${budget}`,budget,current:capSpend.spend};
- return {type:'',msg:'',key:''};
-}
-function notifyAlertForSession(s,opts={}){
- if(!s||pinned) return false;
- const a=sessionAlert(s);
- if(!a.msg) return false;
- const key=opts.forceCurrent?a.key+':current:'+Date.now():a.key;
- return fireNotification('Token Meter session budget',a.msg,key,{requireInteraction:true,renotify:!!opts.forceCurrent,dedupe:!opts.forceCurrent});
-}
-function renderAlertBanner(alert){
- const banner=$('banner');
- banner.classList.toggle('on',!!alert.msg);
- banner.classList.toggle('budget',alert.type==='budget');
- $('banner-msg').textContent=alert.msg||'';
- if(alert.type==='budget'){
-  $('budget-add-btn').textContent='Add budget';
-  $('budget-add').setAttribute('aria-label','Budget to add beyond current spend');
- }
-}
-
-function sessionStartMessage(s){
- for(const row of (s?.series||[])){
-  const message=String(row?.user_message||row?.user_input||'').trim();
-  if(message)return message;
- }
- const event=(s?.trace||[]).find(row=>row?.kind==='user'||row?.label==='User message');
- return String(event?.detail||'').trim();
-}
-
-function sessionDisplayName(s){
- const id=stateSessionId(s),key=stateSessionKey(s),rows=[...(s?.xsession?.current_sessions||[]),...(s?.xsession?.sessions||[]),...(allSessionInventory||[])];
- // Resumed rollouts and subagents share a logical id; only the same trace file may name the header.
- const row=rows.find(item=>item?.session&&String(item.session)===key)||rows.find(item=>!item?.session&&String(item?.id||'')===String(id||''));
- const name=String(row?.session_name||row?.title||'').trim();
- if(name)return name;
- const start=sessionStartMessage(s);
- return start&&start.length<=88?start:'Session';
-}
-
-function sessionDisplayThroughput(session){
- const completed=session?.throughput||{},live=session?.live_throughput||{};
- return live.available?live:completed;
-}
-function sessionThroughputNote(throughput){
- if(throughput?.basis==='live_end_to_end'){
-  const steps=Number(throughput.completed_steps)||0;
-  return `live checkpoints · ${f(steps)} completed ${countWord(steps,'step')}`;
- }
- return `${throughput?.basis==='tool_free'?'tool-free':'end-to-end'} · ${f(throughput?.sample_count||0)} timed ${countWord(throughput?.sample_count||0,'sample')} · ${pct(throughput?.timing_coverage)} coverage`;
-}
-
-const agentCostObservations=new Map();
-let selectedAgentActivityId='';
-function deriveAgentAttention(group,budget,previousCosts=new Map()){
- const reasonsByAgent=new Map();
- const addReason=(agentId,reason)=>{
-  if(!agentId||!reason?.code)return;
-  const reasons=reasonsByAgent.get(agentId)||[];
-  if(!reasons.some(item=>item.code===reason.code))reasons.push({code:String(reason.code),explanation:String(reason.explanation||'')});
-  reasonsByAgent.set(agentId,reasons);
- };
- for(const item of group?.attention||[]){
-  for(const reason of item?.reasons||[])addReason(item?.agent_id,reason);
- }
- const covered=group?.totals?.cost_available===true&&Number.isFinite(Number(group?.totals?.cost));
- if(covered){
-  const cap=Number(budget),rootId=String(group?.root_session_id||'');
-  if(Number.isFinite(cap)&&cap>0&&Number(group.totals.cost)>cap){
-   const root=(group?.agents||[]).find(agent=>agent?.kind==='root');
-   if(root)addReason(root.id,{code:'cap_exceeded',explanation:`Covered estimated group spend is above this session's browser-local ${money(cap)} cap.`});
-  }
-  for(const agent of group?.agents||[]){
-   if(agent?.kind==='root'||agent?.cost_available!==true||!Number.isFinite(Number(agent?.cost)))continue;
-   const cost=Number(agent.cost);
-   if(Number.isFinite(cap)&&cap>0&&cost>cap)addReason(agent.id,{code:'cap_exceeded',explanation:`Covered estimated child-agent spend is above this session's browser-local ${money(cap)} cap.`});
-   if(agent.activity_state==='working'){
-    const key=`${rootId}:${agent.id}`,previous=Number(previousCosts.get(key));
-    if(Number.isFinite(previous)&&cost>previous&&cost-previous>=.25)addReason(agent.id,{code:'observed_live_growth',explanation:'Covered estimated cost increased by at least $0.25 while this child was reported working.'});
-    previousCosts.set(key,cost);
-   }
-  }
- }
- return (group?.agents||[]).filter(agent=>reasonsByAgent.has(agent?.id)).map(agent=>({
-  agent_id:agent.id,level:'needs_attention',reasons:reasonsByAgent.get(agent.id),
- }));
-}
-function agentIdentityPresentation(agent,index){
- if(agent?.kind==='root')return {primary:'Main session',secondary:''};
- const role=String(agent?.role||'').trim(),label=String(agent?.label||'').trim();
- if(role)return {primary:role,secondary:label&&label!==role?label:''};
- return {primary:label||`Agent ${index+1}`,secondary:''};
-}
-function agentDisplayLabel(agent,index){
- return agentIdentityPresentation(agent,index).primary;
-}
-function subagentCostHeat(cost,maxCost,available){
- const value=Number(cost),maximum=Number(maxCost);
- if(available!==true||!Number.isFinite(value)||value<0||!Number.isFinite(maximum)||maximum<=0)return '';
- const intensity=Math.max(0,Math.min(1,value/maximum));
- return `--cost-heat:hsl(${Math.round(190-160*intensity)} 88% 69%);--cost-fill:${Math.round(100*intensity)}%`;
-}
-function renderAgentActivity(s){
- const module=$('agent-activity'),group=s?.agent_group,agents=Array.isArray(group?.agents)?group.agents:[];
- if(!group||agents.length<2){
-  module.hidden=true;
-  selectedAgentActivityId='';
-  return;
- }
- module.hidden=false;
- const attention=deriveAgentAttention(group,sessionBudgetForSession(s),agentCostObservations),attentionByAgent=new Map(attention.map(item=>[String(item.agent_id),item]));
- if(!agents.some(agent=>String(agent.id)===String(selectedAgentActivityId)))selectedAgentActivityId=group.selected_agent_id||agents[0].id;
- const selected=agents.find(agent=>String(agent.id)===String(selectedAgentActivityId))||agents[0];
- selectedAgentActivityId=selected.id;
- const selectedIndex=Math.max(0,agents.indexOf(selected)),selectedLabel=agentDisplayLabel(selected,selectedIndex);
- const childAgents=agents.filter(agent=>agent.kind!=='root'),childTotals=group.child_totals||{},knownChildCost=Number(childTotals.known_cost)||0;
- const maximumChildCost=Math.max(0,...childAgents.filter(agent=>agent.cost_available===true).map(agent=>Number(agent.cost)||0));
- const childCostCovered=childTotals.cost_available===true&&Number.isFinite(Number(childTotals.cost));
- const totals=group.totals||{},coverage=group.coverage||{},hidden=Number(group.hidden_agent_count)||0;
- $('agent-activity-context').textContent=selected.kind==='root'
-  ? `${f(childAgents.length+hidden)} ${countWord(childAgents.length+hidden,'child agent')} under this session`
-  : `Main session → ${selectedLabel}`;
- $('agent-activity-coverage').textContent=[coverage.relationships==='complete'?'':`Relationships ${coverage.relationships||'unavailable'}`,['complete','estimated'].includes(coverage.cost)?'':`cost ${coverage.cost||'unavailable'}`,coverage.tokens==='complete'?'':`tokens ${coverage.tokens||'unavailable'}`,hidden?`${f(hidden)} hidden (limit 100)`:''].filter(Boolean).join(' · ');
- const metric=(label,value,note)=>`<div class="agentActivityMetric metric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
- $('agent-activity-metrics').innerHTML=[
-  metric('Group cost',totals.cost_available?money(totals.cost):'--',totals.cost_available?'API-rate estimate · all agents cost-covered':totals.known_cost?`${money(totals.known_cost)} covered cost; some agents unavailable`:'cost unavailable'),
-  metric('Child cost',childCostCovered?money(childTotals.cost):'--',childCostCovered?'API-rate estimate · root session excluded':knownChildCost?`${money(knownChildCost)} covered child cost; some agents unavailable`:'child cost unavailable'),
-  metric('Tokens',totals.tokens_available?f(totals.tokens):'--',totals.tokens_available?'all agents token-covered':totals.known_tokens?`${f(totals.known_tokens)} covered tokens; some agents unavailable`:'token evidence unavailable'),
-  metric('Agents',f(totals.agents||agents.length),`${f(childAgents.length+hidden)} children · ${f(attention.length)} ${countWord(attention.length,'signal')}`),
- ].join('');
- const rows=agents.map((agent,index)=>{
-  const identity=agentIdentityPresentation(agent,index),label=identity.primary,selectedRow=String(agent.id)===String(selectedAgentActivityId);
-  const model=agent.model&&agent.model!=='unknown'?agent.model:'model unavailable',state=agent.activity_state||'unknown';
-  const tokenValue=agent.tokens_available===true?f(agent.tokens):'--',costValue=agent.cost_available===true?money(agent.cost):'--';
-  const share=agent.group_cost_share==null?'--':pct(agent.group_cost_share),workTime=agent.work_time_s==null?'--':durationShort(agent.work_time_s);
-  const secondary=identity.secondary?`${identity.secondary} · `:'',kind=agent.kind==='root'?'session':agent.kind;
-  const destination=agent.navigable&&agent.session_id?` data-agent-session="${esc(agent.session_id)}"`:'';
-  const heat=agent.kind==='root'?'':subagentCostHeat(agent.cost,maximumChildCost,agent.cost_available);
-  return `<button class="agentRow${selectedRow?' selected':''}" type=button role=treeitem aria-level="${Math.max(1,Number(agent.depth||0)+1)}" aria-selected="${selectedRow?'true':'false'}" style="--agent-depth:${Math.max(0,Number(agent.depth)||0)}" data-agent-id="${esc(agent.id)}"${destination}><span class=agentIdentity><strong><span>${esc(label)}</span></strong><small>${esc(secondary+kind)}</small></span><span class=agentMetric>${esc(model)}</span><span class="agentState ${esc(state)}">${esc(state)}</span><span class=agentMetric>${esc(tokenValue)}</span><span class="agentMetric${heat?' subagentCostHeat':''}"${heat?` style="${heat}" title="Relative child cost in this session"`:''}>${esc(costValue)}</span><span class=agentMetric>${esc(share)}</span><span class=agentMetric>${esc(workTime)}</span></button>`;
- }).join('');
- $('agent-activity-tree').innerHTML='<div class=agentTreeHeader><span>Agent</span><span>Model</span><span>Status</span><span>Tokens</span><span class=fieldtip tabindex=0 aria-description="Cost color compares children in this session; it does not judge their work." data-tip="Cost color compares children in this session; it does not judge their work.">Cost</span><span>Share</span><span class=fieldtip tabindex=0 data-tip="Cumulative completed prompt-to-response time. Includes reasoning and tool use; excludes gaps between prompts.">Work time</span></div>'+rows;
- const selectedAttention=attentionByAgent.get(String(selected.id));
- $('agent-attention-detail').hidden=!selectedAttention;
- $('agent-attention-detail').innerHTML=selectedAttention
-  ? `<b>${esc(selectedLabel)} · Cost and retry evidence</b><ul>${selectedAttention.reasons.map(reason=>`<li>${esc(reason.explanation)}</li>`).join('')}</ul>`
-  : '';
-}
-$('agent-activity-tree').addEventListener('click',event=>{
- const row=event.target.closest('[data-agent-id]');
- if(!row||!CURRENT)return;
- selectedAgentActivityId=row.dataset.agentId;
- const destination=row.dataset.agentSession,currentId=String(stateSessionId(CURRENT)||'');
- if(destination&&destination!==currentId){selectSession(destination,{returnScope:sessionReturnScope});return;}
- renderAgentActivity(CURRENT);
-});
-
-function renderCurrentRun(s){
-	 const source=s.source||{},throughput=sessionDisplayThroughput(s),wait=s.wait_time||{},context=s.context||{},tools=s.tools||{},cache=s.cache||{},timing=s.timing||{};
- const costAvailable=metricAvailable(s,'cost'),cacheAvailable=metricAvailable(s,'cache'),throughputAvailable=metricAvailable(s,'throughput'),cacheSavingsAvailable=costAvailable&&cacheAvailable&&cache.savings_available!==false;
- const contextPct=Math.max(0,Math.min(1,Number(context.latest_pct)||0)),toolResultTokens=tools.total_output_tokens||0;
- const alert=sessionAlert(s),capSpend=sessionCapSpend(s),frozen=!!s.ended,cursorEstimate=s.provider==='cursor',cap=dollarInputValue('budget',Infinity),costPerTask=s.analyses?.cost_per_task||{};
- $('preview-provider').innerHTML=runtimeBadgeContent(s,source.label||s.provider||'source');
- $('preview-provider').className='badge app '+appBadgeClass(s);
- $('preview-project').textContent=s.project||source.project||'';
- $('preview-model').textContent=s.primary_model||'model unavailable';
- renderWorkTags(s.work_tags);
- renderDesktopSessionLink(s);
- $('preview-state').textContent=pinned?'Pinned':(frozen?'Complete':'Live');
- $('preview-idle').textContent=frozen?'frozen':idleLabel(s.idle_s);
- setCostValue('preview-cost',money(s.total_cost)+(s.cost_approx?' est':''),costAvailable);
- $('preview-cost-note').textContent=alert.msg?alert.msg:(capSpend.available&&Number.isFinite(cap)?`${capSpend.partial?'At most ':''}${money(Math.max(0,cap-capSpend.spend))} before the ${money(cap)} session cap`:source.pricing_note||'Cost evidence unavailable.');
- $('preview-status-card').classList.toggle('warn',!!alert.msg);
- $('preview-context-pct').textContent=context.window?pct(contextPct):'--';
- $('preview-context-bar').setAttribute('aria-valuenow',String(Math.round(contextPct*100)));
- $('preview-context-bar').querySelector('i').style.width=`${Math.round(contextPct*100)}%`;
- $('preview-started-at').textContent=(dt12(timing.start_local)||'--').replace(' ','\n');
- $('preview-last-label').textContent=frozen?'Completed':'Last activity';
- $('preview-last-at').textContent=(dt12(timing.end_local)||'--').replace(' ','\n');
- $('preview-speed').textContent=throughputAvailable&&throughput.available?`${speedFmt(throughput.output_tps)} tok/s`:'--';
-	 $('preview-speed-note').textContent=throughputAvailable&&throughput.available?sessionThroughputNote(throughput):'timing unavailable';
- $('preview-wait').textContent=wait.available?waitFmt(wait.total_s):'--';
- $('preview-wait-note').textContent=wait.available?`${waitFmt(wait.avg_s)} average · ${f(wait.sample_count)} completed`:'wait unavailable';
- $('preview-context').textContent=context.latest?f(context.latest):'--';
- $('preview-context-note').textContent=context.window?`${pct(contextPct)} of ${f(context.window)} window`:'window unavailable';
- $('preview-executions').textContent=f(s.turns||0);
- $('preview-executions-note').textContent=s.primary_model||'model unavailable';
- $('preview-tools').textContent=f(tools.total_calls||0);
- $('preview-tools-note').textContent=`${f(tools.activity?.observed_unique??tools.unique_used??0)} observed types`;
- $('preview-tool-results').textContent=f(toolResultTokens);
- $('preview-tool-results-note').textContent=`${f(tools.total_calls||0)} calls · estimated returned tokens`;
- $('preview-cache-rate').textContent=cacheAvailable?pct(cache.input_share||0):'--';
- $('preview-cache-rate-note').textContent=cacheAvailable?`${f(cache.total||0)} cached · ${f(cache.fresh||0)} fresh`:'cache accounting unavailable';
- $('preview-cache-saved').textContent=cacheSavingsAvailable?money(cache.saved||s.cache_saved||0):'--';
- $('preview-cache-saved-note').textContent=cacheSavingsAvailable?`${money(cache.cost||0)} cache cost · est. avoided spend`:'cache savings unavailable';
- $('preview-burn').textContent=costAvailable&&timing.duration_available?money(s.burn_usd_min)+(cursorEstimate?' est':''):'--';
- $('preview-burn-note').textContent=costAvailable&&timing.duration_available?`${f(s.burn_tok_min)} tokens/min · active`:(timing.duration_available?'billing unavailable':'execution timing unavailable');
- setCostValue('preview-cost-task',money(costPerTask.per_task||0)+(cursorEstimate?' est':''),costAvailable);
- $('preview-cost-task-note').textContent=costAvailable?`${f(costPerTask.completed||0)} completed tasks${cursorEstimate?'':' · est.'}`:'billing unavailable';
- const startMessage=sessionStartMessage(s)||(s.provider==='pi'?'Pi message content is not captured.':'No user message captured.');
- $('preview-start').textContent=startMessage;
- $('preview-start').dataset.tip=startMessage;
- $('preview-start').setAttribute('aria-description',startMessage);
-}
-
-function renderSession(s){
- CURRENT=s;
- loadBudgetForSession(s);
- renderCurrentBudgetWarning(s.xsession?.budget||LATEST?.xsession?.budget);
- const frozen=!!s.ended, source=s.source||{};
- $('s-provider').innerHTML=runtimeBadgeContent(s,source.label||s.provider||'source');
- $('s-provider').className='badge app '+appBadgeClass(s);
- $('s-repo').textContent=s.project||source.project||'';
- $('s-id').textContent=s.session||source.id||'';
- $('s-pricing').textContent=source.pricing_note||'';
- const modelIdentity=source.model_identity||{},modelIdentityAction=$('session-model-identity-action');
- const assignedModel=modelIdentity.source==='user_assigned';
- const modelIdentityAssignable=!!modelIdentity.assignable&&!!modelIdentity.key;
- modelIdentityAction.hidden=!modelIdentityAssignable;
- modelIdentityAction.style.display=modelIdentityAssignable?'inline-flex':'none';
- modelIdentityAction.textContent=assignedModel?'Change model':(modelIdentity.kind==='missing_model'?'Add model':'Assign model');
- modelIdentityAction.onclick=modelIdentityAction.hidden?null:()=>openSessionModelIdentityDialog({
-  label:source.label||s.provider,project:s.project||source.project||'',
-  title:sessionDisplayName(s),primary_model:s.primary_model,
-  models:s.primary_model?[s.primary_model]:[],model_identity:modelIdentity,
- });
- const startMessage=sessionStartMessage(s);
- $('session-start').hidden=!startMessage;
- $('session-start-text').textContent=startMessage;
- const sessionActions=s.xsession?.session_actions||{}, deleteButton=$('session-delete');
- const deleteAvailable=sessionDeleteAvailable(source,sessionActions);
- deleteButton.hidden=!source.id||!deleteAvailable;
- deleteButton.disabled=!deleteAvailable;
- deleteButton.title=deleteAvailable?'Move this session log to the system Trash.':'Session deletion is unavailable for this provider.';
- $('frozen').classList.toggle('on',frozen);
- const costAvailable=metricAvailable(s,'cost'),tokensAvailable=metricAvailable(s,'tokens'),inputAvailable=metricAvailable(s,'input_tokens'),outputAvailable=metricAvailable(s,'output_tokens'),cacheAvailable=metricAvailable(s,'cache'),throughputAvailable=metricAvailable(s,'throughput'),cursorEstimate=s.provider==='cursor';
- setCostValue('cost',money(s.total_cost)+(s.cost_approx?' est':''),costAvailable);
- const tok=s.tokens||{}, sem=s.semantic||{}, tools=s.tools||{}, cache=s.cache||{}, latestCache=cache.latest||{}, timing=s.timing||{};
- const cacheSavingsAvailable=costAvailable&&cacheAvailable&&cache.savings_available!==false;
- $('cost-tip').innerHTML=costTipHtml(s,tok);
- const inputTokens=(tok.input||0)+(tok.cache_read||0)+(tok.cache_write||0), outputTokens=tok.output||0;
-	 const thinkingTokens=sem.reasoning||0, toolCallTokens=tools.total_output_tokens||0, throughput=sessionDisplayThroughput(s);
-	 const speedPart=throughputAvailable&&throughput.available?` · <b>${speedFmt(throughput.output_tps)}</b> ${cursorEstimate?'visible out tok/s est':'out tok/s'}`:'';
-	 $('sub').innerHTML=`<b>${inputAvailable?f(inputTokens)+(cursorEstimate?' est':''):'--'}</b> in · <b>${outputAvailable?f(outputTokens)+(cursorEstimate?' est':''):'--'}</b> out${speedPart} · <b>${outputAvailable?f(thinkingTokens)+(cursorEstimate?' est':''):'--'}</b> thinking · <b>${f(toolCallTokens)}</b> estimated tool results · <b>${f(s.turns)}</b> executions`;
- $('input-tok').textContent=inputAvailable?f(inputTokens)+(cursorEstimate?' est':''):'--';
- $('input-toksm').textContent=inputAvailable?(cursorEstimate?`${f(tok.input||0)} context proxy · cache unknown`:`${f(tok.input||0)} uncached · ${f((tok.cache_read||0)+(tok.cache_write||0))} cache`):'input evidence unavailable';
- $('cache-hit').textContent=cacheAvailable?pct(cache.input_share||0):'--';
- $('cache-hitsm').textContent=cacheAvailable?`${f(cache.total||0)} cached · ${f(cache.fresh||0)} uncached`:'cache accounting unavailable';
- $('cache-tok').textContent=cacheAvailable?f(cache.total||0):'--';
-	 $('cache-toksm').textContent=cacheAvailable?`${f(cache.read||0)} read · ${f(cache.write||0)} write · latest ${f(latestCache.tokens||0)}`:'cache accounting unavailable';
-	 $('output-tok').textContent=outputAvailable?f(outputTokens)+(cursorEstimate?' est':''):'--';
-	 $('output-tps').textContent=throughputAvailable&&throughput.available?speedFmt(throughput.output_tps):'--';
-	 $('output-toksm').textContent=throughputAvailable&&throughput.available?`${sessionThroughputNote(throughput)}${cursorEstimate?' · visible text estimate':''}`:(outputAvailable?`of ${f(s.total_tokens)} total · timing unavailable${cursorEstimate?' · visible text estimate':''}`:'output evidence unavailable');
- $('think-tok').textContent=outputAvailable?f(thinkingTokens)+(cursorEstimate?' est':''):'--';
- $('think-toksm').textContent=cursorEstimate?`${f(s.analyses?.reasoning?.think_turns||0)} reasoning exec · hidden reasoning excluded`:outputAvailable?f(s.analyses?.reasoning?.think_turns||0)+' reasoning exec':`${f(s.analyses?.reasoning?.think_turns||0)} reasoning exec · duration only`;
- $('toolcall-tok').textContent=f(toolCallTokens);
- $('toolcall-toksm').textContent=f(tools.total_calls||0)+' calls returned';
- $('cache-saved').textContent=cacheSavingsAvailable?money(cache.saved||s.cache_saved||0):'--';
- $('cache-savedsm').textContent=cacheSavingsAvailable?`${money(cache.cost||0)} cache cost`:'cache savings unavailable';
- $('burn').textContent=costAvailable&&timing.duration_available?money(s.burn_usd_min)+(cursorEstimate?' est':''):'--';
- $('burnsm').textContent=costAvailable&&timing.duration_available?`${f(s.burn_tok_min)} tok/min · active${cursorEstimate?' · local proxy':''}`:(timing.duration_available?'active timing available · billing unavailable':'execution timing unavailable');
- setCostValue('cpt',money(s.analyses?.cost_per_task?.per_task||0)+(cursorEstimate?' est':''),costAvailable);
- $('cptsm').textContent=costAvailable?f(s.analyses?.cost_per_task?.completed||0)+` completed${cursorEstimate?' · local proxy':''}`:'billing unavailable';
- renderOverview(s); renderCurrentOptimization(s); renderCurrentRun(s); renderSessionEfficiency(s); renderAgentActivity(s);
-
- const semanticAvailable=s.semantic_available!==false,semTot=Object.values(sem).reduce((a,b)=>a+(b||0),0)||1;
- const segs=[['reasoning','var(--reason)'],['output','var(--output)'],['retrieval','var(--retrieval)'],['coordination','var(--coord)']];
- $('semhint').textContent=semanticAvailable?'':'semantic data unavailable';
- $('sembar').innerHTML=tokensAvailable&&semanticAvailable?segs.map(([k,c])=>{const w=100*(sem[k]||0)/semTot; if(w<0.6)return''; return `<span style="width:${w}%;background:${c}">${w>8?f(sem[k]):''}</span>`;}).join(''):'';
- drawIO(s.series||[]);
-
- const liveView=!pinned;
-
- const alert=sessionAlert(s);
- $('cost').classList.toggle('alert',!!alert.msg);
- renderAlertBanner(alert);
- if(alert.msg&&liveView) notifyAlertForSession(s);
-}
-
-let pendingSessionDelete=null;
-function sessionDeleteAvailable(target,actions){
- const provider=String(target?.provider||target?.client||'').toLowerCase();
- return Boolean(actions?.available)&&!(actions?.read_only_providers||[]).map(String).map(value=>value.toLowerCase()).includes(provider);
-}
-function sessionDeleteTargetFromState(state){
- const id=stateSessionId(state),source=state?.source||{},key=stateSessionKey(state);
- if(!id)return null;
- const row=(state?.xsession?.sessions||[]).find(item=>sessionRowKey(item)===key);
- return row||{id,session:state?.session||'',title:sessionStartMessage(state)||id,project:state?.project||source.project||'',label:source.label||state?.provider||'session',provider:source.provider||state?.provider||''};
-}
-function openSessionDeleteDialog(target,actions,returnToAll=false,isLive=false){
- if(!target?.id||!sessionDeleteAvailable(target,actions))return;
- pendingSessionDelete={target,actions,returnToAll,isLive};
- $('session-delete-sub').textContent=`${target.label||target.provider||'Session'} · ${target.project||'No project'}`;
- $('session-delete-evidence').innerHTML=`<div><b>${esc(target.title||'(untitled session)')}</b></div><div>This removes the underlying local JSONL session record from Token Meter.</div>`;
- $('session-delete-id').textContent=target.id;
- $('session-delete-note').textContent=isLive?'This appears to be the live session. Stop its agent first to prevent further writes. The session record will be moved to the system Trash; provider metadata and configuration are not changed.':'The session record will be moved to the system Trash and can be recovered there. Provider metadata and configuration are not changed.';
- $('session-delete-confirm').disabled=false;
- $('session-delete-confirm').textContent='Move to Trash';
- $('session-delete-dialog').showModal();
-}
-$('session-delete').onclick=()=>{
- const target=sessionDeleteTargetFromState(CURRENT),actions=CURRENT?.xsession?.session_actions||{};
- if(target)openSessionDeleteDialog(target,actions,sessionReturnScope==='all',Boolean(!pinned&&LATEST&&sessionRowKey(target)===stateSessionKey(LATEST)));
-};
-$('session-delete-cancel').onclick=()=>{$('session-delete-dialog').close();pendingSessionDelete=null;};
-$('session-delete-dialog').addEventListener('cancel',()=>{pendingSessionDelete=null;});
-$('session-delete-confirm').onclick=async()=>{
- if(!pendingSessionDelete)return;
- const {target,actions,returnToAll}=pendingSessionDelete,button=$('session-delete-confirm');
- button.disabled=true;button.textContent='Moving…';
- try{
-  const response=await fetch('/session/delete',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':actions.token},body:JSON.stringify({session_id:target.id,trace:target.session||''})});
-  const result=await response.json();
-  if(!response.ok||!result.ok)throw new Error(result.error||'Could not delete session.');
-  $('session-delete-dialog').close();pendingSessionDelete=null;sessionRequest++;pinned=null;
-  const stateResponse=await fetch('/state',{cache:'no-store'}),state=await stateResponse.json();
-  adoptFreshDiscounts(state);LATEST=state;CURRENT=state;
-  if(returnToAll||!stateSessionId(state)){
-   sessionScope='all';sessionReturnScope='all';
-   if(history.replaceState)history.replaceState(null,'','/#sessions-all');
-   applyHashRoute();
-   if(state.xsession)renderAllSessions(state.xsession);
-	  }else{
-	   if(history.replaceState)history.replaceState(null,'','/#sessions');
-	   applyHashRoute();
-  }
-  showAppToast({title:'Session moved to Trash',body:`${target.title||target.id} was removed from Token Meter.`,kind:'warn',sticky:true});
- }catch(error){
-  button.disabled=false;button.textContent='Move to Trash';
-  showAppToast({title:'Session deletion failed',body:error.message||String(error),kind:'warn',sticky:true});
- }
-};
-
-let pendingSessionModelIdentity=null;
-function sessionModelIdentitySourceLabel(identity){
- if(identity?.kind==='missing_model')return identity.source==='user_assigned'?'User-assigned Claude model':'Underlying Hermes model unavailable';
- return ({user_assigned:'User-assigned model',unresolved:'Underlying model unavailable'}[identity?.source]||'Saved model evidence');
-}
-function sessionModelIdentityPresentation(identity){
- const hermes=identity?.kind==='missing_model'&&identity?.runtime==='hermes';
- return hermes
-  ? {provider:'hermes',fieldLabel:'Claude model ID',placeholder:'claude-sonnet-5',noun:'Claude model ID',observedLabel:'Bedrock application profile'}
-  : {provider:'codex',fieldLabel:'Codex / OpenAI model ID',placeholder:'gpt-model-version',noun:'Codex / OpenAI model ID',observedLabel:''};
-}
-function openSessionModelIdentityDialog(target){
- const identity=target?.model_identity||{};
- if(!identity.assignable||!identity.key)return;
- const presentation=sessionModelIdentityPresentation(identity),candidates=Array.isArray(identity.candidates)?identity.candidates:[];
- pendingSessionModelIdentity={target,identity,presentation};
- $('session-model-identity-sub').textContent=`${target.label||target.provider||'Codex'} · ${target.project||'No project'}`;
- const observedLabel=identity.observed_label||presentation.observedLabel;
- const observed=observedLabel?` Observed: ${observedLabel}.`:'';
- const candidateText=candidates.length?` Configured public ${candidates.length===1?'alias':'aliases'}: ${candidates.join(', ')}.`:'';
- $('session-model-identity-evidence').innerHTML=`<div><b>${esc(target.title||'(untitled session)')}</b></div><div>${esc(sessionModelIdentitySourceLabel(identity))}.${esc(observed+candidateText)} Token Meter could not verify an exact billable model from the available local aggregate.</div>`;
- $('session-model-identity-model-label').textContent=presentation.fieldLabel;
- $('session-model-identity-model').placeholder=presentation.placeholder;
- $('session-model-identity-candidates').innerHTML=candidates.map(model=>`<option value="${esc(model)}"></option>`).join('');
- $('session-model-identity-model').value=identity.source==='user_assigned'?(identity.assigned_model||target.primary_model||(target.models||[])[0]||''):(candidates.length===1?candidates[0]:'');
- $('session-model-identity-remove').hidden=identity.source!=='user_assigned';
- $('session-model-identity-save').disabled=false;
- $('session-model-identity-save').textContent='Save model';
- $('session-model-identity-dialog').showModal();
- requestAnimationFrame(()=>$('session-model-identity-model').focus());
-}
-function closeSessionModelIdentityDialog(){
- $('session-model-identity-dialog').close();pendingSessionModelIdentity=null;
-}
-async function requestSessionModelIdentity(payload){
- const token=agentActionToken();
- if(!token)throw new Error('Settings are not ready yet. Wait for live state and try again.');
- const response=await fetch('/settings/session-model-identity',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify(payload)});
- const result=await response.json();
- if(!response.ok||!result.ok)throw new Error(result.error||'Could not save the session model.');
- return result;
-}
-$('session-model-identity-cancel').onclick=closeSessionModelIdentityDialog;
-$('session-model-identity-dialog').addEventListener('cancel',()=>{pendingSessionModelIdentity=null;});
-$('session-model-identity-save').onclick=async()=>{
- const pending=pendingSessionModelIdentity,button=$('session-model-identity-save');
- if(!pending)return;
- const model=$('session-model-identity-model').value.trim();
- if(!model){$('session-model-identity-model').focus();showAppToast({title:'Model ID required',body:`Enter the exact ${pending.presentation.noun} used for this saved session.`,kind:'warn'});return;}
- button.disabled=true;button.textContent='Saving…';
- try{
-  await requestSessionModelIdentity({session_key:pending.identity.key,provider:pending.presentation.provider,model});
-  closeSessionModelIdentityDialog();
-  forceAllSessionRowRefresh=true;
-  await refreshLiveState();
-  if(pinned)await refreshSelectedSession({show:true});
-  showAppToast({title:'Session model assigned',body:'Only this saved session changed. Model prices were not changed.',kind:'good'});
- }catch(error){
-  button.disabled=false;button.textContent='Save model';
-  showAppToast({title:'Session model could not be saved',body:error.message||String(error),kind:'warn',sticky:true});
- }
-};
-$('session-model-identity-remove').onclick=async()=>{
- const pending=pendingSessionModelIdentity,button=$('session-model-identity-remove');
- if(!pending)return;
- button.disabled=true;button.textContent='Clearing…';
- try{
-  await requestSessionModelIdentity({session_key:pending.identity.key,remove:true});
-  closeSessionModelIdentityDialog();
-  forceAllSessionRowRefresh=true;
-  await refreshLiveState();
-  if(pinned)await refreshSelectedSession({show:true});
-  showAppToast({title:'Session model assignment cleared',body:'This saved session remains unavailable until exact local evidence is present.',kind:'good'});
- }catch(error){
-  button.disabled=false;button.textContent='Clear assignment';
-  showAppToast({title:'Session model could not be cleared',body:error.message||String(error),kind:'warn',sticky:true});
- }
-};
-
-const CAPABILITY_SORT_KEYS=new Set(['name','type','runtime','state','use','last','control']);
-const CAPABILITY_TYPES=new Set(['all','tool','mcp','skill']);
-const CAPABILITY_PAGE_SIZE=100;
-let capabilityType='all', capabilityState='all', capabilityRuntime='all', capabilitySearch='';
-let capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
-let lastCapabilityReviewRevision='', lastCapabilityInventoryRevision='', capabilityLastGoodAt=0;
-let pendingCapabilityTable=null, pendingCapabilityReview=null, capabilityInventorySnapshot=null;
-let capabilityInventoryLoading=false, capabilitySearchTimer=null, capabilityEvidenceState='loading';
-const selectedCapabilityIds=new Set();
-const openCapabilityReviewIds=new Set();
-let capabilitySort=localStorage.getItem('tm_capability_sort')||'name';
-let capabilitySortDir=localStorage.getItem('tm_capability_sort_dir')||'asc';
-if(capabilitySort==='returned')capabilitySort='use';
-if(!CAPABILITY_SORT_KEYS.has(capabilitySort))capabilitySort='name';
-if(!['asc','desc'].includes(capabilitySortDir))capabilitySortDir='asc';
-function capabilityUseCount(row){ return row.type==='skill'?(row.activations||0):(row.calls||0); }
-function capabilityConfigurationText(row){
- if(row.type==='tool')return row.configuration||'Unknown';
- if(row.configuration)return row.configuration;
- return row.enabled===true?'Enabled':row.enabled===false?'Disabled':'Unknown';
-}
-function capabilityEvidenceText(row){
- const used=capabilityUseCount(row);
- if(used)return 'Observed';
- if(row.unmeasurable)return row.measurement==='instruction'?'Instruction-only':'Evidence unavailable';
- if(row.type==='tool'&&row.advertised_sessions)return 'Definition observed';
- return 'No use observed';
-}
-function capabilityControlText(row){
- if(!row.mutable)return 'read-only';
- const action=row.enabled?'Disable':'Enable';
- return row.type==='skill'?`${action} pack`:action;
-}
-function capabilitySortValue(row,key){
- if(key==='name')return row.name||row.identity||'';
- if(key==='type')return {tool:'Tool',mcp:'MCP',skill:'Skill'}[row.type]||row.type||'';
- if(key==='runtime')return [row.runtime,row.source,row.plugin_id,row.path].filter(Boolean).join(' · ');
- if(key==='state')return capabilityConfigurationText(row);
- if(key==='use')return Number(capabilityUseCount(row))||0;
- if(key==='last'){
-  if(!row.last_used||row.last_used==='Never')return 0;
-  const parsed=Date.parse(row.last_used);
-  return Number.isFinite(parsed)?parsed:0;
- }
- if(key==='control')return capabilityControlText(row);
- return '';
-}
-function compareCapabilityRows(a,b){
- const av=capabilitySortValue(a,capabilitySort), bv=capabilitySortValue(b,capabilitySort);
- const cmp=typeof av==='number'&&typeof bv==='number'
-  ? av-bv
-  : String(av).localeCompare(String(bv),undefined,{numeric:true,sensitivity:'base'});
- return capabilitySortDir==='desc'?-cmp:cmp;
-}
-function paintCapabilitySort(){
- [...$('c-table').querySelectorAll('th[data-csort]')].forEach(th=>{
-  const active=th.dataset.csort===capabilitySort;
-  th.classList.toggle('sort-asc',active&&capabilitySortDir==='asc');
-  th.classList.toggle('sort-desc',active&&capabilitySortDir==='desc');
-  th.setAttribute('aria-sort',active?(capabilitySortDir==='asc'?'ascending':'descending'):'none');
-  th.title=`Sort by ${th.textContent.trim()}${active?` (${capabilitySortDir==='asc'?'ascending':'descending'})`:''}`;
- });
- const mobile=$('c-mobile-sort'), choice=`${capabilitySort}:${capabilitySortDir}`;
- if(mobile&&[...mobile.options].some(option=>option.value===choice))mobile.value=choice;
-}
-function setCapabilitySort(key){
- if(!CAPABILITY_SORT_KEYS.has(key))return;
- capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
- if(capabilitySort===key)capabilitySortDir=capabilitySortDir==='asc'?'desc':'asc';
- else{
-  capabilitySort=key;
-  capabilitySortDir=['use','last'].includes(key)?'desc':'asc';
- }
- localStorage.setItem('tm_capability_sort',capabilitySort);
- localStorage.setItem('tm_capability_sort_dir',capabilitySortDir);
- paintCapabilitySort();
- const inventory=currentCapabilityInventory();
- if(inventory)renderCapabilityTable(inventory,{force:true});
-}
-function capabilityConfigurationClass(row){
- if(row.enabled===null||row.enabled===undefined)return 'unknown';
- return row.enabled?'on':'off';
-}
-function capabilityEvidenceClass(row){
- if(capabilityUseCount(row))return 'observed';
- if(row.unmeasurable)return 'unknown';
- if(row.type==='tool'&&/Deferred|Mixed/.test(row.state||''))return 'lazy';
- return 'unknown';
-}
-function capabilityAction(row){
- if(!row.mutable) return '<span class=subline>read-only</span>';
- const next=!row.enabled;
- const label=row.type==='skill'?`${next?'Enable':'Disable'} pack`:(next?'Enable':'Disable');
- const locked=capabilityEvidenceState!=='current';
- return `<button class="capAction ${next?'':'disable'}" data-cap-id="${esc(row.id)}" ${locked?'disabled data-evidence-locked="1" title="Wait for current evidence before changing settings"':''}>${label}</button>`;
-}
-function currentCapabilitySummary(){return LATEST?.xsession?.capabilities||null;}
-function currentCapabilityInventory(){
- const cap=currentCapabilitySummary();
- if(!cap||!capabilityInventorySnapshot||capabilityInventorySnapshot.inventory_revision!==cap.inventory_revision)return null;
- return {...cap,items:capabilityInventorySnapshot.items||[]};
-}
-function paintCapabilityFilters(){
- [...$('c-type-filter').querySelectorAll('button')].forEach(button=>{
-  const on=capabilityType===button.dataset.ctype;
-  button.classList.toggle('on',on);
-  button.setAttribute('aria-pressed',String(on));
- });
- [...document.querySelectorAll('[data-cap-jump]')].forEach(button=>{
-  const on=capabilityType===button.dataset.capJump;
-  button.classList.toggle('on',on);
-  button.setAttribute('aria-pressed',String(on));
- });
- [...$('c-state-filter').querySelectorAll('button')].forEach(button=>{
-  const on=capabilityState===button.dataset.cstate;
-  button.classList.toggle('on',on);
-  button.setAttribute('aria-pressed',String(on));
- });
- const filters=[];
- if(capabilityType!=='all')filters.push({key:'type',label:{tool:'Tools',mcp:'MCPs',skill:'Skills'}[capabilityType]||capabilityType});
- if(capabilityState!=='all')filters.push({key:'state',label:{enabled:'Configured on',observed:'Observed',unused:'No use observed'}[capabilityState]});
- if(capabilityRuntime!=='all')filters.push({key:'runtime',label:capabilityRuntime});
- if(capabilitySearch.trim())filters.push({key:'search',label:`Search: ${capabilitySearch.trim()}`});
- const active=$('c-active-filters');
- active.hidden=!filters.length;
- active.innerHTML=filters.length?`<span>Active</span>${filters.map(filter=>`<button type=button data-cap-clear="${filter.key}" aria-label="Remove ${esc(filter.label)} filter">${esc(filter.label)} <b aria-hidden=true>×</b></button>`).join('')}`:'';
- $('c-clear-filters').hidden=!filters.length;
- [...active.querySelectorAll('[data-cap-clear]')].forEach(button=>button.onclick=()=>clearCapabilityFilter(button.dataset.capClear));
-}
-function clearCapabilityFilter(key){
- if(key==='type')capabilityType='all';
- if(key==='state')capabilityState='all';
- if(key==='runtime')capabilityRuntime='all';
- if(key==='search'){capabilitySearch='';$('c-search').value='';}
- capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
- paintCapabilityFilters();
- const inventory=currentCapabilityInventory();
- if(inventory)renderCapabilityTable(inventory,{force:true});
-}
-function clearCapabilityFilters(){
- capabilityType='all';capabilityState='all';capabilityRuntime='all';capabilitySearch='';capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
- $('c-search').value='';
- paintCapabilityFilters();
- const inventory=currentCapabilityInventory();
- if(inventory)renderCapabilityTable(inventory,{force:true});
-}
-function capabilityPackName(row){
- const value=String(row?.plugin_id||row?.name||'Skill pack');
- return value.split('@')[0]||value;
-}
-function capabilityGroupFingerprint(row){
- return JSON.stringify([
-  row?.id||'',Boolean(row?.enabled),Boolean(row?.used),Boolean(row?.unmeasurable),
-  row?.measurement||'',row?.runtime||'',row?.plugin_id||'',row?.setting_path||'',
-  Number(row?.scanned_sessions||0),
-  Number(row?.unused_eager_definition_tokens||0),[...(row?.members||[])].sort()
- ]);
-}
-function updateCapabilitySelection(cap){
- const valid=new Set(unusedReviewGroups(cap).map(row=>row.id));
- [...selectedCapabilityIds].forEach(id=>{if(!valid.has(id))selectedCapabilityIds.delete(id);});
- const button=$('c-disable-selected'), count=selectedCapabilityIds.size;
- $('c-selection-bar').hidden=!count;
- $('c-selection-count').textContent=`${f(count)} ${countWord(count,'pack')} selected`;
- button.disabled=!count||capabilityEvidenceState!=='current';
- button.textContent='Disable selected…';
- button.title=capabilityEvidenceState==='current'?'Review exact controls before disabling':'Wait for current evidence before changing settings';
-}
-function clearCapabilitySelection(){
- selectedCapabilityIds.clear();
- [...$('c-review-list').querySelectorAll('[data-cap-select]')].forEach(input=>{input.checked=false;});
- updateCapabilitySelection(currentCapabilitySummary());
-}
-function renderCapabilityReviewQueue(cap,{force=false}={}){
- if(!cap)return;
- const groups=unusedReviewGroups(cap), optional=cap?.summary?.optional||{};
- const revision=String(cap.review_revision||JSON.stringify([
-  optional.review_candidates||[],groups.map(capabilityGroupFingerprint)
- ]));
- updateCapabilitySelection(cap);
- if(!force&&revision===lastCapabilityReviewRevision)return;
- const queue=$('c-review-list');
- const queueBusy=queue.matches(':hover')||queue.contains(document.activeElement);
- if(queueBusy&&!force){pendingCapabilityReview=cap;return;}
- pendingCapabilityReview=null;
- const panel=$('c-review-queue');
- panel.classList.toggle('warn',groups.length>0);
- panel.classList.toggle('good',groups.length===0);
- $('c-review-title').textContent=groups.length?'Needs review':'Nothing needs review';
- const runtimes=[...new Set(groups.map(row=>row.runtime||'Runtime'))];
- const sharedRuntime=runtimes.length===1?runtimes[0]:'';
- const restartNote=runtime=>`Restart ${runtime} to apply. Re-enable from All capabilities.`;
-  $('c-review-detail').textContent=groups.length
-  ? `No observed use means review, not proof of disuse.${sharedRuntime?` ${restartNote(sharedRuntime)}`:''}`
-  : `${f((optional.instruction_packs||0)+(optional.unknown_evidence_packs||0)+(optional.unscanned_packs||0))} ${countWord((optional.instruction_packs||0)+(optional.unknown_evidence_packs||0)+(optional.unscanned_packs||0),'pack')} excluded for missing use or coverage evidence.`;
- $('c-review-count').textContent=groups.length?`${f(groups.length)} user-installed ${countWord(groups.length,'pack')}`:'Queue clear';
- const head=`<div class=capReviewHead aria-hidden=true><span class=capReviewCols><span>Pack</span><span>Observed use</span><span>Prompt load</span><span>Affected</span><span>Status</span></span><span>Select</span></div>`;
- queue.innerHTML=groups.length?head+groups.map(row=>{
-  const members=row.members||[], scanned=Number(row.scanned_sessions||0);
-  const overhead=Number(row.unused_eager_definition_tokens||0);
-  const runtime=row.runtime||'Runtime', setting=row.setting_path||'runtime plugin settings';
-  const name=capabilityPackName(row), affected=`${f(members.length)} ${countWord(members.length,'skill')}`;
-  const use=`0 uses · ${f(scanned)} ${countWord(scanned,'log')}`;
-  const loadDetail=overhead?`Est. ${f(overhead)} avoidable definition tokens`:'Not measured';
-  const load=overhead?`≈${compactNumber(overhead)} tokens`:'—';
-  const memberChips=members.map(member=>`<span>${esc(member)}</span>`).join('');
-  const label=`${name}, ${runtime}, ${use}, prompt load ${loadDetail.toLowerCase()}, ${affected}, no use observed`;
-  return `<article class=capReviewItem data-cap-review-id="${esc(row.id)}"><details class=capReviewRow data-cap-review-open="${esc(row.id)}"${openCapabilityReviewIds.has(row.id)?' open':''}><summary class=capReviewCols aria-label="${esc(label)}"><span class=capReviewName><strong>${esc(name)}</strong><span>${esc(runtime)} · User-installed</span></span><span class=capReviewNum>${esc(use)}</span><span class=capReviewNum title="${esc(loadDetail)}">${esc(load)}</span><span class=capReviewNum>${esc(affected)}</span><span class="stateDot unknown">No use observed</span></summary><div class=capReviewDisclosureBody><dl class=capReviewFacts><div><dt>Observed use</dt><dd>0 activations · ${f(scanned)} ${esc(runtime)} ${countWord(scanned,'log')}</dd></div><div><dt>Prompt-load impact</dt><dd>${esc(loadDetail)}</dd></div><div><dt>Affected</dt><dd>${affected}</dd></div></dl>${sharedRuntime?'':`<p class=capReviewImpact>${esc(restartNote(runtime))}</p>`}<div><b>Affected skills</b><div class=capReviewMembers>${memberChips||'<span>No member names available</span>'}</div></div><div>${overhead?'The avoidable-load estimate is the cumulative runtime-reported definition evidence across the scanned logs, not a per-prompt saving.':'Prompt saving is not measurable from the available evidence; this is only an activation review.'}</div><div><b>Exact control</b><div class=capReviewControl>${esc(row.id)}</div></div><div><b>Setting</b><div class=capReviewControl>${esc(setting)}</div></div></div></details><label class=capSelect><input type=checkbox data-cap-select="${esc(row.id)}" aria-label="Select ${esc(name)}" ${selectedCapabilityIds.has(row.id)?'checked':''}><span>Select</span></label></article>`;
- }).join(''):`<div class=capQueueEmpty><h3>No candidate requires a decision</h3><p>Only packs with reliable activation evidence appear here.</p><button class=tbtn type=button data-cap-browse>Browse all capabilities</button></div>`;
- lastCapabilityReviewRevision=revision;
- [...queue.querySelectorAll('[data-cap-review-open]')].forEach(details=>details.addEventListener('toggle',()=>{
-  if(details.open)openCapabilityReviewIds.add(details.dataset.capReviewOpen);else openCapabilityReviewIds.delete(details.dataset.capReviewOpen);
- }));
- [...queue.querySelectorAll('[data-cap-select]')].forEach(input=>input.onchange=()=>{
-  if(input.checked)selectedCapabilityIds.add(input.dataset.capSelect);else selectedCapabilityIds.delete(input.dataset.capSelect);
-  updateCapabilitySelection(cap);
- });
- queue.querySelector('[data-cap-browse]')?.addEventListener('click',()=>openCapabilityInventory());
- updateCapabilitySelection(cap);
-}
-function renderCapabilityTable(cap,{force=false}={}){
- if(!cap)return;
- const tableBusy=$('c-table').matches(':hover')||$('c-table').contains(document.activeElement);
- if(tableBusy&&!force){pendingCapabilityTable=cap;return;}
- pendingCapabilityTable=null;
- const all=cap?.items||[];
- const runtimes=[...new Set(all.map(row=>row.runtime).filter(Boolean))].sort((a,b)=>a.localeCompare(b));
- if(capabilityRuntime!=='all'&&!runtimes.includes(capabilityRuntime))capabilityRuntime='all';
- $('c-runtime-filter').innerHTML='<option value="all">All runtimes</option>'+runtimes.map(runtime=>`<option value="${esc(runtime)}">${esc(runtime)}</option>`).join('');
- $('c-runtime-filter').value=capabilityRuntime;
- const q=capabilitySearch.trim().toLowerCase();
- const rows=all.filter(row=>{
-  if(capabilityType!=='all'&&row.type!==capabilityType)return false;
-  if(capabilityRuntime!=='all'&&row.runtime!==capabilityRuntime)return false;
-  if(capabilityState==='enabled'&&row.enabled!==true)return false;
-  if(capabilityState==='observed'&&!capabilityUseCount(row))return false;
-  if(capabilityState==='unused'&&(row.used||row.unmeasurable))return false;
-  if(q&&![row.name,row.identity,row.runtime,row.source,row.plugin_id,row.path,row.state].join(' ').toLowerCase().includes(q))return false;
-  return true;
- }).map((row,index)=>({row,index})).sort((a,b)=>compareCapabilityRows(a.row,b.row)||a.index-b.index).map(item=>item.row);
- const visibleRows=rows.slice(0,capabilityVisibleLimit);
- $('c-filter-count').textContent=rows.length===visibleRows.length?`${f(rows.length)} shown · ${f(all.length)} discovered`:`${f(visibleRows.length)} of ${f(rows.length)} matches shown · ${f(all.length)} discovered`;
- $('c-table').querySelector('tbody').innerHTML=rows.length?visibleRows.map(row=>{
-  const source=[row.runtime,row.source].filter(Boolean).join(' · ');
-  const detail=row.path?`<div class=capPath title="${esc(row.path)}">${esc(row.path)}</div>`:(row.plugin_id?`<div class=capPath>${esc(row.plugin_id)}</div>`:'');
-  const identifier=row.type==='skill'?`<div class=capPath title="${esc(row.id)}">${esc(row.id)}</div>`:'';
-  const configuration=capabilityConfigurationText(row), evidence=capabilityEvidenceText(row);
-  const typeLabel=row.control_type==='skill_pack'?'Skill pack':({tool:'Tool',mcp:'MCP',skill:'Skill'}[row.type]||row.type);
-  const use=capabilityUseCount(row);
-  const evidenceDetail=row.unmeasurable
-   ? (row.measurement==='instruction'?'Use cannot be inferred from instruction text.':'No reliable activation evidence is available.')
-   : `${f(use)} ${countWord(use,row.type==='skill'?'activation':'call')}${row.nested_calls?` (${f(row.nested_calls)} ${countWord(row.nested_calls,'code-mode call site')})`:''}${row.type==='skill'?'':` · ${f(row.returned_tokens||0)} returned tokens`}`;
-  return `<tr><td class=nm data-label="Capability">${esc(row.name)}${row.identity&&row.identity!==row.name?`<div class=capPath>${esc(row.identity)}</div>`:''}${identifier}</td><td data-label="Type"><span class="chip ${row.type==='mcp'?'mcp':''}">${typeLabel}</span></td><td data-label="Runtime / source">${esc(source)}${detail}</td><td data-label="Configuration"><span class="stateDot ${capabilityConfigurationClass(row)}">${esc(configuration)}</span>${row.type==='mcp'?`<div class=capPath>${row.configured===false?(row.calls?'Observed in traces; not in Codex or Claude config':'Advertised in traces; not in Codex or Claude config'):`Codex ${row.codex_enabled?'on':'off'} · Claude ${row.claude_enabled?'on':'off'}`}</div>`:''}</td><td data-label="Evidence"><div class=capEvidence><strong><span class="stateDot ${capabilityEvidenceClass(row)}">${esc(evidence)}</span></strong><small>${esc(evidenceDetail)}</small></div></td><td data-label="Last observed">${esc(row.last_used||'Never')}</td><td data-label="Control">${capabilityAction(row)}</td></tr>`;
- }).join('')+(visibleRows.length<rows.length?`<tr><td colspan=7 class=capMore><button class=tbtn type=button data-cap-more>Show next ${f(Math.min(CAPABILITY_PAGE_SIZE,rows.length-visibleRows.length))}</button></td></tr>`:''):`<tr><td colspan=7 class=capEmpty>No capabilities match these filters.<button class=tbtn type=button data-cap-clear>Clear filters</button></td></tr>`;
- lastCapabilityInventoryRevision=String(cap.inventory_revision||cap.revision||'');
- paintCapabilitySort();
- paintCapabilityFilters();
- [...$('c-table').querySelectorAll('[data-cap-id]')].forEach(button=>button.onclick=()=>{
-  const item=all.find(row=>row.id===button.dataset.capId);
-  const group=(cap?.control_groups||[]).find(row=>row.id===(item?.control_id||item?.id));
-  requestCapabilityToggle(group?{...item,...group,id:item.id,control_id:group.id}:item,cap);
- });
- $('c-table').querySelector('[data-cap-clear]')?.addEventListener('click',clearCapabilityFilters);
- $('c-table').querySelector('[data-cap-more]')?.addEventListener('click',()=>{capabilityVisibleLimit+=CAPABILITY_PAGE_SIZE;renderCapabilityTable(cap,{force:true});});
-}
-$('c-table').addEventListener('pointerleave',()=>{if(pendingCapabilityTable)renderCapabilityTable(pendingCapabilityTable,{force:true});});
-$('c-table').addEventListener('focusout',()=>requestAnimationFrame(()=>{if(pendingCapabilityTable&&!$('c-table').contains(document.activeElement))renderCapabilityTable(pendingCapabilityTable,{force:true});}));
-$('c-review-list').addEventListener('pointerleave',()=>{if(pendingCapabilityReview)renderCapabilityReviewQueue(pendingCapabilityReview,{force:true});});
-$('c-review-list').addEventListener('focusout',()=>requestAnimationFrame(()=>{if(pendingCapabilityReview&&!$('c-review-list').contains(document.activeElement))renderCapabilityReviewQueue(pendingCapabilityReview,{force:true});}));
-function openCapabilityInventory(type='all'){
- capabilityType=CAPABILITY_TYPES.has(type)?type:'all';
- capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
- paintCapabilityFilters();
- const inventory=currentCapabilityInventory();
- if(inventory)renderCapabilityTable(inventory,{force:true});else loadCapabilityInventory({force:true});
- $('c-inventory').scrollIntoView({behavior:'smooth',block:'start'});
- requestAnimationFrame(()=>$('c-inventory-title').focus({preventScroll:true}));
-}
-async function loadCapabilityInventory({force=false}={}){
- if(capabilityInventoryLoading)return;
- const cap=currentCapabilitySummary();
- if(!cap)return;
- if(!force&&capabilityInventorySnapshot&&capabilityInventorySnapshot.inventory_revision===cap.inventory_revision){
-  renderCapabilityTable(currentCapabilityInventory());
-  return;
- }
- capabilityInventoryLoading=true;
- $('c-filter-count').textContent='Loading inventory…';
- $('c-table').querySelector('tbody').innerHTML='<tr><td colspan=7 class=capEmpty>Loading local capability inventory…</td></tr>';
- try{
-  const response=await fetch('/capabilities/inventory',{cache:'no-store'});
-  const result=await response.json();
-  if(!response.ok||!result.ok||!Array.isArray(result.items))throw new Error('Capability inventory could not be loaded.');
-  capabilityInventorySnapshot=result;
-  const merged=currentCapabilityInventory();
-  if(merged)renderCapabilityTable(merged,{force});
- }catch(error){
-  $('c-filter-count').textContent='Inventory unavailable';
-  $('c-table').querySelector('tbody').innerHTML='<tr><td colspan=7 class=capEmpty>Inventory could not be loaded.<button class=tbtn type=button data-cap-retry>Retry</button></td></tr>';
-  $('c-table').querySelector('[data-cap-retry]')?.addEventListener('click',()=>loadCapabilityInventory({force:true}));
- }finally{capabilityInventoryLoading=false;}
-}
-let pendingCapabilityAction=null;
-function requestCapabilityToggle(row,cap){
- if(!row||!row.mutable||capabilityEvidenceState!=='current')return;
- const enabled=!row.enabled, members=row.members||[row.name], shown=members.slice(0,8);
- const controlId=row.control_id||row.id;
- pendingCapabilityAction={row,controlId,fingerprint:capabilityGroupFingerprint({...row,id:controlId})};
- $('cap-dialog-title').textContent=`${enabled?'Enable':'Disable'} skill pack?`;
- $('cap-dialog-sub').textContent=`${row.runtime} · ${row.plugin_id} · ${row.source||row.origin||'configured plugin'}`;
- $('cap-dialog-evidence').innerHTML=`<div>This changes the entire pack, not only ${esc(row.name)}.</div><div>${f(members.length)} affected ${countWord(members.length,'skill')}: ${esc(shown.join(', '))}${members.length>shown.length?` and ${f(members.length-shown.length)} more`:''}</div>`;
- $('cap-dialog-control').textContent=controlId;
- $('cap-dialog-setting').textContent=`The persisted ${row.setting_path||'runtime setting'} will be read back and verified before success is reported. Restart the IDE or agent afterward.`;
- const button=$('cap-confirm');
- button.disabled=false; button.textContent=`${enabled?'Enable':'Disable'} pack`;
- button.classList.toggle('danger',!enabled);
- $('cap-dialog').showModal();
-}
-$('cap-cancel').onclick=()=>{$('cap-dialog').close();pendingCapabilityAction=null;};
-$('cap-dialog').addEventListener('cancel',()=>{pendingCapabilityAction=null;});
-$('cap-confirm').onclick=()=>{
- if(!pendingCapabilityAction)return;
- const {row,controlId,fingerprint}=pendingCapabilityAction, cap=currentCapabilitySummary();
- const group=(cap?.control_groups||[]).find(item=>item.id===controlId);
- if(capabilityEvidenceState!=='current'||!group||capabilityGroupFingerprint(group)!==fingerprint){
-  $('cap-dialog').close();pendingCapabilityAction=null;
-  showAppToast({title:'Capability state changed',body:'The exact control or its evidence changed while confirmation was open. Reopen it from the current inventory.',kind:'warn',sticky:true});
-  return;
- }
- toggleCapability({...row,...group,id:row.id,control_id:controlId},cap,$('cap-confirm'));
-};
-function applyCapabilitySnapshot(freshCap){
- if(!freshCap)return;
- if(LATEST?.xsession)LATEST.xsession.capabilities=freshCap;
- if(CURRENT?.xsession)CURRENT.xsession.capabilities=freshCap;
- renderCapabilities(freshCap,{force:true});
-}
-async function toggleCapability(row,cap,confirmButton=null){
- if(!row||!row.mutable||capabilityEvidenceState!=='current')return;
- const enabled=!row.enabled;
- const controlId=row.control_id||row.id;
- const payload={type:row.type,enabled,control_id:controlId};
- const buttons=[...document.querySelectorAll(`[data-cap-id="${CSS.escape(row.id)}"]`)];
- buttons.forEach(button=>{button.disabled=true;button.textContent=enabled?'Enabling…':'Disabling…';});
- if(confirmButton){confirmButton.disabled=true;confirmButton.textContent=enabled?'Enabling…':'Disabling…';}
- try{
-  const response=await fetch('/capability/toggle',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':cap.actions.token},body:JSON.stringify(payload)});
-  const result=await response.json();
-  if(!response.ok||!result.ok)throw new Error(result.error||'Capability change failed.');
-  (cap.items||[]).forEach(item=>{
-   if(item.id===row.id||item.control_id===controlId){
-    item.enabled=enabled; item.state=enabled?'Enabled':'Disabled';
-   }
-  });
-  (cap.control_groups||[]).forEach(group=>{if(group.id===controlId)group.enabled=enabled;});
-  let freshCap=result.capabilities||cap;
-  if(!result.capabilities)try{
-   const fresh=await fetch('/state',{cache:'no-store'}).then(response=>response.json());
-   if(fresh?.xsession?.capabilities){adoptFreshDiscounts(fresh);LATEST=fresh;if(!pinned)CURRENT=fresh;freshCap=fresh.xsession.capabilities;}
-  }catch(_error){}
-  if(result.capabilities)applyCapabilitySnapshot(freshCap);
-  if(confirmButton){$('cap-dialog').close();pendingCapabilityAction=null;}
-  if(!result.capabilities)renderCapabilities(freshCap,{force:true});
-  const verified=result.verified?' Setting verified.':'';
-  showAppToast({title:`Skill pack ${enabled?'enabled':'disabled'}`,body:`${row.plugin_id} changed for future sessions.${verified} Restart the IDE or agent to load the change.`,kind:enabled?'neutral':'warn',sticky:true});
- }catch(error){
-  buttons.forEach(button=>{button.disabled=false;});
-  if(confirmButton){confirmButton.disabled=false;confirmButton.textContent=`${enabled?'Enable':'Disable'} pack`;}
-  showAppToast({title:'Capability change failed',body:error.message||String(error),kind:'warn',sticky:true});
-  const inventory=currentCapabilityInventory();
-  if(inventory)renderCapabilityTable(inventory,{force:true});
- }
-}
-let pendingBulkDisable=null;
-function unusedReviewGroups(cap){
- const ids=new Set(cap?.summary?.optional?.review_candidates||[]);
- return (cap?.control_groups||[]).filter(row=>ids.has(row.id)&&row.reviewable!==false&&row.mutable&&row.enabled&&!row.used&&!row.unmeasurable&&Number(row.scanned_sessions||0)>0);
-}
-function openSelectedDisableDialog(cap){
- if(capabilityEvidenceState!=='current')return;
- const groups=unusedReviewGroups(cap).filter(row=>selectedCapabilityIds.has(row.id));
- if(!groups.length)return;
- const controlIds=groups.map(row=>row.id);
- pendingBulkDisable={controlIds,fingerprints:Object.fromEntries(groups.map(row=>[row.id,capabilityGroupFingerprint(row)]))};
- const affected=groups.reduce((total,row)=>total+(row.members||[]).length,0);
- const measured=groups.reduce((total,row)=>total+Number(row.unused_eager_definition_tokens||0),0);
- const coverage=[...new Map(groups.map(row=>[row.runtime||'Runtime',Number(row.scanned_sessions||0)])).entries()].map(([runtime,count])=>`${f(count)} ${runtime} ${countWord(count,'log')}`).join(' · ');
- $('bulk-dialog-sub').textContent=`${f(groups.length)} selected ${countWord(groups.length,'skill pack')} will be disabled`;
- $('bulk-dialog-evidence').innerHTML=`<div>${f(affected)} affected ${countWord(affected,'skill')} · evidence from ${esc(coverage)}</div><div>Estimated avoidable prompt load across scanned logs: ${measured?`${f(measured)} definition tokens`:'not measured'}. This is not a per-prompt saving. Restart each affected runtime after the change; packs can be re-enabled from All capabilities.</div><div>MCP servers, runtime packs, built-ins, standalone skills, and used groups are excluded.</div>`;
- $('bulk-dialog-controls').textContent=controlIds.join('\n');
- $('bulk-confirm').disabled=false;
- $('bulk-confirm').textContent='Disable selected';
- $('bulk-dialog').showModal();
-}
-$('bulk-cancel').onclick=()=>{$('bulk-dialog').close();pendingBulkDisable=null;};
-$('bulk-dialog').addEventListener('cancel',()=>{pendingBulkDisable=null;});
-$('bulk-confirm').onclick=async()=>{
- if(!pendingBulkDisable)return;
- const {controlIds,fingerprints}=pendingBulkDisable, button=$('bulk-confirm');
- const cap=currentCapabilitySummary(), current=new Map(unusedReviewGroups(cap).map(row=>[row.id,row]));
- const groups=controlIds.map(id=>current.get(id));
- const changed=capabilityEvidenceState!=='current'||groups.some((row,index)=>!row||capabilityGroupFingerprint(row)!==fingerprints[controlIds[index]]);
- if(changed){
-  $('bulk-dialog').close();pendingBulkDisable=null;
-  renderCapabilityReviewQueue(cap,{force:true});
-  showAppToast({title:'Review evidence changed',body:'The selected controls or their evidence changed while confirmation was open. Review the current receipts before trying again.',kind:'warn',sticky:true});
-  return;
- }
- button.disabled=true;button.textContent='Disabling…';
- try{
-  const response=await fetch('/capability/disable-unused',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':cap.actions.token},body:JSON.stringify({control_ids:controlIds})});
-  const result=await response.json();
-  if(result.capabilities)applyCapabilitySnapshot(result.capabilities);
-  if(!response.ok||!result.ok){
-   if(result.partial){
-    $('bulk-dialog').close();pendingBulkDisable=null;
-    selectedCapabilityIds.clear();
-    (result.failures||[]).forEach(row=>{if(row.control_id)selectedCapabilityIds.add(row.control_id);});
-    renderCapabilityReviewQueue(currentCapabilitySummary(),{force:true});
-    const names=(result.failures||[]).map(row=>row.name).slice(0,4).join(', ');
-    showAppToast({title:'Some groups could not be disabled',body:`${f(result.changed)} changed; ${f((result.failures||[]).length)} failed${names?`: ${names}`:''}.`,kind:'warn',sticky:true});
-    return;
-   }
-   throw new Error(result.error||'Unused capabilities could not be disabled.');
-  }
-  $('bulk-dialog').close();pendingBulkDisable=null;
-  selectedCapabilityIds.clear();
-  showAppToast({title:'Selected packs disabled',body:`${f(result.changed)} packs changed and verified. Restart the IDE or agent to load the changes.`,kind:'warn',sticky:true});
- }catch(error){
-  button.disabled=false;button.textContent='Disable selected';
-  showAppToast({title:'Selected capability change failed',body:error.message||String(error),kind:'warn',sticky:true});
- }
-};
-function setCapabilityAvailability(state){
- capabilityEvidenceState=state;
- if(state!=='current'){
-  [...document.querySelectorAll('#c-table [data-cap-id]')].forEach(button=>{button.disabled=true;button.dataset.evidenceLocked='1';});
-  $('c-disable-selected').disabled=true;
-  let closedConfirmation=false;
-  if($('bulk-dialog').open&&!/ing…$/.test($('bulk-confirm').textContent)){$('bulk-dialog').close();pendingBulkDisable=null;closedConfirmation=true;}
-  else if($('bulk-dialog').open)$('bulk-confirm').disabled=true;
-  if($('cap-dialog').open&&!/ing…$/.test($('cap-confirm').textContent)){$('cap-dialog').close();pendingCapabilityAction=null;closedConfirmation=true;}
-  else if($('cap-dialog').open)$('cap-confirm').disabled=true;
-  if(closedConfirmation)showAppToast({title:'Confirmation closed',body:'Capability evidence became stale. Wait for a current snapshot, then review the exact control again.',kind:'warn',sticky:true});
- }else{
-  [...document.querySelectorAll('#c-table [data-evidence-locked]')].forEach(button=>{delete button.dataset.evidenceLocked;if(!/ing…$/.test(button.textContent))button.disabled=false;});
-  updateCapabilitySelection(currentCapabilitySummary());
- }
-}
-function renderCapabilities(cap,{force=false}={}){
- if(!cap){setCapabilityAvailability('unavailable');return;}
- capabilityLastGoodAt=Date.now();
- setCapabilityAvailability('current');
- const sum=cap.summary||{}, defs=sum.definitions||{}, optional=sum.optional||{};
- const tools=sum.tools||{}, mcps=sum.mcps||{}, skills=sum.skills||{};
- $('c-stat-tools').textContent=f(tools.available||0);
- $('c-stat-tools-detail').textContent=`${f(tools.observed||0)} observed`;
- $('c-stat-mcps').textContent=f(mcps.available||0);
- $('c-stat-mcps-detail').textContent=`${f(mcps.enabled||0)} configured on · ${f(mcps.historically_used||0)} observed`;
- $('c-stat-skills').textContent=f(skills.available||0);
- $('c-stat-skills-detail').textContent=`${f(skills.enabled||0)} enabled · ${f(skills.historically_used||skills.used||0)} activated`;
- const inventoryCount=Number(cap.inventory_count??(cap.items||[]).length);
- $('c-inventory-count').textContent=`${f(inventoryCount)} ${countWord(inventoryCount,'capability','capabilities')}`;
- const eager=defs.eager_definition_tokens||0, unused=defs.unused_eager_definition_tokens||0, deferred=defs.deferred_definition_tokens||0, total=defs.definition_tokens||0, useful=Math.max(0,eager-unused);
- const denom=Math.max(1,total);
- $('c-def-chart').innerHTML=`<i class=used style="width:${100*useful/denom}%"></i><i class=unused style="width:${100*unused/denom}%"></i><i class=deferred style="width:${100*deferred/denom}%"></i>`;
- $('c-def-legend').innerHTML=`<span><i class=dot style="background:var(--good)"></i>useful eager ${f(useful)}</span><span><i class=dot style="background:var(--warn)"></i>unused eager ${f(unused)}</span><span><i class=dot style="background:rgb(var(--signal-hi-rgb)/.42)"></i>deferred ${f(deferred)}</span>`;
- $('c-def-note').textContent=total?`${f(total)} schema tokens · evidence only`:'No prompt-load token evidence';
- renderCapabilityReviewQueue(cap,{force});
- const revision=String(cap.inventory_revision||'');
- if(capabilityInventorySnapshot&&capabilityInventorySnapshot.inventory_revision===revision){
-  if(force||lastCapabilityInventoryRevision!==revision)renderCapabilityTable(currentCapabilityInventory(),{force});
- }else loadCapabilityInventory({force});
-}
-$('c-search').oninput=e=>{
- capabilitySearch=e.target.value;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
- clearTimeout(capabilitySearchTimer);
- capabilitySearchTimer=setTimeout(()=>{const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});},120);
-};
-$('c-type-filter').onclick=e=>{if(!e.target.dataset.ctype)return;capabilityType=e.target.dataset.ctype;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;paintCapabilityFilters();const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});};
-$('c-state-filter').onclick=e=>{if(!e.target.dataset.cstate)return;capabilityState=e.target.dataset.cstate;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;paintCapabilityFilters();const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});};
-$('c-runtime-filter').onchange=e=>{capabilityRuntime=e.target.value;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});};
-$('c-clear-filters').onclick=clearCapabilityFilters;
-[...document.querySelectorAll('[data-cap-jump]')].forEach(button=>button.onclick=()=>openCapabilityInventory(button.dataset.capJump));
-$('c-clear-selection').onclick=clearCapabilitySelection;
-$('c-disable-selected').onclick=()=>openSelectedDisableDialog(currentCapabilitySummary());
-$('c-table').querySelector('thead').onclick=e=>{const th=e.target.closest('th[data-csort]');if(th)setCapabilitySort(th.dataset.csort);};
-$('c-table').querySelector('thead').onkeydown=e=>{if(!['Enter',' '].includes(e.key))return;const th=e.target.closest('th[data-csort]');if(!th)return;e.preventDefault();setCapabilitySort(th.dataset.csort);};
-$('c-mobile-sort').onchange=e=>{
- const [key,dir]=e.target.value.split(':');
- if(!CAPABILITY_SORT_KEYS.has(key)||!['asc','desc'].includes(dir))return;
- capabilitySort=key;capabilitySortDir=dir;capabilityVisibleLimit=CAPABILITY_PAGE_SIZE;
- localStorage.setItem('tm_capability_sort',capabilitySort);localStorage.setItem('tm_capability_sort_dir',capabilitySortDir);
- paintCapabilitySort();const inventory=currentCapabilityInventory();if(inventory)renderCapabilityTable(inventory,{force:true});
-};
-paintCapabilityFilters();
-paintCapabilitySort();
-
-function localDayKey(date=new Date()){
- const y=date.getFullYear(),m=String(date.getMonth()+1).padStart(2,'0'),d=String(date.getDate()).padStart(2,'0');
- return `${y}-${m}-${d}`;
-}
-function dayLabel(day){
- if(!day)return 'No date';
- return new Date(`${day}T12:00:00`).toLocaleDateString([],{weekday:'short',month:'short',day:'numeric',year:'numeric'});
-}
-function shortDayLabel(day){
- if(!day)return '--';
- return new Date(`${day}T12:00:00`).toLocaleDateString([],{month:'short',day:'numeric'});
-}
-function dailyDeltaLabel(current,baseline){
- current=Number(current||0);baseline=Number(baseline||0);
- if(!baseline)return current?'New':'0%';
- const value=Math.round(100*(current-baseline)/baseline);
- return value>0?`+${value}%`:value<0?`\u2212${Math.abs(value)}%`:'0%';
-}
-// spend-range-logic-start
-const SPEND_RUNTIME_COLORS={claude:'var(--provider-claude)',codex:'var(--provider-codex)',cursor:'var(--provider-cursor)',opencode:'var(--provider-opencode)',kiro:'var(--provider-kiro)',unknown:'var(--provider-other)'};
-const SPEND_RUNTIME_ORDER=['claude','codex','cursor','opencode','kiro','unknown'];
-const SPEND_RUNTIME_LABELS={claude:'Claude',codex:'Codex',cursor:'Cursor',opencode:'OpenCode',kiro:'Kiro',unknown:'Unknown'};
-function spendDayDate(day){
- const match=/^(\d{4})-(\d{2})-(\d{2})$/.exec(String(day||''));
- if(!match)return null;
- const date=new Date(Number(match[1]),Number(match[2])-1,Number(match[3]),12,0,0,0);
- return date.getFullYear()===Number(match[1])&&date.getMonth()===Number(match[2])-1&&date.getDate()===Number(match[3])?date:null;
-}
-function spendDayKey(date){return `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;}
-function spendShiftDay(day,amount){const date=spendDayDate(day);if(!date)return '';date.setDate(date.getDate()+amount);return spendDayKey(date);}
-function spendRangeWindow(range,from='',to='',now=new Date(),earliest=''){
- const end=spendDayKey(now);
- if(range==='all'){
-  const start=spendDayDate(earliest)&&earliest<end?earliest:end;
-  return {valid:true,start,end,dayCount:Math.round((spendDayDate(end)-spendDayDate(start))/86400000)+1,error:''};
- }
- if(range==='yesterday'){const day=spendShiftDay(end,-1);return {valid:true,start:day,end:day,dayCount:1,error:''};}
- if(range==='month'){
-  const startDate=new Date(now.getFullYear(),now.getMonth(),1,12,0,0,0),endDate=spendDayDate(end);
-  return {valid:true,start:spendDayKey(startDate),end,dayCount:Math.round((endDate-startDate)/86400000)+1,error:''};
- }
- if(range==='last_month'){
-  const startDate=new Date(now.getFullYear(),now.getMonth()-1,1,12,0,0,0),endDate=new Date(now.getFullYear(),now.getMonth(),0,12,0,0,0);
-  return {valid:true,start:spendDayKey(startDate),end:spendDayKey(endDate),dayCount:endDate.getDate(),error:''};
- }
- if(range==='custom'){
-  const startDate=spendDayDate(from),endDate=spendDayDate(to);
-  if(!startDate||!endDate)return {valid:false,start:from,end:to,dayCount:0,error:'Choose both From and To dates.'};
-  if(from>to)return {valid:false,start:from,end:to,dayCount:0,error:'From must be on or before To.'};
-  const dayCount=Math.round((endDate-startDate)/86400000)+1;
-  return {valid:true,start:from,end:to,dayCount,error:''};
- }
- const dayCount=range==='today'?1:Number(range);
- const count=[1,7,30,90].includes(dayCount)?dayCount:7;
- return {valid:true,start:spendShiftDay(end,1-count),end,dayCount:count,error:''};
-}
-function spendPreviousWindow(window){
- const end=spendShiftDay(window.start,-1),start=spendShiftDay(end,1-window.dayCount);
- return {valid:true,start,end,dayCount:window.dayCount,error:''};
-}
-function spendCalendarRows(days,window){
- if(!window?.valid)return [];
- const byDay=new Map((days||[]).filter(row=>spendDayDate(row?.day)).map(row=>[row.day,row]));
- const rows=[];
- for(let day=window.start,guard=0;day&&day<=window.end&&guard<10000;day=spendShiftDay(day,1),guard++){
-  const source=byDay.get(day);
-  rows.push(source?{...source,cost:Number(source.cost||0),providers:source.providers||[],hasActivity:true}:{day,cost:0,providers:[],coverage:{},provenance:{},usage_basis:'unavailable',availability:{cost:true},hasActivity:false});
- }
- return rows;
-}
-function spendRuntimeKey(provider){
- const value=String(provider||'').toLowerCase().replace(/[^a-z0-9]/g,'');
- return SPEND_RUNTIME_ORDER.slice(0,-1).find(key=>value.includes(key))||'unknown';
-}
-function spendRuntimeIdentity(provider){
- const raw=String(provider||'unknown').trim()||'unknown',key=spendRuntimeKey(raw);
- return {id:key==='unknown'?`unknown:${raw.toLowerCase()}`:key,key,label:key==='unknown'&&raw.toLowerCase()!=='unknown'?raw:SPEND_RUNTIME_LABELS[key]};
-}
-function spendRuntimeTotals(rows){
- const totals=new Map();
- (rows||[]).forEach(day=>(day.providers||[]).forEach(provider=>{
-  const identity=spendRuntimeIdentity(provider.provider),current=totals.get(identity.id)||{...identity,cost:0,estimated:false,partial:false,unavailable:false};
-  current.cost+=Number(provider.cost||0);
-  current.estimated=current.estimated||['local_estimate','mixed'].includes(provider.usage_basis)||['local_estimate','mixed'].includes(provider.provenance?.usage_basis);
-  current.unavailable=current.unavailable||provider.availability?.cost===false;
-  current.partial=current.partial||provider.coverage?.cost?.complete===false||provider.availability?.cost===false;
-  totals.set(identity.id,current);
- }));
- return [...totals.values()].sort((a,b)=>SPEND_RUNTIME_ORDER.indexOf(a.key)-SPEND_RUNTIME_ORDER.indexOf(b.key)||a.label.localeCompare(b.label));
-}
-// Four equal axis divisions on a round step, so every tick reads as a plain number.
-function spendNiceMax(value){
- value=Math.max(0,Number(value)||0);
- if(!value||!Number.isFinite(value))return 1;
- const step=value*1.02/4,magnitude=10**Math.floor(Math.log10(step));
- const factor=[1,1.25,1.5,2,2.5,3,4,5,6,8,10].find(item=>(item!==1.25||magnitude>=10)&&item*magnitude>=step*(1-1e-12));
- return Math.max(1,Number((4*factor*magnitude).toPrecision(12)));
-}
-const SPEND_GRANULARITIES=['day','week','month'];
-function normalizeSpendGranularity(value){return SPEND_GRANULARITIES.includes(value)?value:'day';}
-function spendBucketStart(day,granularity){
- const date=spendDayDate(day);if(!date)return '';
- if(granularity==='week')date.setDate(date.getDate()-(date.getDay()+6)%7);
- else if(granularity==='month')date.setDate(1);
- return spendDayKey(date);
-}
-function spendBucketEnd(start,granularity){
- if(granularity==='week')return spendShiftDay(start,6);
- if(granularity==='month'){const date=spendDayDate(start);return date?spendDayKey(new Date(date.getFullYear(),date.getMonth()+1,0,12,0,0,0)):'';}
- return start;
-}
-function spendIsEstimated(row){return ['local_estimate','mixed'].includes(row?.usage_basis)||['local_estimate','mixed'].includes(row?.provenance?.usage_basis);}
-function spendBucketRows(rows,granularity,today=''){
- granularity=normalizeSpendGranularity(granularity);
- if(granularity==='day')return (rows||[]).map(row=>({...row,granularity,start:row.day,end:row.day,bucketStart:row.day,bucketEnd:row.day,days:1,fullDays:1,clipped:false,inProgress:row.day===today,incomplete:row.day===today}));
- const buckets=[],byKey=new Map();
- (rows||[]).forEach(row=>{
-  const key=spendBucketStart(row.day,granularity);if(!key)return;
-  let bucket=byKey.get(key);
-  if(!bucket){
-   const bucketEnd=spendBucketEnd(key,granularity);
-   bucket={day:row.day,granularity,start:row.day,end:row.day,bucketStart:key,bucketEnd,days:0,fullDays:Math.round((spendDayDate(bucketEnd)-spendDayDate(key))/86400000)+1,cost:0,providers:[],hasActivity:false,availability:{cost:true},coverage:{cost:{complete:true}},usage_basis:'',provenance:{}};
-   byKey.set(key,bucket);buckets.push(bucket);
-  }
-  bucket.end=row.day;bucket.days+=1;bucket.cost+=Number(row.cost||0);
-  bucket.providers.push(...(row.providers||[]));
-  if(!row.hasActivity)return;
-  bucket.hasActivity=true;
-  if(row.availability?.cost===false)bucket.availability.cost=false;
-  if(row.coverage?.cost?.complete===false)bucket.coverage.cost.complete=false;
-  if(spendIsEstimated(row))bucket.usage_basis='mixed';
- });
- return buckets.map(bucket=>{
-  const clipped=bucket.days<bucket.fullDays,inProgress=Boolean(today)&&bucket.start<=today&&today<=bucket.bucketEnd;
-  return {...bucket,clipped,inProgress,incomplete:clipped||inProgress};
- });
-}
-function spendGranularityOptions(rows,today=''){
- return Object.fromEntries(SPEND_GRANULARITIES.map(granularity=>{
-  if(granularity==='day')return [granularity,true];
-  const buckets=spendBucketRows(rows,granularity,today);
-  return [granularity,buckets.length>=2&&buckets.some(bucket=>!bucket.incomplete)];
- }));
-}
-function spendAutoGranularity(dayCount){return dayCount>186?'month':dayCount>35?'week':'day';}
-function spendResolveGranularity(choice,rows,today=''){
- const options=spendGranularityOptions(rows,today),order=['month','week','day'];
- const wanted=SPEND_GRANULARITIES.includes(choice)?choice:spendAutoGranularity((rows||[]).length);
- return {granularity:order.slice(order.indexOf(wanted)).find(granularity=>options[granularity])||'day',options};
-}
-function spendAverageBasis(buckets){
- return (buckets||[]).filter(row=>row.granularity==='day'||!row.incomplete);
-}
-function spendAverageReference(rows,axisMax){
- const costs=(rows||[]).map(row=>{const value=Number(row?.cost||0);return Number.isFinite(value)&&value>0?value:0;});
- if(!costs.length)return {value:0,ratio:0};
- const value=costs.reduce((sum,cost)=>sum+cost,0)/costs.length,max=Number(axisMax)||0;
- return {value,ratio:max>0?Math.min(1,Math.max(0,value/max)):0};
-}
-function spendDayNavigation(rows,focusDay=''){
- const days=(rows||[]).map(row=>row.day),resolved=days.includes(focusDay)?focusDay:(days.at(-1)||'');
- return {focusDay:resolved,buttons:days.map(day=>({day,tabIndex:day===resolved?0:-1,selected:false}))};
-}
-function spendSessionMetricValue(row,metric){
- let value=null;
- if(metric==='cost'&&row?.availability?.cost===true)value=Number(row.cost);
- else if(metric==='input'&&(row?.availability?.input_tokens===true||row?.availability?.tokens===true))value=Number(row.input_tokens);
- else if(metric==='executions'&&row?.turns!==null&&row?.turns!==undefined)value=Number(row.turns);
- else if(metric==='active'&&row?.duration_available===true)value=Number(row.duration_s);
- return Number.isFinite(value)&&value>=0?value:null;
-}
-function spendQuantile(values,quantile){
- const sorted=(values||[]).filter(value=>Number.isFinite(value)).slice().sort((a,b)=>a-b);
- if(!sorted.length)return 0;
- const position=(sorted.length-1)*quantile,lower=Math.floor(position),upper=Math.ceil(position),weight=position-lower;
- return sorted[lower]+(sorted[upper]-sorted[lower])*weight;
-}
-function spendDistribution(values){
- const clean=(values||[]).filter(value=>Number.isFinite(value));
- if(!clean.length)return {count:0,p10:0,p25:0,median:0,mean:0,p75:0,p90:0};
- return {count:clean.length,p10:spendQuantile(clean,.1),p25:spendQuantile(clean,.25),median:spendQuantile(clean,.5),mean:clean.reduce((sum,value)=>sum+value,0)/clean.length,p75:spendQuantile(clean,.75),p90:spendQuantile(clean,.9)};
-}
-function spendSessionAnalytics(rows){
- rows=rows||[];
- const coveredCosts=rows.map(row=>spendSessionMetricValue(row,'cost')).filter(value=>value!==null).sort((a,b)=>b-a),total=coveredCosts.reduce((sum,value)=>sum+value,0),topCount=coveredCosts.length?Math.ceil(coveredCosts.length*.1):0,topCost=coveredCosts.slice(0,topCount).reduce((sum,value)=>sum+value,0);
- return {
-  concentration:{covered:coveredCosts.length,total,top_count:topCount,top_cost:topCost,top_share:total?topCost/total:0},
-  distributions:{
-   cost:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'cost')).filter(value=>value!==null)),
-   input:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'input')).filter(value=>value!==null)),
-   executions:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'executions')).filter(value=>value!==null)),
-   active:spendDistribution(rows.map(row=>spendSessionMetricValue(row,'active')).filter(value=>value!==null)),
-  },
- };
-}
-function spendScatterRows(rows,metric){
- const valueMetric=metric==='input'?'input':'cost';
- return (rows||[]).filter(row=>{
-  const active=spendSessionMetricValue(row,'active'),value=spendSessionMetricValue(row,valueMetric);
-  return active!==null&&active>0&&value!==null&&value>=0;
- });
-}
-function normalizeSpendRangeChoice(value){return ['today','yesterday','7','30','90','month','last_month','all','custom'].includes(value)?value:'30';}
-// spend-range-logic-end
-const SPEND_RANGE_KEY='tm_spend_range_v1';
-const SPEND_SCATTER_METRIC_KEY='tm_spend_scatter_metric_v1';
-let spendGranularityChoice='auto',spendChartRows=[];
-let spendRangeChoice='30',spendCustomFrom='',spendCustomTo='',spendFocusDay='',spendInspectDay='',spendCurrentRows=[],spendCurrentWindow=null,spendCurrentSource=[],spendResizeTimer=0,spendLogsRequestKey='',spendLogsRenderedRange='',spendLogsRequestSeq=0,spendInsightPayload=null,spendInsightRenderKey='',spendScatterMetric=localStorage.getItem(SPEND_SCATTER_METRIC_KEY)==='input'?'input':'cost';
-try{
- const saved=JSON.parse(localStorage.getItem(SPEND_RANGE_KEY)||'{}');
- spendRangeChoice=normalizeSpendRangeChoice(saved.range);
- spendCustomFrom=String(saved.from||'');spendCustomTo=String(saved.to||'');
-}catch(error){}
-function persistSpendRange(){try{localStorage.setItem(SPEND_RANGE_KEY,JSON.stringify({range:spendRangeChoice,from:spendCustomFrom,to:spendCustomTo}));}catch(error){}}
-function openMonthSpend(){
- spendRangeChoice='month';spendGranularityChoice='auto';persistSpendRange();setHashRoute('spend');
-}
-$('current-month-spend').onclick=openMonthSpend;
-function spendRangeLabel(window){return window.dayCount===1?dayLabel(window.start):`${dayLabel(window.start)} – ${dayLabel(window.end)}`;}
-function spendPct(value){value=Number(value||0);return value>0&&value<.01?'<1%':pct(value);}
-function spendEvidence(rows){
- const active=rows.filter(row=>row.hasActivity),unavailable=active.some(row=>row.availability?.cost===false);
- const partial=active.some(row=>row.coverage?.cost?.complete===false||row.availability?.cost===false);
- const estimated=active.some(row=>['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis));
- return {active:active.length,unavailable,partial,estimated,allUnavailable:Boolean(active.length)&&active.every(row=>row.availability?.cost===false)};
-}
-function spendDayDetails(row){
- const runtimes=spendRuntimeTotals([row]),available=row.availability?.cost!==false,total=Number(row.cost||0);
- if(!row.hasActivity)return {totalText:money(0),note:'no recorded activity',runtimes};
- if(!available&&!total)return {totalText:'Unavailable',note:'recorded activity has no cost evidence',runtimes};
- const partial=row.coverage?.cost?.complete===false||!available,estimated=['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis);
- return {totalText:money(total),note:[partial?'partial coverage':'',estimated?'estimated':''].filter(Boolean).join(' · '),runtimes};
-}
-const SPEND_GRANULARITY_COPY={
- day:{unit:'day',total:'Daily total',note:'Line = average'},
- week:{unit:'wk',total:'Weekly total',note:'Line = average'},
- month:{unit:'mo',total:'Monthly total',note:'Line = average'},
-};
-function spendMonthLabel(day,style='long'){return new Date(`${day}T12:00:00`).toLocaleDateString([],style==='long'?{month:'long',year:'numeric'}:{month:'short'});}
-function spendBucketLabel(row){
- if(row.granularity==='week')return `Week of ${shortDayLabel(row.bucketStart)}`;
- if(row.granularity==='month')return spendMonthLabel(row.bucketStart);
- return dayLabel(row.day);
-}
-function spendBucketNote(row){
- if(row.granularity==='day')return row.inProgress?'today, still in progress':'';
- const unit=row.granularity==='week'?'week':'month';
- if(row.clipped)return `partial ${unit} · ${row.days} of ${row.fullDays} days in range${row.inProgress?' · in progress':''}`;
- return row.inProgress?`${unit} in progress`:'';
-}
-function spendDayAria(row){
- const details=spendDayDetails(row),parts=details.runtimes.filter(runtime=>runtime.cost>0||runtime.unavailable).map(runtime=>`${runtime.label} ${runtime.unavailable&&!runtime.cost?'cost unavailable':money(runtime.cost)}${runtime.estimated?' estimated':''}${runtime.partial?' partial':''}`),bucketNote=spendBucketNote(row);
- return `${spendBucketLabel(row)}, ${details.totalText}${details.note?`, ${details.note}`:''}${bucketNote?`, ${bucketNote}`:''}${parts.length?`, ${parts.join(', ')}`:''}`;
-}
-function spendAxisText(row,spansYears){
- if(row.granularity==='month'){const label=spendMonthLabel(row.bucketStart,'short');return spansYears||row.bucketStart.endsWith('-01-01')?`${label} ’${row.bucketStart.slice(2,4)}`:label;}
- return shortDayLabel(row.granularity==='week'?row.bucketStart:row.day);
-}
-function spendAxisLabel(row,index,count,chartWidth,spansYears=false){
- const maxLabels=Math.max(2,Math.floor(Math.max(1,chartWidth)/54));
- const step=Math.max(1,Math.ceil(Math.max(1,count-1)/Math.max(1,maxLabels-1)));
- return index===0||index===count-1||(index%step===0&&count-1-index>=step)?spendAxisText(row,spansYears):'';
-}
-function spendBarBody(row,index,count,axisMax,chartWidth,spansYears){
- const runtimes=spendRuntimeTotals([row]).filter(runtime=>runtime.cost>0),total=Number(row.cost||0),height=total?Math.max(1.5,100*total/axisMax):0;
- const segments=runtimes.map(runtime=>`<i class=spendStackSegment data-estimated="${runtime.estimated}" data-partial="${runtime.partial}" style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]};--segment-share:${total?100*runtime.cost/total:0}%"></i>`).join('');
- const axisLabel=spendAxisLabel(row,index,count,chartWidth,spansYears);
- return `<span class=spendDayTrack><span class="spendBarValue mono">${total?money(total):''}</span>${total?`<span class=spendDayStack style="--spend-height:${height}%">${segments}</span>`:''}</span><span class=spendDayLabel>${esc(axisLabel)}</span>`;
-}
-function renderSpendAxis(axisMax){
- const ticks=[1,.75,.5,.25,0].map(ratio=>`<span>${money(axisMax*ratio)}</span>`).join('');
- if($('s-y-axis')._spendTicks!==ticks){$('s-y-axis').innerHTML=ticks;$('s-y-axis')._spendTicks=ticks;}
-}
-function renderSpendAverage(rows,axisMax){
- const line=$('s-average-line'),reference=spendAverageReference(spendAverageBasis(rows),axisMax),track=$('s-chart-inner').querySelector('.spendDayTrack');
- if(!track||reference.value<=0){line.hidden=true;return;}
- const trackRect=track.getBoundingClientRect(),plotRect=line.parentElement.getBoundingClientRect(),unit=SPEND_GRANULARITY_COPY[rows[0]?.granularity||'day'].unit;
- const top=trackRect.top-plotRect.top+(1-reference.ratio)*trackRect.height,label=`avg ${money(reference.value)}/${unit}`;
- line.style.top=`${Math.round(top*10)/10}px`;line.hidden=false;
- const value=line.querySelector('span');if(value.textContent!==label)value.textContent=label;
-}
-function spendPaintNavigation(){
- const state=spendDayNavigation(spendChartRows,spendFocusDay);spendFocusDay=state.focusDay;
- [...$('s-chart-inner').querySelectorAll('[data-spend-day]')].forEach((button,index)=>{
-  const item=state.buttons[index];
-  button.classList.toggle('selected',Boolean(item?.selected));button.tabIndex=item?.tabIndex??-1;button.removeAttribute('aria-pressed');
- });
-}
-function updateSpendBar(button,row,index,count,axisMax,chartWidth,{peak=false,spansYears=false}={}){
- const edge=count>1?(index===0?'first':index===count-1?'last':''):'';
- button.dataset.spendDay=row.day;
- button.setAttribute('aria-label',spendDayAria(row));
- if(edge)button.dataset.axisEdge=edge;else delete button.dataset.axisEdge;
- button.dataset.peak=String(peak);if(peak&&index<=2)button.dataset.peakEdge='first';else if(peak&&index>=count-3)button.dataset.peakEdge='last';else delete button.dataset.peakEdge;
- button.dataset.incomplete=String(Boolean(row.incomplete));
- const body=spendBarBody(row,index,count,axisMax,chartWidth,spansYears);
- if(button._spendBody!==body){button.innerHTML=body;button._spendBody=body;}
-}
-function reconcileSpendBars(rows){
- const granularity=rows[0]?.granularity||'day',inner=$('s-chart-inner'),keys=`${granularity}:${rows.map(row=>row.day).join('|')}`,costs=rows.map(row=>Number(row.cost||0)),axisMax=spendNiceMax(Math.max(0,...costs)),chartWidth=Math.max(1,inner.clientWidth||$('s-chart').clientWidth||1);
- const existing=[...inner.querySelectorAll('[data-spend-day]')],same=inner.dataset.keys===keys&&existing.length===rows.length;
- const peakCost=Math.max(0,...costs),peakIndex=rows.length>1&&peakCost>0?costs.indexOf(peakCost):-1,spansYears=Boolean(rows.length)&&rows[0].bucketStart.slice(0,4)!==rows.at(-1).bucketStart.slice(0,4);
- inner.dataset.granularity=granularity;inner.dataset.dense=String(rows.length>45);inner.dataset.values=rows.length<=14?'shown':'hover';
- renderSpendAxis(axisMax);
- if(!same){
-  inner.innerHTML=rows.map(row=>`<button class=spendDay type=button data-spend-day="${esc(row.day)}"></button>`).join('');
-  inner.dataset.keys=keys;
- }
- [...inner.querySelectorAll('[data-spend-day]')].forEach((button,index)=>updateSpendBar(button,rows[index],index,rows.length,axisMax,chartWidth,{peak:index===peakIndex,spansYears}));
- renderSpendAverage(rows,axisMax);
- spendPaintNavigation();
-}
-function setSpendLogsHtml(html){
- const list=$('s-logs');
- if(list._spendHtml===html)return;
- const scrollTop=list.scrollTop;
- list.innerHTML=html;list._spendHtml=html;list.scrollTop=scrollTop;
-}
-function spendInsightMetricFormat(metric,value){
- if(metric==='cost')return money(value);
- if(metric==='input')return compactNumber(value);
- if(metric==='active')return waitFmt(value);
- const rounded=Math.round(Number(value||0)*10)/10;
- return Number.isInteger(rounded)?rounded.toLocaleString():rounded.toLocaleString(undefined,{maximumFractionDigits:1});
-}
-function spendShapeRow(metric,label,note,distribution,totalRows){
- if(!distribution.count)return `<div class=spendShapeRow><div class=spendShapeIdentity><b>${esc(label)}</b><small>${esc(note)}</small></div><div class=spendShapeCoverage>0 / ${f(totalRows)}</div><div class=spendShapeRail></div><div class=spendShapeValues><span data-label=P10>--</span><span data-label=Median>--</span><span data-label=Mean>--</span><span data-label=P90>--</span></div></div>`;
- const span=Math.max(.000001,distribution.p90-distribution.p10),position=value=>Math.max(0,Math.min(100,100*(value-distribution.p10)/span));
- const style=`--p25:${position(distribution.p25)}%;--p75:${position(distribution.p75)}%;--median:${position(distribution.median)}%;--mean:${position(distribution.mean)}%`;
- const format=value=>spendInsightMetricFormat(metric,value);
- return `<div class=spendShapeRow><div class=spendShapeIdentity><b>${esc(label)}</b><small>${esc(note)}</small></div><div class=spendShapeCoverage>${f(distribution.count)} / ${f(totalRows)}</div><div class=spendShapeRail style="${style}"><i class=spendShapeIqr></i><i class=spendShapeMedian title="Median ${esc(format(distribution.median))}"></i><i class=spendShapeMean title="Mean ${esc(format(distribution.mean))}"></i></div><div class=spendShapeValues><span data-label=P10 title="10th percentile">${esc(format(distribution.p10))}</span><span data-label=Median>${esc(format(distribution.median))}</span><span data-label=Mean>${esc(format(distribution.mean))}</span><span data-label=P90 title="90th percentile">${esc(format(distribution.p90))}</span></div></div>`;
-}
-function renderSpendShape(distributions,totalRows){
- $('s-shape').innerHTML=`<div class=spendShapeHeader><span>Measure</span><span>Coverage</span><span>Middle 50% · median / mean</span><span><i>P10</i><i>Median</i><i>Mean</i><i>P90</i></span></div>${spendShapeRow('cost','Period spend','selected range',distributions.cost,totalRows)}${spendShapeRow('input','Processed input','full session',distributions.input,totalRows)}${spendShapeRow('executions','Executions','full session',distributions.executions,totalRows)}${spendShapeRow('active','Active time','full session',distributions.active,totalRows)}`;
-}
-function spendScatterTipHtml(row){
- const selected=spendSessionMetricValue(row,spendScatterMetric),active=spendSessionMetricValue(row,'active'),estimated=['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis);
- return `<b title="${esc(row.title||'Untitled session')}">${esc(row.title||'Untitled session')}</b><span><em>${spendScatterMetric==='input'?'Processed input':'Period spend'}</em><strong class=mono>${esc(spendInsightMetricFormat(spendScatterMetric,selected))}${spendScatterMetric==='cost'&&estimated?' est':''}</strong></span><span><em>Active time</em><strong class=mono>${esc(waitFmt(active))}</strong></span><span><em>Executions</em><strong class=mono>${f(row.turns)}</strong></span><span><em>${esc(row.label||row.provider||'Runtime')}</em><strong>${esc(row.project||'No project')}</strong></span>`;
-}
-function hideSpendScatterTip(){$('s-scatter-tip').hidden=true;}
-function showSpendScatterTip(row,target,event){
- const tip=$('s-scatter-tip'),wrap=tip.parentElement,wrapRect=wrap.getBoundingClientRect(),targetRect=target.getBoundingClientRect();
- tip.innerHTML=spendScatterTipHtml(row);tip.hidden=false;
- const pointerX=event?.clientX||targetRect.left+targetRect.width/2,pointerY=event?.clientY||targetRect.top;
- tip.style.left=Math.max(6,Math.min(wrapRect.width-tip.offsetWidth-6,pointerX-wrapRect.left+12))+'px';
- tip.style.top=Math.max(6,Math.min(wrapRect.height-tip.offsetHeight-6,pointerY-wrapRect.top-tip.offsetHeight-10))+'px';
-}
-function drawSpendScatter(rows,analytics=spendSessionAnalytics(rows)){
- const svg=$('s-scatter-svg'),points=spendScatterRows(rows,spendScatterMetric),valueMetric=spendScatterMetric==='input'?'input':'cost',metricLabel=spendScatterMetric==='input'?'processed input':'selected-period spend';
- [...$('s-scatter-metric').querySelectorAll('[data-scatter-metric]')].forEach(button=>{const on=button.dataset.scatterMetric===spendScatterMetric;button.classList.toggle('on',on);button.setAttribute('aria-pressed',String(on));});
- $('s-scatter-coverage').textContent=`${f(points.length)} of ${f((rows||[]).length)} sessions plotted`;$('s-scatter-missing').hidden=points.length>=(rows||[]).length;
- svg.setAttribute('aria-label',`${metricLabel} by full-session active time for ${points.length} sessions. Each point opens the session.`);
- hideSpendScatterTip();
- const VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(270,Math.round(svg.clientHeight||340)),mobile=VW<560,ML=mobile?54:66,MR=mobile?18:28,MT=26,MB=48,PW=VW-ML-MR,PH=VH-MT-MB;
- svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- if(!points.length){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="12">No sessions have both ${esc(metricLabel)} and active-time evidence</text>`;return;}
- const xMax=Math.max(1,...points.map(row=>spendSessionMetricValue(row,'active'))),yMax=Math.max(1,...points.map(row=>spendSessionMetricValue(row,valueMetric))),xLog=Math.log1p(xMax),yLog=Math.log1p(yMax),x=value=>ML+PW*Math.log1p(value)/xLog,y=value=>MT+PH-PH*Math.log1p(value)/yLog;
- let html='';
- for(let index=0;index<=4;index++){
-  const ratio=index/4,gx=ML+PW*ratio,gy=MT+PH-PH*ratio,xValue=Math.expm1(xLog*ratio),yValue=Math.expm1(yLog*ratio);
-  html+=`<line x1="${gx}" x2="${gx}" y1="${MT}" y2="${MT+PH}" stroke="${CHART.grid}"/><line x1="${ML}" x2="${ML+PW}" y1="${gy}" y2="${gy}" stroke="${CHART.grid}"/><text x="${gx}" y="${VH-24}" text-anchor="middle" fill="${CHART.lbl}" font-size="11">${esc(waitFmt(xValue))}</text><text x="${ML-8}" y="${gy+3}" text-anchor="end" fill="${CHART.lbl}" font-size="11">${esc(spendInsightMetricFormat(valueMetric,yValue))}</text>`;
- }
- const activeMedian=analytics.distributions.active.median,valueMedian=analytics.distributions[valueMetric].median;
- if(activeMedian>0)html+=`<line x1="${x(activeMedian)}" x2="${x(activeMedian)}" y1="${MT}" y2="${MT+PH}" stroke="${tint('signal',.52)}" stroke-dasharray="4 5"/><text x="${Math.min(ML+PW-4,x(activeMedian)+5)}" y="${MT+11}" fill="${CHART.lbl}" font-size="11">median time</text>`;
- if(valueMedian>0)html+=`<line x1="${ML}" x2="${ML+PW}" y1="${y(valueMedian)}" y2="${y(valueMedian)}" stroke="${tint('signal',.52)}" stroke-dasharray="4 5"/><text x="${ML+5}" y="${Math.max(MT+10,y(valueMedian)-5)}" fill="${CHART.lbl}" font-size="11">median</text>`;
- const ranked=(rows||[]).filter(row=>spendSessionMetricValue(row,'cost')!==null).slice().sort((a,b)=>spendSessionMetricValue(b,'cost')-spendSessionMetricValue(a,'cost')),topIds=new Set(ranked.slice(0,analytics.concentration.top_count).map(sessionRowKey));
- points.slice().sort((a,b)=>Number(topIds.has(sessionRowKey(a)))-Number(topIds.has(sessionRowKey(b)))).forEach(row=>{
-  const active=spendSessionMetricValue(row,'active'),value=spendSessionMetricValue(row,valueMetric),runtime=spendRuntimeKey(row.provider),top=topIds.has(sessionRowKey(row)),label=`Open ${row.title||'untitled session'}: ${spendInsightMetricFormat(valueMetric,value)} ${metricLabel}, ${waitFmt(active)} active time`;
-  html+=`<a class=spendScatterLink href="${esc(sessionRoute(sessionRowKey(row)))}" data-spend-insight-session="${esc(sessionRowKey(row))}" aria-label="${esc(label)}"><circle class=spendScatterPoint cx="${x(active)}" cy="${y(value)}" r="${top?6.5:5.5}" style="fill:${SPEND_RUNTIME_COLORS[runtime]}" fill-opacity="${top ? .92 : .7}" stroke="${top?'var(--signal-hi)':CHART.ink}" stroke-width="${top?2.5:1.5}" vector-effect="non-scaling-stroke"><title>${esc(label)}</title></circle></a>`;
- });
- html+=`<text x="${ML}" y="13" fill="${CHART.lbl}" font-size="11">${esc(metricLabel)}</text><text x="${ML+PW/2}" y="${VH-6}" text-anchor="middle" fill="${CHART.lbl}" font-size="11">full-session active time · log scale</text>`;
- svg.innerHTML=html;
- [...svg.querySelectorAll('[data-spend-insight-session]')].forEach(link=>{
-  const row=points.find(item=>sessionRowKey(item)===link.dataset.spendInsightSession);
-  link.onpointerenter=event=>showSpendScatterTip(row,link,event);link.onpointermove=event=>showSpendScatterTip(row,link,event);link.onpointerleave=hideSpendScatterTip;link.onfocus=()=>showSpendScatterTip(row,link);link.onblur=hideSpendScatterTip;
- });
-}
-function renderSpendSessionInsights(payload,window){
- $('s-insights-range').textContent=spendRangeLabel(window);
- if(payload?.loading||payload?.error){
-  const statusKey=`${window.start}|${window.end}|${payload?.error||'loading'}`;spendInsightPayload=null;if(statusKey===spendInsightRenderKey)return;spendInsightRenderKey=statusKey;$('s-concentration').textContent='--';$('s-concentration-note').textContent=payload?.error||'Loading range evidence…';$('s-concentration-bar').querySelector('i').style.width='0%';$('s-concentration-bar').setAttribute('aria-valuenow','0');$('s-concentration-sessions').innerHTML='';$('s-shape').innerHTML=`<div class="spendShapeEmpty emptyState">${esc(payload?.error||'Loading session distributions…')}</div>`;drawSpendScatter([]);return;
- }
- spendInsightPayload=payload;
- const rows=payload?.sessions||[],renderKey=`${window.start}|${window.end}|`+rows.map(row=>[row.id,row.title,row.project,row.cost,row.input_tokens,row.turns,row.duration_s,row.duration_available,row.duration_basis,row.usage_basis,row.availability?.cost,row.availability?.input_tokens].join('~')).join('|');
- if(renderKey===spendInsightRenderKey)return;
- spendInsightRenderKey=renderKey;
- const focused=document.activeElement?.closest?.('[data-spend-insight-session]'),focusedId=focused?.dataset.spendInsightSession||'',focusedScatter=Boolean(focused?.closest?.('#s-scatter-svg')),analytics=spendSessionAnalytics(rows),concentration=analytics.concentration,share=concentration.top_share;
- $('s-concentration').textContent=concentration.covered?spendPct(share):'--';
- $('s-concentration-note').textContent=concentration.covered?`${f(concentration.top_count)} of ${f(concentration.covered)} cost-covered ${countWord(concentration.covered,'session')} account for ${money(concentration.top_cost)} of ${money(concentration.total)}.${rows.some(hasLocalEstimate)?' Includes local estimates.':''}`:'No cost-covered sessions in this period.';
- $('s-concentration-bar').querySelector('i').style.width=Math.max(0,Math.min(100,100*share))+'%';$('s-concentration-bar').setAttribute('aria-valuenow',String(Math.round(100*share)));
- const topRows=rows.filter(row=>spendSessionMetricValue(row,'cost')!==null).slice().sort((a,b)=>spendSessionMetricValue(b,'cost')-spendSessionMetricValue(a,'cost')).slice(0,Math.min(3,concentration.top_count));
- $('s-concentration-sessions').innerHTML=topRows.map(row=>{const cost=spendSessionMetricValue(row,'cost'),estimated=['local_estimate','mixed'].includes(row.usage_basis)||['local_estimate','mixed'].includes(row.provenance?.usage_basis);return `<button class=spendImpactRow data-spend-insight-session="${esc(sessionRowKey(row))}" type=button title="Open ${esc(row.title||'Untitled session')}"><span class=spendImpactName>${esc(row.title||'Untitled session')}</span><span class=spendImpactValue><b class=mono>${money(cost)}${estimated?' est':''}</b><small>${spendPct(concentration.total?cost/concentration.total:0)} of covered spend</small></span></button>`;}).join('');
- renderSpendShape(analytics.distributions,rows.length);drawSpendScatter(rows,analytics);
- if(focusedId)requestAnimationFrame(()=>{const root=focusedScatter?$('s-scatter-svg'):$('s-concentration-sessions'),target=[...root.querySelectorAll('[data-spend-insight-session]')].find(element=>element.dataset.spendInsightSession===focusedId);target?.focus({preventScroll:true});});
-}
-function renderSpendLogs(payload,window){
- const rows=payload?.sessions||[],rangeTotal=Number(payload?.total_cost||0);
- $('s-log-day').textContent=spendRangeLabel(window);
- renderSpendSessionInsights(payload,window);
- if(payload?.loading){$('s-log-count').textContent='';setSpendLogsHtml('<div class="spendLogEmpty emptyState">Loading range logs…</div>');return;}
- if(payload?.error){$('s-log-count').textContent='';setSpendLogsHtml(`<div class="spendLogEmpty emptyState">${esc(payload.error)}</div>`);return;}
- $('s-log-count').textContent=`${f(rows.length)} logs`;
- if(!rows.length){setSpendLogsHtml('<div class="spendLogEmpty emptyState">No spend-contributing logs in this range.</div>');return;}
- const maxCost=Math.max(.001,...rows.map(row=>Number(row.cost||0)));
- setSpendLogsHtml(rows.map((row,index)=>{
-  const available=metricAvailable(row,'cost'),estimated=hasLocalEstimate(row),cost=Number(row.cost||0),share=available&&rangeTotal?pct(cost/rangeTotal):'0%',days=Math.max(1,Number(row.active_days)||1);
-  return `<div class=spendLogRow><div class=spendLogRank>${index+1}</div><div class=spendLogMain><div class=spendLogName title="${esc(row.title||'Untitled session')}">${esc(row.title||'Untitled session')}</div><div class=spendLogMeta>${esc(row.project||'No project')} · ${esc(row.label||row.provider||'Unknown runtime')} · ${f(days)} ${countWord(days,'day')}${estimated?' · local est':''}</div><div class=spendLogTrack><i style="width:${available?100*cost/maxCost:0}%"></i></div></div><div class=spendLogValue><strong class=mono>${costValueHtml(money(cost)+estimateSuffix(row),available)}</strong><span>${available?`${share} of range spend`:'cost unavailable'}</span></div><button class=tbtn data-spend-session="${esc(sessionRowKey(row))}" type=button>Open</button></div>`;
- }).join(''));
-}
-function loadSpendLogs(window,generatedAt){
- const rangeKey=`${window.start}|${window.end}`,requestKey=`${rangeKey}|${generatedAt||0}`;
- if(requestKey===spendLogsRequestKey)return;
- spendLogsRequestKey=requestKey;
- const request=++spendLogsRequestSeq;
- if(rangeKey!==spendLogsRenderedRange)renderSpendLogs({loading:true},window);
- fetch(`/spend/logs?from=${encodeURIComponent(window.start)}&to=${encodeURIComponent(window.end)}`,{cache:'no-store'}).then(response=>{
-  if(!response.ok)throw new Error(`Range logs could not be loaded (${response.status}).`);
-  return response.json();
- }).then(payload=>{
-  if(request!==spendLogsRequestSeq)return;
-  if(!payload?.ok)throw new Error(payload?.error||'Range logs could not be loaded.');
-  spendLogsRenderedRange=rangeKey;renderSpendLogs(payload,window);
- }).catch(error=>{
-  if(request!==spendLogsRequestSeq)return;
-  spendLogsRequestKey='';spendLogsRenderedRange=rangeKey;renderSpendLogs({error:error.message||String(error)},window);
- });
-}
-function hideSpendTip(){
- spendInspectDay='';$('s-chart-tip').hidden=true;
-}
-function showSpendTip(day,button=$('s-chart-inner').querySelector(`[data-spend-day="${day}"]`)){
- const row=spendChartRows.find(item=>item.day===day),tip=$('s-chart-tip');
- if(!row||!button){hideSpendTip();return;}
- spendInspectDay=day;
- const details=spendDayDetails(row),total=Number(row.cost||0),note=[details.note,spendBucketNote(row)].filter(Boolean).join(' · ');
- const span=row.granularity==='day'?'':`<div class=spendTipSpan>${esc(row.start===row.end?dayLabel(row.start):`${shortDayLabel(row.start)} – ${shortDayLabel(row.end)}`)}</div>`;
- const shownRuntimes=details.runtimes.filter(runtime=>runtime.cost>0||runtime.unavailable),runtimeRows=shownRuntimes.length?shownRuntimes.map(runtime=>`<div class=spendTipRuntime style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]}"><span><i></i>${esc(runtime.label)}</span><b class=mono>${costValueHtml(money(runtime.cost),!(runtime.unavailable&&!runtime.cost))}</b><small>${runtime.unavailable?'unavailable':total?spendPct(runtime.cost/total):'0%'}${runtime.estimated?' · est':''}${runtime.partial?' · partial':''}</small></div>`).join(''):'<div class=spendTipEmpty>No runtime spend recorded.</div>';
- const html=`<div class=spendTipDate>${esc(spendBucketLabel(row))}</div>${span}<div class=spendTipTotal><span>${SPEND_GRANULARITY_COPY[row.granularity].total}</span><b class=mono>${esc(details.totalText)}</b></div>${note?`<div class=spendTipNote>${esc(note)}</div>`:''}<div class=spendTipRuntimes>${runtimeRows}</div>`;
- if(tip._spendHtml!==html){tip.innerHTML=html;tip._spendHtml=html;}
- tip.hidden=false;
- const card=tip.closest('.spendChartCard'),barRect=button.getBoundingClientRect(),cardRect=card.getBoundingClientRect();
- const left=Math.max(8,Math.min(cardRect.width-tip.offsetWidth-8,barRect.left-cardRect.left+barRect.width/2-tip.offsetWidth/2));
- tip.style.left=`${left}px`;tip.style.top=`${Math.max(8,Math.min(cardRect.height-tip.offsetHeight-8,Math.max(54,barRect.top-cardRect.top-tip.offsetHeight-8)))}px`;
-}
-function selectSpendDay(day,{focus=false}={}){
- if(!spendChartRows.some(row=>row.day===day))return;
- spendFocusDay=day;spendPaintNavigation();
- const button=$('s-chart-inner').querySelector(`[data-spend-day="${day}"]`);
- if(focus)button?.focus();
-}
-function renderSpend(xs){
- const source=xs?.spend?.days||xs?.daily||[],today=spendDayKey(new Date()),availableDays=source.map(row=>row.day).filter(day=>spendDayDate(day)).sort();
- const earliest=availableDays[0]||today;
- let window=spendRangeWindow(spendRangeChoice,spendCustomFrom,spendCustomTo,new Date(),earliest);
- const savedCustomInvalid=spendRangeChoice==='custom'&&(!window.valid||window.start<earliest||window.end>today);
- if(savedCustomInvalid){spendRangeChoice='30';spendGranularityChoice='auto';window=spendRangeWindow('30');persistSpendRange();}
- spendCurrentSource=source;spendCurrentWindow=window;spendCurrentRows=spendCalendarRows(source,window);
- $('s-range').value=spendRangeChoice;
- $('s-custom').hidden=spendRangeChoice!=='custom';
- ['s-from','s-to'].forEach(id=>{$(id).min=earliest;$(id).max=today;});
- if(!$('s-range-error').textContent){$('s-from').value=spendCustomFrom;$('s-to').value=spendCustomTo;}
-	 const rows=spendCurrentRows,total=rows.reduce((sum,row)=>sum+Number(row.cost||0),0),dailyAverage=window.dayCount?total/window.dayCount:0,evidence=spendEvidence(rows),runtimeTotals=spendRuntimeTotals(rows),topRuntime=runtimeTotals.reduce((best,row)=>!best||row.cost>best.cost?row:best,null),highest=rows.reduce((best,row)=>!best||Number(row.cost||0)>Number(best.cost||0)?row:best,null);
- const rangeText=spendRangeLabel(window),periodUnavailable=evidence.allUnavailable&&!total;
- const periodDiscount=source.filter(row=>row.day>=window.start&&row.day<=window.end).reduce((sum,row)=>sum+Number(row.discount_usd||0),0);
- setCostValue('s-total',money(total),!periodUnavailable);
- $('s-total-note').textContent=periodUnavailable?'Cost unavailable for recorded activity':`${rangeText} · ${periodDiscount>0?`Estimate after discounts · list ${money(total+periodDiscount)}`:'API-equivalent estimate'}${evidence.partial?' · lower bound':''}`;
-	 setCostValue('s-average',money(dailyAverage),!periodUnavailable);
- const previousWindow=spendPreviousWindow(window),previousRows=spendCalendarRows(source,previousWindow),previousEvidence=source.some(row=>row.day>=previousWindow.start&&row.day<=previousWindow.end),previousCoverage=spendEvidence(previousRows),previousTotal=previousRows.reduce((sum,row)=>sum+Number(row.cost||0),0);
- $('s-average-note').textContent=periodUnavailable?'Daily average unavailable':previousEvidence&&!evidence.partial&&!previousCoverage.partial?`${dailyDeltaLabel(total,previousTotal)} vs preceding ${window.dayCount}d`:`${window.dayCount} calendar ${countWord(window.dayCount,'day')}${evidence.partial||previousCoverage.partial?' · comparison withheld for partial coverage':''}`;
- $('s-top-runtime').textContent=periodUnavailable?'Unavailable':topRuntime&&topRuntime.cost?topRuntime.label:'No spend';
- $('s-top-runtime-note').textContent=topRuntime&&topRuntime.cost?`${money(topRuntime.cost)} · ${spendPct(total?topRuntime.cost/total:0)}${topRuntime.estimated?' · est':''}${topRuntime.partial?' · partial':''}`:evidence.active?'No covered runtime cost':'No recorded activity';
- $('s-highest-day').textContent=periodUnavailable?'Unavailable':highest&&highest.cost?shortDayLabel(highest.day):'No spend';
- $('s-highest-day-note').textContent=highest&&highest.cost?`${money(highest.cost)} · ${dayLabel(highest.day)}`:evidence.active?'No covered daily cost':'No recorded activity';
- const visibleRuntimes=runtimeTotals.filter(runtime=>runtime.cost||runtime.unavailable);
- $('s-legend').innerHTML=visibleRuntimes.map(runtime=>`<span style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]}"><i></i>${esc(runtime.label)}</span>`).join('')+(visibleRuntimes.some(runtime=>runtime.estimated)?'<span class=spendEstimateKey><i></i>Local estimate</span>':'')+(evidence.partial?'<span class=spendPartialKey><i></i>Partial coverage</span>':'');
- const {granularity,options:granularityOptions}=spendResolveGranularity(spendGranularityChoice,rows,today);
- [...$('s-granularity').querySelectorAll('[data-spend-granularity]')].forEach(button=>{
-  const value=button.dataset.spendGranularity,on=value===granularity;
-  button.classList.toggle('on',on);button.setAttribute('aria-pressed',String(on));button.setAttribute('aria-disabled',String(!granularityOptions[value]));
-  button.title=granularityOptions[value]?'':`Needs a range with at least two ${value}s, one of them complete`;
- });
- $('s-chart-note').textContent=SPEND_GRANULARITY_COPY[granularity].note;
- spendChartRows=spendBucketRows(rows,granularity,today);
- if(spendChartRows.some(row=>row.incomplete&&row.hasActivity))$('s-legend').insertAdjacentHTML('beforeend',`<span class=spendIncompleteKey><i></i>${granularity==='day'?'In progress':'Partial or in progress'}</span>`);
- reconcileSpendBars(spendChartRows);
-	 $('s-chart').setAttribute('aria-label',`${rangeText}. ${periodUnavailable?'Spend unavailable':`${money(total)} estimated spend, daily average ${money(dailyAverage)}`}${evidence.partial?', partial coverage':''}. Use arrow keys to inspect ${granularity}s.`);
- $('s-platforms').innerHTML=visibleRuntimes.length?`<div class=spendPlatformRows>${visibleRuntimes.map(runtime=>`<div class=spendPlatformRow style="--spend-color:${SPEND_RUNTIME_COLORS[runtime.key]}"><div class=spendPlatformName><i></i><span>${esc(runtime.label)}</span></div><div class=spendPlatformTrack><i style="width:${total?100*runtime.cost/total:0}%"></i></div><div class="spendPlatformValue mono">${costValueHtml(money(runtime.cost),!(runtime.unavailable&&!runtime.cost))}<span>${runtime.unavailable?'unavailable':total?spendPct(runtime.cost/total):'0%'}${runtime.estimated?' · est':''}${runtime.partial?' · partial':''}</span></div></div>`).join('')}</div>`:`<div class="spendEmpty emptyState">${evidence.active?'Recorded activity has no runtime cost evidence.':'No spend recorded in this range.'}</div>`;
- loadSpendLogs(window,xs?.generated_at);
- const hovered=$('s-chart-inner').querySelector('.spendDay:hover');
- if(hovered)showSpendTip(hovered.dataset.spendDay,hovered);else hideSpendTip();
-}
-function validateSpendCustomDraft(){
- const from=$('s-from').value,to=$('s-to').value,window=spendRangeWindow('custom',from,to),earliest=spendCurrentSource.map(row=>row.day).filter(day=>spendDayDate(day)).sort()[0]||spendDayKey(new Date()),today=spendDayKey(new Date());
- let error=window.error;
- if(window.valid&&from<earliest)error=`From cannot be earlier than ${dayLabel(earliest)}.`;
- if(window.valid&&to>today)error='To cannot be later than today.';
- const valid=!error;
- $('s-range-error').textContent=error;['s-from','s-to'].forEach(id=>$(id).setAttribute('aria-invalid',String(!valid)));
- if(!valid)return;
- spendCustomFrom=from;spendCustomTo=to;spendRangeChoice='custom';spendGranularityChoice='auto';persistSpendRange();renderSpend(LATEST?.xsession);
-}
-$('s-range').onchange=event=>{
- const range=normalizeSpendRangeChoice(event.target.value);
- $('s-range-error').textContent='';['s-from','s-to'].forEach(id=>$(id).setAttribute('aria-invalid','false'));
- if(range==='custom'){
-  const fallback=spendCurrentWindow?.valid?spendCurrentWindow:spendRangeWindow('30');
-  if(!spendCustomFrom)spendCustomFrom=fallback.start;if(!spendCustomTo)spendCustomTo=fallback.end;
- }
- spendRangeChoice=range;spendGranularityChoice='auto';persistSpendRange();if(LATEST)renderSpend(LATEST.xsession);
-};
-$('s-from').onchange=validateSpendCustomDraft;$('s-to').onchange=validateSpendCustomDraft;
-$('s-granularity').onclick=event=>{
- const button=event.target.closest('[data-spend-granularity]');if(!button||button.getAttribute('aria-disabled')==='true')return;
- spendGranularityChoice=normalizeSpendGranularity(button.dataset.spendGranularity);
- hideSpendTip();if(LATEST)renderSpend(LATEST.xsession);
-};
-function handleSpendInspect(event){
- const button=event.target.closest('[data-spend-day]');if(!button)return;
- if(spendInspectDay===button.dataset.spendDay&&!$('s-chart-tip').hidden)return;
- showSpendTip(button.dataset.spendDay,button);
-}
-$('s-chart-inner').addEventListener('pointerover',handleSpendInspect);
-$('s-chart-inner').addEventListener('pointerleave',hideSpendTip);
-$('s-chart-inner').onclick=event=>{const button=event.target.closest('[data-spend-day]');if(button)selectSpendDay(button.dataset.spendDay,{focus:true});};
-$('s-logs').onclick=event=>{const button=event.target.closest('[data-spend-session]');if(button)selectSession(button.dataset.spendSession);};
-$('s-scatter-metric').onclick=event=>{const button=event.target.closest('[data-scatter-metric]');if(!button)return;spendScatterMetric=button.dataset.scatterMetric==='input'?'input':'cost';localStorage.setItem(SPEND_SCATTER_METRIC_KEY,spendScatterMetric);drawSpendScatter(spendInsightPayload?.sessions||[]);};
-function openSpendInsightSession(event){const button=event.target.closest('[data-spend-insight-session]');if(!button)return;event.preventDefault();selectSession(button.dataset.spendInsightSession);}
-$('s-concentration-sessions').onclick=openSpendInsightSession;$('s-scatter-svg').onclick=openSpendInsightSession;
-$('s-chart-inner').onkeydown=event=>{
- if(!['ArrowLeft','ArrowRight','Home','End','Escape'].includes(event.key))return;
- if(event.key==='Escape'){hideSpendTip();return;}
- event.preventDefault();const buttons=[...$('s-chart-inner').querySelectorAll('[data-spend-day]')],current=event.target.closest('[data-spend-day]'),index=Math.max(0,buttons.indexOf(current));
- const next=event.key==='Home'?0:event.key==='End'?buttons.length-1:Math.max(0,Math.min(buttons.length-1,index+(event.key==='ArrowRight'?1:-1)));
- if(buttons[next])selectSpendDay(buttons[next].dataset.spendDay,{focus:true});
-};
-// Pixel-viewBox charts redraw when their box changes (resize, or first shown after a hidden render)
-// so text and marks stay undistorted. Redrawing sets viewBox to the box, so this settles.
-let chartResizeTimer=0;
-const PIXEL_CHARTS={spend:['s-scatter-svg'],git:['d-daily-chart'],models:['m-chart','m-mix','m-speedchart-svg'],goals:['goals-trend-chart'],efficiency:['e-output-dollar-chart','e-reasoning-chart','e-context-load-chart','e-cache-hit-chart'],session:['iochart']};
-const chartViewBoxStale=id=>{const svg=$(id);if(!svg||!svg.clientWidth||!svg.clientHeight)return false;const box=svg.viewBox.baseVal;return Math.abs(box.width-Math.round(svg.clientWidth))>1||Math.abs(box.height-Math.round(svg.clientHeight))>1;};
-const chartResizeObserver=new ResizeObserver(()=>{
- clearTimeout(chartResizeTimer);
- chartResizeTimer=setTimeout(()=>{
-  if(activeModelStats&&activeModelScope===modelProject&&PIXEL_CHARTS.models.some(chartViewBoxStale))renderModelStats(activeModelStats);
-  if(activeEfficiencyStats&&activeEfficiencyScope===efficiencyProject&&PIXEL_CHARTS.efficiency.some(chartViewBoxStale))renderEfficiency(activeEfficiencyStats);
-  if(CURRENT&&PIXEL_CHARTS.session.some(chartViewBoxStale))drawIO(CURRENT.series||[]);
-  if(spendInsightPayload&&PIXEL_CHARTS.spend.some(chartViewBoxStale))drawSpendScatter(spendInsightPayload.sessions||[]);
-  if(deliveryPayload&&PIXEL_CHARTS.git.some(chartViewBoxStale))drawDeliveryChart(deliveryPayload.days||[]);
-  if(goalDetailData&&PIXEL_CHARTS.goals.some(chartViewBoxStale))drawGoalTrend();
- },120);
-});
-Object.values(PIXEL_CHARTS).flat().forEach(id=>{const svg=$(id);if(svg)chartResizeObserver.observe(svg);});
-// spectrum-motion-v1: motion that explains a change, never on poll redraws or keyboard-only paths.
-const motionAllowed=()=>!pageSignalReducedMotionQuery.matches&&!document.hidden;
-const CHART_REVEAL_IDS=Object.values(PIXEL_CHARTS).flat();
-const chartsRevealedThisVisit=new Set();
-function revealChart(svg){
- if(!svg||chartsRevealedThisVisit.has(svg.id)||!svg.childElementCount||!svg.getClientRects().length)return;
- chartsRevealedThisVisit.add(svg.id);
- if(!motionAllowed()||!svg.animate)return;
- // Time runs left to right, so the series draws in that direction.
- svg.animate([{clipPath:'inset(0 100% 0 0)'},{clipPath:'inset(0 0 0 0)'}],{duration:560,easing:cssVar('--ease-in-out')});
-}
-const chartRevealObserver=new MutationObserver(records=>records.forEach(record=>revealChart(record.target)));
-CHART_REVEAL_IDS.forEach(id=>{const svg=$(id);if(svg)chartRevealObserver.observe(svg,{childList:true});});
-let motionRouteView=null;
-function playRouteMotion(view){
- if(view===motionRouteView)return;
- motionRouteView=view;
- chartsRevealedThisVisit.clear();
- CHART_REVEAL_IDS.forEach(id=>revealChart($(id)));
- if(!view||view.dataset.entered)return;
- view.dataset.entered='1';
- if(!motionAllowed())return;
- [...view.children].forEach((child,index)=>child.style.setProperty('--enter-i',String(Math.min(index,6))));
- view.classList.add('viewEnter');
- setTimeout(()=>view.classList.remove('viewEnter'),900);
-}
-const READOUT_SELECTOR=':is(.metric>.v,.metric>strong,.metric>b,.previewCost,.previewKpi .v,.budgetSpendValue,.efficiencyHeadline .v,.ov .v,.stat .v)';
-const READOUT_PATTERN=/^([$<≈~]?)(\d[\d,]*(?:\.\d+)?)(\s?[A-Za-z%]{0,3})$/;
-const READOUT_MIN_SHARE=.01,READOUT_QUIET_MS=10000;
-const readoutText=new WeakMap(),readoutTweens=new WeakMap(),readoutLastTween=new WeakMap();
-function parseReadout(text){
- const match=READOUT_PATTERN.exec(String(text).trim());
- if(!match)return null;
- return {prefix:match[1],suffix:match[3],value:Number(match[2].replace(/,/g,'')),decimals:(match[2].split('.')[1]||'').length,grouped:match[2].includes(',')};
-}
-function formatReadout(shape,value){
- return shape.prefix+value.toLocaleString('en-US',{minimumFractionDigits:shape.decimals,maximumFractionDigits:shape.decimals,useGrouping:shape.grouped})+shape.suffix;
-}
-function tweenReadout(element,fromText,toText){
- // Placeholders mean unavailable evidence: they switch instantly instead of counting up from a fake zero.
- const to=parseReadout(toText),from=parseReadout(fromText);
- if(!to||!from||from.prefix!==to.prefix||from.suffix!==to.suffix||from.value===to.value)return;
- // Live ticks stay quiet: only a meaningful change counts, at most once per element every 10s.
- if(Math.abs(to.value-from.value)<READOUT_MIN_SHARE*Math.max(Math.abs(from.value),Math.abs(to.value)))return;
- const now=performance.now();
- if(now-(readoutLastTween.get(element)??-Infinity)<READOUT_QUIET_MS)return;
- readoutLastTween.set(element,now);
- const started=now,duration=parseFloat(cssVar('--dur-data'))||480;
- const step=now=>{
-  if(readoutTweens.get(element)!==step)return;
-  const progress=Math.min(1,(now-started)/duration),eased=1-Math.pow(1-progress,3);
-  const text=progress>=1?toText:formatReadout(to,from.value+(to.value-from.value)*eased);
-  readoutText.set(element,text);
-  element.textContent=text;
-  if(progress<1)requestAnimationFrame(step);else readoutTweens.delete(element);
- };
- readoutTweens.set(element,step);
- requestAnimationFrame(step);
-}
-// Readouts count toward their new value so the size of a change is visible, not just its result.
-const readoutObserver=new MutationObserver(records=>{
- records.forEach(record=>{
-  const element=record.type==='characterData'?record.target.parentElement:record.target;
-  if(!element?.matches?.(READOUT_SELECTOR))return;
-  const next=element.textContent,previous=readoutText.get(element);
-  if(next===previous)return;
-  readoutText.set(element,next);
-  readoutTweens.delete(element);
-  if(previous===undefined||element.childElementCount||!motionAllowed()||element.closest('[aria-live]')||!element.getClientRects().length)return;
-  tweenReadout(element,previous,next);
- });
-});
-document.querySelectorAll(READOUT_SELECTOR).forEach(element=>readoutText.set(element,element.textContent));
-readoutObserver.observe(document.body,{subtree:true,childList:true,characterData:true});
-window.addEventListener('resize',()=>{
- clearTimeout(spendResizeTimer);
- spendResizeTimer=setTimeout(()=>{
-  if(!$('view-daily').classList.contains('on')||!spendChartRows.length)return;
-  reconcileSpendBars(spendChartRows);
-  const hovered=$('s-chart-inner').querySelector('.spendDay:hover');
-  if(hovered)showSpendTip(hovered.dataset.spendDay,hovered);else hideSpendTip();
-  if(spendInsightPayload)drawSpendScatter(spendInsightPayload.sessions||[]);
- },100);
-});
-
-
-function deliveryProjectName(value){return String(value||'').split(' · ')[0]||'Local project';}
-function deliveryPercent(value){
- const number=Number(value);
- return Number.isFinite(number)?`${Math.abs(number).toFixed(Math.abs(number)>=10?0:1)}%`:'';
-}
-function deliveryComparisonText(comparison){
- const code=Number(comparison?.code_pushed_pct),intensity=Number(comparison?.spend_per_1k_pct);
- if(!comparison?.available||!Number.isFinite(code)||!Number.isFinite(intensity))return 'No comparable prior period';
- const codeText=Math.abs(code)<.05?'the same code volume':`${deliveryPercent(code)} ${code>0?'more':'less'} code`;
- const costText=Math.abs(intensity)<.05?'unchanged cost intensity':`${deliveryPercent(intensity)} ${intensity<0?'lower':'higher'} cost intensity`;
- return `<span>${esc(codeText)}</span><span class=deliveryComparisonDivider aria-hidden=true>&middot;</span><span>${esc(costText)}</span>`;
-}
-function deliveryRatio(value){
- if(value===null||value===undefined||value==='')return '--';
- const number=Number(value);
- if(!Number.isFinite(number))return '--';
- if(number>=1000)return compactNumber(number);
- return number.toFixed(number>=10?1:2).replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');
-}
-function deliveryMultiple(value){
- const number=Number(value);
- return Number.isFinite(number)?`${number.toFixed(number>=10?0:1)}×`:'--';
-}
-function deliveryQuantile(sorted,share){
- if(!sorted.length)return null;
- if(sorted.length===1)return sorted[0];
- const position=(sorted.length-1)*share,lower=Math.floor(position),upper=Math.ceil(position);
- return lower===upper?sorted[lower]:sorted[lower]+(sorted[upper]-sorted[lower])*(position-lower);
-}
-function deliveryDistribution(values){
- const sorted=(values||[]).map(Number).filter(value=>Number.isFinite(value)).sort((a,b)=>a-b);
- if(!sorted.length)return null;
- return {count:sorted.length,min:sorted[0],max:sorted[sorted.length-1],p25:deliveryQuantile(sorted,.25),median:deliveryQuantile(sorted,.5),p75:deliveryQuantile(sorted,.75)};
-}
-function deliveryShapeRange(distribution){
- if(!distribution)return null;
- const stable=distribution.count>=5;
- return {label:stable?'Middle half':'Observed range',low:stable?distribution.p25:distribution.min,high:stable?distribution.p75:distribution.max};
-}
-const DELIVERY_MIN_RATIO_LINES=50;
-const DELIVERY_SHAPE_METRICS=[
- {key:'spend_per_1k',label:'Spend / 1K',format:value=>money(value)},
- {key:'changed_lines',label:'Lines / push day',format:value=>compactNumber(value)},
- {key:'delivery_yield',label:'Push yield',format:value=>deliveryRatio(value)},
-];
-function deliveryRatioDay(row){
- return (Number(row?.comparable_changed_lines)||0)>=DELIVERY_MIN_RATIO_LINES;
-}
-function deliveryIntensityDays(payload){
- const days=Array.isArray(payload?.days)?payload.days:[];
- return days.filter(row=>row?.availability?.spend_per_1k===true&&deliveryRatioDay(row)&&Number.isFinite(Number(row.spend_per_1k)));
-}
-function deliveryDaySeries(payload,key){
- const days=Array.isArray(payload?.days)?payload.days:[];
- if(key==='changed_lines')return days.filter(row=>row?.availability?.code_pushed===true&&(Number(row.changed_lines)||0)>0).map(row=>Number(row.changed_lines));
- if(key==='delivery_yield')return days.filter(row=>row?.efficiency?.availability?.delivery_yield===true&&deliveryRatioDay(row)).map(row=>Number(row.efficiency.delivery_yield));
- return deliveryIntensityDays(payload).map(row=>Number(row.spend_per_1k));
-}
-function deliveryShapeRows(payload){
- return DELIVERY_SHAPE_METRICS.map(metric=>({...metric,distribution:deliveryDistribution(deliveryDaySeries(payload,metric.key))}));
-}
-function deliverySignals(payload){
- const overall=payload?.overall||{},comparison=payload?.comparison||{},coverage=payload?.coverage||{};
- const days=Array.isArray(payload?.days)?payload.days:[],available=overall?.availability||{};
- const efficiency=overall?.efficiency||{},efficiencyAvailable=efficiency?.availability||{};
- const rows=[];
- const intensityChange=Number(comparison?.spend_per_1k_pct),codeChange=Number(comparison?.code_pushed_pct);
- if(comparison?.available===true&&Number.isFinite(intensityChange)&&Number.isFinite(codeChange)){
-  const flat=Math.abs(intensityChange)<.05;
-  rows.push({key:'intensity_trend',kind:'neutral',priority:10,
-   title:flat?'Cost intensity held steady':`Cost intensity ${intensityChange<0?'fell':'rose'} ${deliveryPercent(intensityChange)}`,
-   text:''});
- }
- const yieldValue=Number(efficiency?.delivery_yield),yieldChange=Number(comparison?.delivery_yield_pct);
- if(efficiencyAvailable?.delivery_yield===true&&Number.isFinite(yieldValue)){
-  const known=Number.isFinite(yieldChange);
-  rows.push({key:'push_yield',kind:'neutral',priority:20,
-   title:`${deliveryRatio(yieldValue)} pushed lines per 1K output tokens`,
-   text:known?'':'No prior period to compare.'});
- }
- const intensityDays=deliveryIntensityDays(payload);
- if(intensityDays.length>=4){
-  const distribution=deliveryDistribution(intensityDays.map(row=>Number(row.spend_per_1k)));
-  const peak=intensityDays.reduce((top,row)=>Number(row.spend_per_1k)>Number(top.spend_per_1k)?row:top);
-  const multiple=distribution.median>0?Number(peak.spend_per_1k)/distribution.median:null;
-	  if(multiple&&multiple>=1.6)rows.push({key:'peak_day',kind:'warn',priority:30,action:'day',value:peak.day,
-	   title:`${deliveryDateLabel(peak.day)}: ${deliveryMultiple(multiple)} the typical Spend / 1K`,
-	   text:`${money(peak.spend_per_1k)} vs a ${money(distribution.median)} median over ${distribution.count} ${countWord(distribution.count,'day')}.`});
- }
- const quiet=days.filter(row=>Number(row?.covered_cost)>0&&(Number(row?.changed_lines)||0)===0);
- if(quiet.length&&days.length){
-  const quietCost=quiet.reduce((total,row)=>total+(Number(row.covered_cost)||0),0);
-  rows.push({key:'quiet_days',kind:quiet.length>=Math.max(2,Math.round(days.length*.4))?'warn':'neutral',priority:35,
-   title:`${quiet.length} of ${days.length} ${countWord(days.length,'day')} had spend but no pushes`,
-   text:`${money(quietCost)} spent. Work may land in a later push.`});
- }
- const added=Number(overall?.added),deleted=Number(overall?.deleted),changed=Number(overall?.changed_lines);
- if(available?.code_pushed===true&&Number.isFinite(changed)&&changed>0&&Number.isFinite(deleted)&&Number.isFinite(added)){
-  rows.push({key:'deleted_share',kind:'neutral',priority:40,
-   title:`${deliveryPercent(100*deleted/changed)} of pushed lines were deletions`,
-   text:`${f(added)} added, ${f(deleted)} deleted. Normal editing, not defects.`});
- }
- const projectRows=Array.isArray(payload?.project_rows)?payload.project_rows:[];
- const costed=projectRows.filter(row=>row?.availability?.cost===true&&Number(row?.covered_cost)>0);
- if(costed.length>1){
-  const total=costed.reduce((sum,row)=>sum+Number(row.covered_cost),0);
-  const top=costed.reduce((best,row)=>Number(row.covered_cost)>Number(best.covered_cost)?row:best);
-  const share=total>0?Number(top.covered_cost)/total:0;
-	  if(share>=.6)rows.push({key:'concentration',kind:'neutral',priority:50,action:'project',value:top.project,
-	   title:`${deliveryPercent(100*share)} of covered spend sits in ${deliveryProjectName(top.project)}`,
-	   text:`${money(top.covered_cost)} of ${money(total)} across ${costed.length} ${countWord(costed.length,'project')}.`});
- }
- const selectedCount=Number(coverage?.selected_repositories)||0,comparable=Number(coverage?.comparable_repositories)||0;
- if(selectedCount&&comparable<selectedCount){
-	  rows.push({key:'coverage',kind:'neutral',priority:60,action:'coverage',value:'',
-	   title:`${comparable} of ${selectedCount} ${countWord(selectedCount,'project')} have both spend and Git`,
-	   text:'Ratios use only these; the rest may shift them.'});
- }
- const ranked=rows.sort((left,right)=>left.priority-right.priority||left.key.localeCompare(right.key));
- const coverageRow=ranked.find(row=>row.key==='coverage');
- if(!coverageRow)return ranked.slice(0,5);
-	 return ranked.filter(row=>row.key!=='coverage').slice(0,4).concat(coverageRow);
-}
-function deliveryProjectEvidence(row){
- const cost=row?.availability?.cost===true,code=row?.availability?.code_pushed===true;
- if(cost&&code)return {key:'comparable',label:'Comparable',detail:'Spend + Git'};
- if(cost)return {key:'spend_only',label:'Spend only',detail:'Git unavailable'};
- if(code)return {key:'git_only',label:'Git only',detail:'Spend unavailable'};
- return {key:'unavailable',label:'No period evidence',detail:'Spend + Git unavailable'};
-}
-function deliveryFilteredProjectRows(rows,filter=deliveryEvidenceFilter){
- const normalized=DELIVERY_EVIDENCE_FILTERS.includes(filter)?filter:'all';
- return (rows||[]).filter(row=>normalized==='all'||deliveryProjectEvidence(row).key===normalized);
-}
-function selectDeliveryProject(project){
- const projects=Array.isArray(deliveryPayload?.projects)?deliveryPayload.projects:[];
- if(!projects.includes(project))return;
-	 deliveryProject=project;deliverySelectedDay='';deliveryEvidenceFilter='all';localStorage.setItem('tm_delivery_project',deliveryProject);
- const select=$('d-project');if(select)select.value=deliveryProject;
- loadDelivery();
-}
-function deliverySortValue(row,key){
- if(key==='project')return deliveryProjectName(row?.project).toLowerCase();
- const value=Number(row?.[key]);
- if(key==='changed_lines'&&row?.availability?.code_pushed!==true)return null;
- if(key==='covered_cost'&&row?.availability?.cost!==true)return null;
- if(key==='spend_per_1k'&&row?.availability?.spend_per_1k!==true)return null;
- return Number.isFinite(value)?value:null;
-}
-function sortedDeliveryRows(rows){
- const direction=deliverySort.direction==='asc'?1:-1;
- return [...(rows||[])].sort((left,right)=>{
-  const a=deliverySortValue(left,deliverySort.key),b=deliverySortValue(right,deliverySort.key);
-  if(a===null&&b===null)return deliveryProjectName(left.project).localeCompare(deliveryProjectName(right.project));
-  if(a===null)return 1;if(b===null)return -1;
-  const compared=typeof a==='string'?a.localeCompare(b):a-b;
-  return compared?compared*direction:deliveryProjectName(left.project).localeCompare(deliveryProjectName(right.project));
- });
-}
-function renderDeliveryTable(rows){
-	 rows=rows||[];
-	 const visible=deliveryFilteredProjectRows(rows),body=$('d-project-table').querySelector('tbody'),sorted=sortedDeliveryRows(visible);
-	 const totalCost=rows.filter(row=>row?.availability?.cost===true).reduce((total,row)=>total+(Number(row.covered_cost)||0),0);
-	 const evidenceCounts={comparable:0,spend_only:0,git_only:0,unavailable:0};
-	 rows.forEach(row=>{evidenceCounts[deliveryProjectEvidence(row).key]++;});
-	 const evidenceSelect=$('d-evidence-filter');
-	 if(evidenceSelect){
-	  const labels={all:'All projects',comparable:'Comparable',spend_only:'Spend only',git_only:'Git only',unavailable:'No period evidence'};
-	  [...evidenceSelect.options].forEach(option=>{const count=option.value==='all'?rows.length:evidenceCounts[option.value];option.textContent=`${labels[option.value]} (${count})`;});
-	  evidenceSelect.value=deliveryEvidenceFilter;
-	 }
-	 body.innerHTML=sorted.length?sorted.map(row=>{
-	  const codeAvailable=row?.availability?.code_pushed===true,costAvailable=row?.availability?.cost===true,ratioAvailable=row?.availability?.spend_per_1k===true;
-	  const project=deliveryProjectName(row.project);
-	  const cost=Number(row.covered_cost)||0,share=costAvailable&&totalCost>0?Math.max(0,Math.min(100,100*cost/totalCost)):0;
-	  const shareBar=costAvailable&&totalCost>0?`<span class=deliverySpendShare style="--share:${share.toFixed(2)}" title="${esc(`${deliveryPercent(share)} of covered spend in this period`)}"><i aria-hidden=true></i></span>`:'';
-	  const added=Number(row.added)||0,deleted=Number(row.deleted)||0,changed=added+deleted;
-	  const composition=codeAvailable&&changed>0?`<span class=deliveryComposition title="${esc(`${f(added)} added · ${f(deleted)} deleted`)}"><i aria-hidden=true style="width:${(100*added/changed).toFixed(2)}%"></i><i class=deleted aria-hidden=true style="width:${(100*deleted/changed).toFixed(2)}%"></i></span>`:'';
-	  return `<tr><td title="${esc(row.project)}" data-label="Project"><button class=deliveryProjectLink type=button data-delivery-project="${esc(row.project)}">${esc(project)}</button></td><td class=num data-label="Spend">${costAvailable?money(cost):'--'}${shareBar}</td><td class="num mono" data-label="Pushed lines">${codeAvailable?f(row.changed_lines):'--'}${composition}</td><td class="num mono" data-label="Spend / 1K">${ratioAvailable?money(row.spend_per_1k):'--'}</td></tr>`;
-	 }).join(''):'<tr><td colspan=4><div class="deliveryEmpty emptyState">No projects match this filter.</div></td></tr>';
-	 body.querySelectorAll('[data-delivery-project]').forEach(button=>button.addEventListener('click',()=>selectDeliveryProject(button.dataset.deliveryProject)));
- $('d-project-table').querySelectorAll('th').forEach(header=>{
-  const button=header.querySelector('[data-delivery-sort]'),active=button?.dataset.deliverySort===deliverySort.key;
-  header.setAttribute('aria-sort',active?(deliverySort.direction==='asc'?'ascending':'descending'):'none');
-  const mark=button?.querySelector('.deliverySortMark');if(mark)mark.textContent=active?(deliverySort.direction==='asc'?'↑':'↓'):'';
- });
- const mobileSort=$('d-mobile-sort'),mobileChoice=`${deliverySort.key}:${deliverySort.direction}`;
- if(mobileSort&&[...mobileSort.options].some(option=>option.value===mobileChoice))mobileSort.value=mobileChoice;
-}
-function deliveryModelSortValue(row,key){
- if(key==='model')return String(row?.model||'').toLowerCase();
- const value=row?.[key];
- if(value===null||value===undefined)return null;
- const number=Number(value);
- return Number.isFinite(number)?number:null;
-}
-function sortedDeliveryModelRows(rows){
- const direction=deliveryModelSort.direction==='asc'?1:-1;
- return [...(rows||[])].sort((left,right)=>{
-  const a=deliveryModelSortValue(left,deliveryModelSort.key),b=deliveryModelSortValue(right,deliveryModelSort.key);
-  if(a===null&&b===null)return String(left.model).localeCompare(String(right.model));
-  if(a===null)return 1;if(b===null)return -1;
-  const compared=typeof a==='string'?a.localeCompare(b):a-b;
-  return compared?compared*direction:String(left.model).localeCompare(String(right.model));
- });
-}
-function renderDeliveryModelTable(rows,coverage){
- rows=Array.isArray(rows)?rows:[];
- const body=$('d-model-table').querySelector('tbody'),sorted=sortedDeliveryModelRows(rows);
- const comparableLines=Number(coverage?.comparable_lines)||0,attributedLines=Number(coverage?.attributed_lines)||0;
- $('d-model-note').textContent=coverage?.available?`${f(attributedLines)} / ${f(comparableLines)} lines attributed${coverage?.truncated?' · top 50':''}`:'No model lines in this period.';
- body.innerHTML=sorted.length?sorted.map(row=>`<tr><td data-label="Model"><div class=modelName title="${esc(row.model)}">${esc(row.model)}</div></td><td data-label="App">${esc(row.runtime||'unknown runtime')}</td><td data-label="Effort">${esc(modelEffortLabel(row))}</td><td class="num mono" data-label="Spend">${money(Number(row.covered_cost)||0)}</td><td class="num mono" data-label="Est. lines">${f(Math.round(Number(row.attributed_lines)||0))}</td></tr>`).join(''):`<tr><td colspan=5><div class="deliveryEmpty emptyState">${comparableLines>0?'No model spend in comparable projects.':'Needs a project with both pushes and spend.'}</div></td></tr>`;
- $('d-model-table').querySelectorAll('th').forEach(header=>{
-  const button=header.querySelector('[data-delivery-model-sort]'),active=button?.dataset.deliveryModelSort===deliveryModelSort.key;
-  header.setAttribute('aria-sort',active?(deliveryModelSort.direction==='asc'?'ascending':'descending'):'none');
-  const mark=button?.querySelector('.deliverySortMark');if(mark)mark.textContent=active?(deliveryModelSort.direction==='asc'?'↑':'↓'):'';
- });
-}
-function deliveryDateLabel(day,compact=false){
- const date=new Date(`${day}T12:00:00`);
- if(Number.isNaN(date.getTime()))return day;
- return date.toLocaleDateString(undefined,compact?{weekday:'short'}:{month:'short',day:'numeric'});
-}
-function deliveryFreshnessLabel(timestamp){
- const value=Number(timestamp),date=new Date(value*1000);
- if(!value||Number.isNaN(date.getTime()))return 'Git scan pending.';
- return `Last Git scan ${date.toLocaleString(undefined,{month:'short',day:'numeric',hour:'numeric',minute:'2-digit'})}`;
-}
-function setDeliveryEvidencePanel(open){
- const panel=$('d-evidence-panel'),trigger=$('d-coverage');if(!panel||!trigger)return;
- panel.hidden=!open;trigger.setAttribute('aria-expanded',open?'true':'false');
- if(open)panel.scrollIntoView({block:'nearest'});
-}
-function setDeliveryEvidenceFilter(filter,{scroll=true}={}){
- deliveryEvidenceFilter=DELIVERY_EVIDENCE_FILTERS.includes(filter)?filter:'all';
- renderDeliveryTable(deliveryPayload?.project_rows||[]);
- if(scroll)$('d-project-table')?.scrollIntoView({block:'start'});
-}
-function setDeliveryEvidenceRatio(text,detail){
- const ratio=$('d-evidence-ratio');ratio.textContent=text;ratio.dataset.tip=detail;ratio.setAttribute('aria-description',detail);
-}
-function renderDeliveryEvidence(payload){
- const coverage=payload?.coverage||{},rows=Array.isArray(payload?.project_rows)?payload.project_rows:[];
- const counts={comparable:0,spend_only:0,git_only:0,unavailable:0};
- rows.forEach(row=>{counts[deliveryProjectEvidence(row).key]++;});
- const spendCoverage=Number(coverage.spend_coverage),available=coverage.spend_coverage!==null&&coverage.spend_coverage!==undefined&&Number.isFinite(spendCoverage);
- $('d-evidence-spend').textContent=available?`${Math.round(100*Math.max(0,Math.min(1,spendCoverage)))}%`:'--';
- $('d-evidence-count-comparable').textContent=f(counts.comparable);
- $('d-evidence-count-spend').textContent=f(counts.spend_only);
- $('d-evidence-count-git').textContent=f(counts.git_only);
- $('d-evidence-count-unavailable').textContent=f(counts.unavailable);
- const selected=Number(coverage.selected_repositories)||rows.length,comparable=Number(coverage.comparable_repositories)||0;
- const ratioDetail=selected?`${comparable} of ${selected} ${countWord(selected,'project')} can compare ratios; every ratio on this page uses only that overlap.`:'No selected projects have period evidence yet.';
- setDeliveryEvidenceRatio(selected?`${comparable} / ${selected} comparable`:'No comparable projects',ratioDetail);
- $('d-evidence-freshness').textContent=deliveryFreshnessLabel(coverage.last_checked);
-}
-function deliveryCommitsMeasured(row){
- const value=row?.commits;
- return typeof value==='number'&&Number.isFinite(value)&&value>=0;
-}
-function renderDeliveryDayInspector(row,index,rows){
- const inspector=$('d-day-inspector');if(!inspector)return;
- const ratioAvailable=row?.availability?.spend_per_1k===true,rollingAvailable=row?.availability?.rolling_spend_per_1k===true,costAvailable=row?.availability?.cost===true,codeAvailable=row?.availability?.code_pushed===true;
- const lowVolume=ratioAvailable&&(Number(row?.comparable_changed_lines)||0)<DELIVERY_MIN_RATIO_LINES;
- $('d-day-title').textContent=deliveryDateLabel(row.day);
- $('d-day-note').textContent=lowVolume?'Under 50 lines · ratio is noisy.':'';
- const dayCommitsAvailable=codeAvailable&&deliveryCommitsMeasured(row);
- $('d-day-metrics').innerHTML=`<div class="deliveryDayMetric metric"><span>Pushed lines</span><b>${codeAvailable?f(row.changed_lines):'--'}</b></div><div class="deliveryDayMetric metric"><span>Commits</span><b>${dayCommitsAvailable?f(row.commits):'--'}</b></div><div class="deliveryDayMetric metric"><span>Covered spend</span><b>${costAvailable?money(row.covered_cost):'--'}</b></div><div class="deliveryDayMetric metric"><span>Day spend / 1K</span><b>${ratioAvailable?money(row.spend_per_1k):'--'}</b></div><div class="deliveryDayMetric metric"><span>7-day spend / 1K</span><b>${rollingAvailable?money(row.rolling_spend_per_1k):'--'}</b></div>`;
- $('d-day-prev').disabled=index<=0;$('d-day-next').disabled=index>=rows.length-1;
- inspector.hidden=false;
-}
-function selectAdjacentDeliveryDay(offset){
- const rows=deliveryPayload?.days||[],index=rows.findIndex(row=>row.day===deliverySelectedDay),next=index+offset;
- if(index<0||next<0||next>=rows.length)return;
- selectDeliveryDay(rows[next].day);
-}
-function dismissGitChartInspector(){
- deliverySelectedDay='';
- const tip=$('d-chart-tip');if(tip)tip.hidden=true;
- $('d-chart-hits')?.querySelectorAll('button[aria-pressed=true]').forEach(button=>button.setAttribute('aria-pressed','false'));
- const inspector=$('d-day-inspector');if(inspector)inspector.hidden=true;
-}
-function hideDeliveryChartTip(){
- const tip=$('d-chart-tip');if(tip)tip.hidden=true;
-}
-function selectDeliveryDay(day,button){
- const rows=deliveryPayload?.days||[],index=rows.findIndex(row=>row.day===day);
- if(index<0)return;
- deliverySelectedDay=day;
- const row=rows[index];
- const tip=$('d-chart-tip');
-	 tip.innerHTML=`<strong>${esc(deliveryDateLabel(day))}</strong><div class=deliveryTipRow><span>Pushed lines</span><b>${f(row.changed_lines)}</b></div><div class=deliveryTipRow><span>Added</span><b>+${f(row.added)}</b></div><div class=deliveryTipRow><span>Deleted</span><b>-${f(row.deleted)}</b></div><div class=deliveryTipRow><span>Commits</span><b>${deliveryCommitsMeasured(row)?f(row.commits):'--'}</b></div>`;
- const width=$('d-daily-chart')?.viewBox?.baseVal?.width||1040,count=Math.max(1,rows.length),{left,right}=DELIVERY_CHART_INSET,center=100*(left+((width-left-right)/count)*(index+.5))/width;
- tip.style.left=`${Math.max(11,Math.min(89,center)).toFixed(2)}%`;tip.style.top='66px';tip.hidden=false;
-	 $('d-chart-hits').querySelectorAll('button').forEach(item=>item.setAttribute('aria-pressed',item.dataset.deliveryDay===day?'true':'false'));
-	 renderDeliveryDayInspector(row,index,rows);
- if(button?.focus&&document.activeElement===button)button.scrollIntoView({block:'nearest',inline:'nearest'});
-}
-function selectDeliveryDayFromPointer(day,button){
- if(deliveryIgnorePointerSelection)return;
- selectDeliveryDay(day,button);
-}
-const DELIVERY_CHART_INSET={left:58,right:40,top:38,bottom:40};
-function drawDeliveryChart(rows){
- rows=Array.isArray(rows)?rows:[];
- const svg=$('d-daily-chart'),hits=$('d-chart-hits'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(200,Math.round(svg.clientHeight||310));
- svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
-	 if(!rows.length){svg.innerHTML=`<text class=axis x=${Math.round(VW/2)} y=${Math.round(VH/2)} text-anchor=middle>No Git evidence in this period</text>`;hits.innerHTML='';dismissGitChartInspector();return;}
- const left=DELIVERY_CHART_INSET.left,right=VW-DELIVERY_CHART_INSET.right,barTop=DELIVERY_CHART_INSET.top,barBottom=VH-DELIVERY_CHART_INSET.bottom,plotWidth=right-left;
- const lineMax=Math.max(1,...rows.map(row=>Number(row.changed_lines)||0));
- const step=plotWidth/Math.max(rows.length,1);
- const x=index=>left+step*(index+.5);
- const barWidth=Math.max(3,Math.min(34,step*.42));
- const labelEvery=Math.max(1,Math.ceil(rows.length/7));
- let markup='';
- [0,.5,1].forEach(share=>{const y=barBottom-share*(barBottom-barTop),value=lineMax*share;markup+=`<line class=grid x1=${left} y1=${y} x2=${right} y2=${y} /><text class=axis x=${left-9} y=${y+3} text-anchor=end>${esc(compactNumber(value))}</text>`;});
- rows.forEach((row,index)=>{
-  const center=x(index),added=Number(row.added)||0,deleted=Number(row.deleted)||0,total=Math.max(0,added+deleted),height=total/lineMax*(barBottom-barTop),deletedHeight=total?height*(deleted/total):0,addedHeight=height-deletedHeight;
-  if(deletedHeight>0)markup+=`<rect class=deleted x=${(center-barWidth/2).toFixed(1)} y=${(barBottom-deletedHeight).toFixed(1)} width=${barWidth.toFixed(1)} height=${deletedHeight.toFixed(1)} rx=1 />`;
-  if(addedHeight>0)markup+=`<rect class=added x=${(center-barWidth/2).toFixed(1)} y=${(barBottom-height).toFixed(1)} width=${barWidth.toFixed(1)} height=${addedHeight.toFixed(1)} rx=2 />`;
-  if(index%labelEvery===0||index===rows.length-1)markup+=`<text class=axis x=${center.toFixed(1)} y=${VH-11} text-anchor=middle>${esc(deliveryDateLabel(row.day,rows.length<=7))}</text>`;
- });
- svg.innerHTML=markup;
- hits.style.left=`${left}px`;hits.style.right=`${VW-right}px`;hits.style.top=`${barTop}px`;hits.style.bottom='9px';hits.style.setProperty('--delivery-days',rows.length);
- hits.innerHTML=rows.map(row=>`<button type=button data-delivery-day="${esc(row.day)}" aria-pressed=false aria-label="${esc(`${deliveryDateLabel(row.day)}, ${f(row.changed_lines)} pushed text lines, ${f(row.added)} added and ${f(row.deleted)} deleted`)}"></button>`).join('');
- hits.querySelectorAll('button').forEach(button=>{
-  button.addEventListener('pointerenter',()=>selectDeliveryDayFromPointer(button.dataset.deliveryDay,button));
-  button.addEventListener('focus',()=>selectDeliveryDay(button.dataset.deliveryDay,button));
-  button.addEventListener('click',()=>selectDeliveryDay(button.dataset.deliveryDay,button));
- });
-	 if(deliverySelectedDay&&rows.some(row=>row.day===deliverySelectedDay))selectDeliveryDay(deliverySelectedDay);else dismissGitChartInspector();
-}
-function renderDeliverySignals(payload){
- const list=$('d-signals'),rows=deliverySignals(payload);
-	 list.innerHTML=rows.length?rows.map(row=>{
-	  const body=`<i aria-hidden=true></i><div class=deliverySignalBody><b>${esc(row.title)}</b>${row.text?`<span>${esc(row.text)}</span>`:''}</div>`;
-	  const classes=`deliverySignal ${row.kind==='warn'?'warn':row.kind==='good'?'good':''}`;
-	  return row.action?`<button class="${classes}" type=button data-delivery-signal-action="${esc(row.action)}" data-delivery-signal-value="${esc(row.value||'')}">${body}</button>`:`<div class="${classes}">${body}</div>`;
-	 }).join(''):'<div class="deliverySignalEmpty emptyState">No overlapping Git and spend in this period.</div>';
-	 list.querySelectorAll('[data-delivery-signal-action]').forEach(button=>button.addEventListener('click',event=>{
-	  event.stopPropagation();
-	  const action=button.dataset.deliverySignalAction,value=button.dataset.deliverySignalValue;
-	  if(action==='day'){deliveryIgnorePointerSelection=true;$('d-chart-wrap')?.scrollIntoView({block:'center'});selectDeliveryDay(value);}
-	  else if(action==='project')selectDeliveryProject(value);
-	  else if(action==='coverage')setDeliveryEvidencePanel(true);
-	 }));
-}
-function renderDeliveryShape(payload){
- const host=$('d-shape'),rows=deliveryShapeRows(payload);
- if(!rows.some(row=>row.distribution)){host.innerHTML='<div class="deliveryShapeEmpty emptyState">No daily data in this period.</div>';return;}
- const header='<div class=deliveryShapeHeader><span></span><span></span><span><span>Median</span><span>Range</span><span>High</span></span></div>';
- host.innerHTML=header+rows.map(row=>{
-  const distribution=row.distribution;
-  if(!distribution)return `<div class=deliveryShapeRow><span class=deliveryShapeIdentity><b>${esc(row.label)}</b><small>No data</small></span><span class=deliveryShapeRail></span><span class=deliveryShapeValues><span>--</span><span>--</span><span>--</span></span></div>`;
-  const range=deliveryShapeRange(distribution),stable=range.label==='Middle half';
-  const fence=stable?Math.max(distribution.p75+1.5*(distribution.p75-distribution.p25),distribution.median*1.25,distribution.p75):distribution.max;
-  const span=Math.min(distribution.max,fence)||1,beyond=stable&&distribution.max>span*1.0001;
-  const percent=value=>`${Math.max(0,Math.min(100,100*value/span)).toFixed(2)}%`;
-  const rail=`<span class=deliveryShapeRail role=img aria-label="${esc(`${row.label}: median ${row.format(distribution.median)}, ${range.label.toLowerCase()} ${row.format(range.low)} to ${row.format(range.high)}, high day ${row.format(distribution.max)}${beyond?' beyond the rail scale':''} across ${distribution.count} ${countWord(distribution.count,'day')}`)}"><i class=deliveryShapeIqr style="--p25:${percent(range.low)};--p75:${percent(range.high)}"></i><i class=deliveryShapeMedian style="--median:${percent(distribution.median)}"></i><i class="deliveryShapeHigh${beyond?' beyond':''}" style="--p90:${percent(distribution.max)}"></i></span>`;
-  return `<div class=deliveryShapeRow><span class=deliveryShapeIdentity><b>${esc(row.label)}</b><small>${distribution.count} ${countWord(distribution.count,'day')} · ${esc(range.label.toLowerCase())}</small></span>${rail}<span class=deliveryShapeValues><span data-label="Median">${esc(row.format(distribution.median))}</span><span data-label="${esc(range.label)}">${esc(`${row.format(range.low)}–${row.format(range.high)}`)}</span><span data-label="High day">${esc(row.format(distribution.max))}</span></span></div>`;
- }).join('');
-}
-document.addEventListener('click',event=>{
- const target=event.target instanceof Element?event.target:null;
-	 if(!target?.closest('#d-chart-wrap')&&!target?.closest('#d-day-inspector'))dismissGitChartInspector();
-});
-document.addEventListener('pointermove',()=>{deliveryIgnorePointerSelection=false;},{passive:true});
-document.addEventListener('keydown',event=>{
- if(event.key==='Escape')dismissGitChartInspector();
-});
-function renderDelivery(payload){
- deliveryPayload=payload||{};
- const projects=Array.isArray(payload?.projects)?payload.projects:[],select=$('d-project');
- const selected=projects.includes(deliveryProject)?deliveryProject:'';
- if(selected!==deliveryProject){deliveryProject=selected;localStorage.setItem('tm_delivery_project',deliveryProject);}
- select.innerHTML='<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(deliveryProjectName(project))}</option>`).join('');select.value=deliveryProject;
- const rangeSelect=$('d-range');rangeSelect.value=deliveryRange;
- $('d-period-label').textContent=rangeSelect.selectedOptions[0]?.textContent||'Selected period';
- const overall=payload?.overall||{},available=overall?.availability||{},coverage=payload?.coverage||{};
- $('d-code-pushed').textContent=available.code_pushed===true?compactNumber(overall.changed_lines):'--';
- $('d-added').textContent=available.code_pushed===true?`+${f(overall.added)}`:'--';
- $('d-deleted').textContent=available.code_pushed===true?`-${f(overall.deleted)}`:'--';
- $('d-spend-lines').textContent=available.spend_per_1k===true?money(overall.spend_per_1k):'--';
- $('d-spend-note').innerHTML=available.cost===true?`<b>${money(overall.covered_cost)}</b> covered spend`:'Waiting for coverage.';
- const efficiency=overall?.efficiency||{},yieldAvailable=efficiency?.availability?.delivery_yield===true;
- // The Git service compares month-to-date with the same days of last month, not the whole month.
- const comparison=payload?.comparison||{},comparisonLabel=deliveryRange==='month'?'same days last month':efficiencyComparisonWindows(deliveryRange)?.label||'prior period';
- const gitDelta=key=>comparison.available?percentTrendDelta(comparison[key],comparisonLabel):{text:'No comparable prior period',direction:''};
- // Git deltas stay neutral: pushed-code evidence is never scored as better or worse.
- renderTrendDelta('d-code-pushed-change',gitDelta('code_pushed_pct'),'',available.code_pushed!==true);
- renderTrendDelta('d-spend-lines-change',gitDelta('spend_per_1k_pct'),'',available.spend_per_1k!==true);
- $('d-push-yield').textContent=yieldAvailable?deliveryRatio(efficiency.delivery_yield):'--';
- $('d-push-yield-note').textContent=yieldAvailable?'lines / 1K output':'Waiting for output tokens.';
- renderTrendDelta('d-push-yield-change',gitDelta('delivery_yield_pct'),'',!yieldAvailable);
- const changedLines=Number(overall?.changed_lines)||0;
- $('d-rework').textContent=available.code_pushed===true&&changedLines>0?deliveryPercent(100*(Number(overall.deleted)||0)/changedLines):'--';
- $('d-comparison').innerHTML=deliveryComparisonText(payload?.comparison||{});
- const selectedCount=Number(coverage.selected_repositories)||0,measured=Number(coverage.measured_repositories)||0,comparable=Number(coverage.comparable_repositories)||0,checked=Number(coverage.last_checked)||0,days=Array.isArray(payload?.days)?payload.days:[];
- const coverageNode=$('d-coverage');
- const spendCoverage=Number(coverage.spend_coverage),spendCoverageAvailable=coverage.spend_coverage!==null&&coverage.spend_coverage!==undefined&&Number.isFinite(spendCoverage);
- const coveragePercent=spendCoverageAvailable?Math.max(0,Math.min(100,Math.round(100*spendCoverage))):0,coverageBar=$('d-coverage-bar');
- const evidencePartial=!spendCoverageAvailable||coveragePercent<100||comparable<selectedCount||available.partial===true;
- coverageBar.style.setProperty('--delivery-coverage',coveragePercent);
- coverageBar.classList.toggle('partial',evidencePartial);
- if(spendCoverageAvailable){coverageBar.setAttribute('aria-valuenow',coveragePercent);coverageBar.removeAttribute('aria-valuetext');}
- else{coverageBar.removeAttribute('aria-valuenow');coverageBar.setAttribute('aria-valuetext','Spend coverage unavailable');}
- $('d-coverage-percent').textContent=spendCoverageAvailable?`${coveragePercent}%`:'--';
- const activeDays=days.filter(row=>(Number(row?.changed_lines)||0)>0).length;
- $('d-active-days').textContent=checked&&available.code_pushed===true&&days.length?`${activeDays} / ${days.length}`:'--';
- const commitsAvailable=available.code_pushed===true&&deliveryCommitsMeasured(overall);
- $('d-commits').textContent=commitsAvailable?f(overall.commits):'--';
- $('d-repo-evidence').textContent=checked&&selectedCount?`${measured} / ${selectedCount}`:'--';
- $('d-comparable-evidence').textContent=checked?`${comparable} ${countWord(comparable,'project')}`:'--';
- coverageNode.classList.toggle('partial',evidencePartial||!checked);
- coverageNode.textContent=!checked?'Scanning local Git':selectedCount?(evidencePartial?'Partial evidence':'Evidence ready'):'No Git projects found';
-	 drawDeliveryChart(days);renderDeliveryModelTable(payload?.model_rows||[],payload?.model_coverage);renderDeliveryTable(payload?.project_rows||[]);
-	 renderDeliveryEvidence(payload);renderDeliverySignals(payload);renderDeliveryShape(payload);
-}
-let deliveryRetryTimer=0,deliveryLoadRetries=0;
-function renderWorkTags(tags){
- const host=$('preview-work-tags');
- if(!tags||!(tags.area||tags.work_type)){host.hidden=true;host.innerHTML='';return;}
- const tagChips=[];
- if(tags.area&&tags.area!=='Pending')tagChips.push(`<span class=workTag title="${tags.area_guess?'Area: the local model\u2019s best guess with low confidence':'Area (local model estimate)'}">${esc(tags.area)}${tags.area_guess?' (likely)':''}</span>`);
- if(tags.work_type)tagChips.push(`<span class=workTag title="Work type (local model estimate)">${esc(WORK_TYPE_LABELS[tags.work_type]||tags.work_type)}</span>`);
- if(tags.complexity)tagChips.push(`<span class=workTag title="Complexity (local model estimate)">${esc(WORK_COMPLEXITY_LABELS[tags.complexity]||tags.complexity)}</span>`);
- if(tags.labeled_turns)tagChips.push(`<span class="workTag${tags.corrections?' pushback':''}" title="Follow-up turns that pushed back on the previous work">${tags.corrections} pushback${tags.corrections===1?'':'s'} / ${tags.labeled_turns}</span>`);
- host.innerHTML=tagChips.join('');host.hidden=!tagChips.length;
-}
-const WORK_TYPE_LABELS={feature:'Feature work',debug:'Bug fixing',refactor:'Refactoring',test:'Testing',review:'Code review',plan:'Planning & design',explore:'Questions & research',ops:'DevOps & setup',docs:'Docs & writing',other:'Non-software',unclear:'Unclear'};
-const WORK_COMPLEXITY_LABELS={routine:'Routine',everyday:'Everyday',complex:'Complex',high_impact:'High impact'};
-const WORK_TIER_LABELS={light:'Light models',standard:'Standard models',premium:'Premium models'};
-const WORK_UNLABELED_AREAS=['No request text','Outside history','Pending'],WORK_MUTED_AREAS=['Unclear',...WORK_UNLABELED_AREAS];
-const WORK_AREA_NAMES={Pending:'Not labeled yet','Outside history':'Outside labeling history'};
-const WORK_AREA_TIPS={Unclear:'The local model was not confident about the area.','No request text':'Token Meter has no typed request to label for these sessions: the app does not record one Token Meter can read, or the session never had one.','Outside history':'Older than the labeling history in Settings → Work insights. Raise it to label these.',Pending:'Waiting for the local model.'};
-const WORK_AREA_COLORS=['var(--w1)','var(--w2)','var(--w3)','var(--w4)','var(--w5)','var(--w6)','var(--w7)','var(--w8)'];
-function workAreaColor(area,areas){
- if(area==='Unclear')return'var(--w-unclear)';
- if(WORK_UNLABELED_AREAS.includes(area))return'var(--w-pending)';
- const index=(areas||[]).indexOf(area);
- return WORK_AREA_COLORS[index]||'var(--w-unclear)';
-}
-function workPercent(value){return value==null?'--':`${Math.round(value*100)}%`;}
-function workRateText(rework){
- if(!rework)return'<span class=workMuted>--</span>';
- const text=workPercent(rework.rate);
- return rework.few_samples?`<span class=workMuted title="Fewer than 20 labeled turns">${text} · few</span>`:text;
-}
-function workMonthLabel(month,partial){return workMonthName(month,{year:true,partial});}
-function workClock(value){
- if(!value||value==='indefinite')return'';
- const when=new Date(Number(value)*1000),today=new Date().toDateString()===when.toDateString();
- return when.toLocaleString([],today?{hour:'2-digit',minute:'2-digit'}:{weekday:'short',hour:'2-digit',minute:'2-digit'});
-}
-function workDuration(seconds){
- if(!seconds)return'';
- const minutes=Math.max(1,Math.round(seconds/60));
- return minutes<90?`about ${minutes} min left`:`about ${Math.round(minutes/60)} h left`;
-}
-const WORK_SETUP_ACTIVE=['checking','installing_ollama','starting_ollama','downloading_model','importing'];
-let workSetupTimer=0;
-function workGigabytes(bytes){const value=Math.max(0,bytes||0);return value<1e9?`${Math.round(value/1e6)} MB`:`${(value/1e9).toFixed(1)} GB`;}
-const WORK_SETUP_STEP={checking:'ollama',installing_ollama:'ollama',starting_ollama:'ollama',downloading_model:'model',importing:'prepare'};
-const WORK_SETUP_DETAIL={size:'The connection dropped before the download finished. What arrived is kept, and the next try resumes from there.',hash:'The downloaded file didn’t match its checksum, so it was deleted and will be downloaded again.',archive:'Ollama’s download didn’t pass its safety check, so it was deleted.',signature:'Ollama’s download wasn’t signed by Ollama, so it was deleted.',http_status:'The download server turned the request away.',tls:'A secure connection couldn’t be made. A proxy, VPN, or network filter may be blocking it.',timeout:'The connection timed out.',connection:'The connection was lost or couldn’t be opened.',curl:'A second download method also failed.',disk:'The disk filled up during the download.',start_timeout:'Ollama took too long to start.',import_failed:'Adding the model to Ollama failed.'};
-// Download speed from successive status polls, smoothed so one slow poll doesn't swing the estimate.
-let workSetupRate={bytes:0,at:0,speed:0,state:''};
-function workSetupSpeed(setup){
- const now=Date.now(),done=Number(setup.done_bytes||0),rate=workSetupRate;
- if(rate.state!==setup.state||done<rate.bytes){workSetupRate={bytes:done,at:now,speed:0,state:setup.state};return 0;}
- const seconds=(now-rate.at)/1000;
- if(seconds>=2){const sample=(done-rate.bytes)/seconds;rate.speed=rate.speed?rate.speed*.6+sample*.4:sample;rate.bytes=done;rate.at=now;}
- return rate.speed;
-}
-function workRate(bytesPerSecond){return bytesPerSecond>=1e6?`${(bytesPerSecond/1e6).toFixed(1)} MB/s`:`${Math.max(1,Math.round(bytesPerSecond/1e3))} KB/s`;}
-function workSetupCopy(setup){
- if(!setup)return null;
- const progress=setup.total_bytes?`${workGigabytes(setup.done_bytes)} of ${workGigabytes(setup.total_bytes)}`:'';
- let pace='';
- if(['installing_ollama','downloading_model'].includes(setup.state)&&setup.total_bytes){
-  const speed=workSetupSpeed(setup),left=Math.max(0,setup.total_bytes-setup.done_bytes);
-  if(speed>0)pace=` · ${workRate(speed)} · ${workDuration(left/speed)||'almost done'}`;
-  if(speed>0&&speed<1e6)pace+=' · slow connection: this can take a while, and you can leave this page';
- }
- const retry=setup.state==='failed'&&setup.retry_at?`Token Meter tries again on its own at ${workClock(setup.retry_at)}${setup.attempts>1?` (attempt ${setup.attempts+1})`:''}, or select Retry setup now.`:'';
- const why=WORK_SETUP_DETAIL[setup.detail]||'';
- return {
-  checking:['Setup','Checking Ollama','Looking for Ollama and the classifier model on this Mac.'],
-  installing_ollama:['Setup',`Downloading Ollama ${setup.ollama_version||''}`.trim(),`${progress}${pace} · a pinned, signed build that runs only on this Mac.`],
-  starting_ollama:['Setup','Starting Ollama','The first start can take a minute while macOS checks it. Ollama runs in the background on this Mac only.'],
-  downloading_model:['Setup','Downloading the labeling model',`${progress}${pace} · the download resumes if the connection drops.`],
-  importing:['Setup','Preparing the model','Adding it to Ollama. This can take a few minutes.'],
-  failed:['Setup',{network:'The download stopped',verify:'A download failed its check',disk_space:'Not enough disk space',memory:'Not enough memory on this Mac',ollama_start:'Ollama didn’t start',ollama_offline:'Ollama isn’t running',import:'Importing the model failed'}[setup.reason]||'Setup stopped',
-   [why,retry||({network:'Check the internet connection, then select Retry setup.',verify:'Select Retry setup to download it again.',disk_space:setup.needed_bytes?`Free up about ${workGigabytes(setup.needed_bytes)}, then select Retry setup.`:'Free up some disk space, then select Retry setup.',memory:'The labeling model needs a Mac with at least about 10 GB of memory, so nothing was downloaded.',ollama_start:'Select Retry setup to try again.',ollama_offline:'Start Ollama on this Mac (open the Ollama app or run ollama serve), then select Retry setup.',import:'Select Retry setup to try again.'}[setup.reason]||'Select Retry setup to try again.')].filter(Boolean).join(' ')],
- }[setup.state]||null;
-}
-// Which step is done, current, or failed; a failure belongs to the step that was running.
-function renderWorkSetupSteps(setup,lastStep){
- const list=$('w-setup-steps'),bar=$('w-setup-bar');
- list.hidden=!setup;bar.hidden=!(setup&&setup.total_bytes&&['installing_ollama','downloading_model'].includes(setup.state));
- if(!setup)return;
- const order=['ollama','model','prepare','label'],current=setup.state==='failed'?(WORK_SETUP_STEP[setup.failed_during]||lastStep):WORK_SETUP_STEP[setup.state];
- const at=Math.max(0,order.indexOf(current));
- list.querySelectorAll('li').forEach((item,index)=>{item.dataset.state=index<at?'done':index===at?(setup.state==='failed'?'failed':'current'):'';});
- if(!bar.hidden){const share=Math.min(100,Math.round(100*setup.done_bytes/setup.total_bytes));bar.querySelector('i').style.width=`${share}%`;bar.setAttribute('aria-valuenow',share);}
-}
-let workSetupLastStep='ollama';
-async function refreshWorkStatus(){
- if(!WORK||!$('view-work').classList.contains('on'))return;
- try{
-  const response=await fetch('/work-insights/status',{cache:'no-store'}),payload=await response.json();
-  if(!payload.ok)return;
-  WORK.status=payload.status;WORK.settings=payload.settings;renderWorkStatus(WORK);
-  if(payload.status?.setup?.state==='ready')loadWork();
- }catch(error){}
-}
-// The charts read only labeled requests, so say so until labeling catches up.
-function workProgressNote(settings,status,coverage,hasInsights){
- const labelable=Math.max(0,(coverage.sessions||0)-(coverage.no_text_sessions||0)-(coverage.outside_sessions||0));
- const labeled=coverage.labeled_sessions||0;
- if(!settings.enabled||!hasInsights||(labeled>=labelable&&!status.pending))return null;
- // The status card above already counts what is left; this says what that means for the charts.
- if(!labeled)return['Results appear as labeling finishes','No session in this period is labeled yet, so the charts below are empty for now. They fill in as requests are labeled.'];
- if(labeled>=labelable)return['Results are updating','Every session in this period has labels. Some are being labeled again, so numbers below may shift a little as that finishes.'];
- // One line: the status card above already gives the labeled share.
- return['','Charts are partial until labeling finishes · unlabeled sessions show in gray.'];
-}
-function renderWorkStatus(payload){
- const status=payload?.status||{},settings=payload?.settings||{},coverage=payload?.insights?.coverage||{};
- const state=status.reason==='delete_pending'?'storage_error':settings.enabled?status.state||'idle':'disabled';
- const labelable=Math.max(0,(coverage.sessions||0)-(coverage.no_text_sessions||0)-(coverage.outside_sessions||0));
- const share=labelable?Math.floor(100*coverage.labeled_sessions/labelable):0;
- // While requests are queued, show what is left; the session share alone reads as done during a relabel.
- const progress=`${status.pending?`${status.pending.toLocaleString()} request${status.pending===1?'':'s'} left to label · charts update as they finish`:`Labeled ${share}% of labelable sessions in this period`}${status.eta_s&&state==='running'?` · ${workDuration(status.eta_s)}`:''}`;
- const copy={
-  disabled:['Off','Work insights are off','Turn on local classification in Settings to label sessions.'],
-  setup_needed:['Setup',status.reason==='remote_model'?'Cloud model refused':'Classifier model not found',status.reason==='model_missing'?(status.model_change?'Work insights now use Google’s Gemma 4 E4B model (Apache-2.0): about a 5 GB download that needs about 11 GB free while it sets up and about 5.5 GB of memory while it labels. Select Retry setup to download it.':`Looking for “${settings.model||'token-meter-gemma'}”. Select Retry setup to install it.`):status.reason==='remote_model'?'That Ollama model runs on another host. Choose a local model in Settings.':'Start Ollama on this machine, then Token Meter retries automatically.'],
-  running:['Running','Labeling sessions',progress],
-  idle:['Ready',status.pending?'Waiting to label more requests':'Up to date',progress],
-  paused:['Paused','Paused',status.paused_until==='indefinite'?'Paused until you resume.':`Paused until ${workClock(status.paused_until)}.`],
-  throttled:['Waiting',{on_battery:'Waiting: on battery power',system_busy:'Waiting: this Mac is busy',model_slow:'Waiting: the model is responding slowly',low_memory:'Waiting: memory is low',not_enough_memory:'Waiting: not enough memory on this Mac'}[status.reason]||'Waiting',status.reason==='not_enough_memory'?'The labeling model needs about 6 GB of memory plus room for macOS and your apps, which this Mac doesn’t have. Work insights stay off the model so your Mac stays responsive.':status.reason==='low_memory'?`The model is unloaded so other apps keep their memory. ${progress} · checks again${status.retry_at?` at ${workClock(status.retry_at)}`:' shortly'}.`:`${progress} · checks again in a minute.`],
-  backoff:['Retrying',status.reason==='internal_error'?'Recovering from an internal error':status.reason==='timeout'?'Ollama is slow to answer':'Can’t reach Ollama',`${status.retry_at?`Retrying at ${workClock(status.retry_at)}.`:'Retrying shortly.'} Queued work is kept.${status.error_at?` (${status.error_at})`:''}`],
-  storage_error:['Error',status.reason==='delete_pending'?'Deleting labels didn’t finish':'Can’t save labels',status.reason==='delete_pending'?'Labeling is stopped until the delete succeeds. Token Meter retries every five minutes.':'Token Meter retries every five minutes.'],
- }[state]||['Ready','Up to date',progress];
- const setupRelevant=status.setup&&(WORK_SETUP_ACTIVE.includes(status.setup.state)||(status.setup.state==='failed'&&['setup_needed','backoff'].includes(status.state)));
- const setup=settings.enabled&&setupRelevant?status.setup:null,setupCopy=workSetupCopy(setup);
- const shown=setupCopy||copy;
- const off=!settings.enabled;$('w-turn-on').hidden=!off;$('w-open-settings').hidden=off;
- const pill=$('w-state');pill.dataset.state=setupCopy?(setup.state==='failed'?'setup_needed':'running'):state;pill.textContent=shown[0];
- $('w-status-title').textContent=shown[1];$('w-status-detail').textContent=shown[2];
- const note=workProgressNote(settings,status,coverage,Boolean(payload?.insights));
- $('w-progress-note').hidden=!note;
- if(note){$('w-progress-title').textContent=note[0];$('w-progress-title').hidden=!note[0];$('w-progress-detail').textContent=note[1];}
- if(setup&&WORK_SETUP_STEP[setup.state])workSetupLastStep=WORK_SETUP_STEP[setup.state];
- renderWorkSetupSteps(setupCopy?setup:null,workSetupLastStep);
- const setupState=status.setup?.state;
- const serviceNeedsSetup=['setup_needed','backoff'].includes(status.state);
- $('w-setup-retry').hidden=!(settings.enabled&&status.setup&&!WORK_SETUP_ACTIVE.includes(setupState)&&(setupState==='failed'?serviceNeedsSetup:state==='setup_needed'));
- clearTimeout(workSetupTimer);
- if(setup&&(WORK_SETUP_ACTIVE.includes(setup.state)||setup.retry_at))workSetupTimer=setTimeout(refreshWorkStatus,setup.retry_at&&setup.state==='failed'?15000:4000);
- $('w-pause-wrap').hidden=!settings.enabled||state==='paused';
- $('w-resume').hidden=state!=='paused';
-}
-const WORK_OUTCOME_ORDER=['accepted','recovered','ended_on_pushback','unclear'],OUTCOMES_SHOWN=WORK_OUTCOME_ORDER;
-function workIsDay(key){return /^\d{4}-\d{2}-\d{2}$/.test(String(key||''));}
-function workMonthName(month,{year=false,partial=false}={}){
- if(workIsDay(month)){
-  const day=new Date(`${month}T12:00:00`);if(Number.isNaN(day.getTime()))return month;
-  const text=day.toLocaleDateString([],year?{month:'short',day:'numeric',year:'numeric'}:{month:'short',day:'numeric'});
-  return partial?`${text} · so far`:text;
- }
- const date=new Date(`${month}-01T00:00:00`);
- if(Number.isNaN(date.getTime()))return month;
- const text=date.toLocaleDateString([],year?{month:'short',year:'numeric'}:{month:'short'});
- return partial?`${text} · so far`:text;
-}
-let workBreakdownModel='',workBreakdownSort={key:'spend',direction:'desc'};
-const WORK_BREAKDOWN_COLUMNS=[
- ['name','Kind of work','Select to sort by name.'],
- ['spend','Spend','Each request\'s share of its session\'s cost.'],
- ['requests','Requests','Messages you typed. Agent : human counts only those from apps that split model calls by request; hover a row for its counts.'],
- ['resolved_rate','Task outcomes','Tasks with a labeled follow-up: accepted, recovered after pushback, ended on pushback, or unclear. Sorts by resolved share.'],
- ['cost_per_resolved','Cost / resolved','Spend on resolved tasks per resolved task.'],
- ['agent_per_human','Agent : human','Agent turns (model calls) per human turn (message you typed). Only apps that split model calls by request count.'],
- ['pushback','Pushback','How often your next message pushed back. Faded below 20 labeled follow-ups.'],
- ['best_model','Best model','Least pushback among models with 20+ labeled follow-ups and 3+ sessions for this kind of work. Sorts by its pushback.'],
- ['worst_model','Worst model','Most pushback among the same rated models. Sorts by its pushback.'],
-];
-function workBreakdownName(row){return row.key?(WORK_TYPE_LABELS[row.key]||row.key):'Not labeled yet';}
-function workBreakdownValue(row,key){
- if(key==='name')return workBreakdownName(row).toLowerCase();
- if(key==='pushback')return row.pushback?row.pushback.rate:null;
- if(key==='best_model'||key==='worst_model')return row[key]?row[key].rate:null;
- return row[key]??null;
-}
-function sortWorkBreakdown(rows,sort=workBreakdownSort){
- const sign=sort.direction==='asc'?1:-1;
- return [...rows].sort((a,b)=>{const x=workBreakdownValue(a,sort.key),y=workBreakdownValue(b,sort.key);
-  if(x==null&&y==null)return b.spend-a.spend;if(x==null)return 1;if(y==null)return -1;
-  return (x<y?-1:x>y?1:0)*sign||b.spend-a.spend;});
-}
-function workCellBar(value,max){
- if(value==null||!(max>0))return '';
- return `<span class=workCellBar><i style="width:${Math.max(2,100*value/max).toFixed(1)}%"></i></span>`;
-}
-function renderWorkBreakdown(insights){
- const breakdown=insights?.breakdown||{},models=breakdown.models||[],select=$('w-breakdown-model');
- const keys=models.map(item=>`${item.model}␟${item.runtime}`);
- if(workBreakdownModel&&!keys.includes(workBreakdownModel))workBreakdownModel='';
- select.innerHTML='<option value="">All models</option>'+models.map((item,index)=>`<option value="${esc(keys[index])}">${esc(`${item.model} · ${item.runtime}`)}</option>`).join('');
- select.value=workBreakdownModel;
- const chosen=workBreakdownModel?models[keys.indexOf(workBreakdownModel)]:null;
- const overall=chosen?chosen.overall:breakdown.overall,table=$('w-breakdown-table');
- const columns=WORK_BREAKDOWN_COLUMNS.filter(([key])=>!chosen||(key!=='best_model'&&key!=='worst_model'));
- if(chosen&&(workBreakdownSort.key==='best_model'||workBreakdownSort.key==='worst_model'))workBreakdownSort={key:'spend',direction:'desc'};
- const calls=value=>value==null?'--':value.toLocaleString(undefined,{maximumFractionDigits:1});
- const count=value=>(value||0).toLocaleString();
- const ratio=row=>workAgentRatio(row.agent_per_human);
- if(!overall||!overall.requests){$('w-breakdown-note').textContent='';$('w-breakdown-foot').textContent='';table.innerHTML='<tbody><tr><td><div class=workEmpty>No requests in this period.</div></td></tr></tbody>';return;}
- $('w-breakdown-note').textContent=`${chosen?`${chosen.model} · `:''}${money(overall.spend)} over ${count(overall.requests)} request${overall.requests===1?'':'s'} · agent : human ${ratio(overall)} · ${workPercent(overall.resolved_rate)} of judged tasks resolved`;
- const rows=sortWorkBreakdown(chosen?chosen.work_type:breakdown.work_type||[]);
- const max=key=>Math.max(0,...rows.map(row=>workBreakdownValue(row,key)||0));
- const maxSpend=max('spend'),maxRatio=max('agent_per_human');
- const muted=row=>!row.key||row.key==='unclear';
- const outcomeBar=row=>{const judged=WORK_OUTCOME_ORDER.reduce((sum,key)=>sum+((row.outcomes||{})[key]||0),0);
-  if(!judged)return `<span class=workMuted title="${esc(`${count(row.tasks)} task${row.tasks===1?'':'s'}, none with a labeled follow-up`)}">--</span>`;
-  const present=WORK_OUTCOME_ORDER.filter(key=>(row.outcomes||{})[key]);
-  return `<span class=workOutcomeBar role=img aria-label="${esc(present.map(key=>`${WORK_OUTCOME_LABELS[key]} ${row.outcomes[key]}`).join(', '))}" title="${esc(`${count(judged)} of ${count(row.tasks)} tasks judged`)}">${present.map(key=>`<i style="flex:${row.outcomes[key]} 0 0;--swatch:${WORK_OUTCOME_COLORS[key]}" title="${esc(`${WORK_OUTCOME_LABELS[key]} · ${row.outcomes[key]}`)}"></i>`).join('')}</span><small>${workPercent(row.resolved_rate)} resolved</small>`;};
- const modelCell=(row,field)=>{const item=row[field];if(!item)return '<td><span class=workMuted title="Needs two models with enough labeled follow-ups">--</span></td>';
-  const drill={model:item.model,model_runtime:item.runtime};if(row.key)drill.work_type=row.key;
-  return `<td><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify(drill))}" data-drill-label="${esc(`${workBreakdownName(row)} · ${item.model}`)}" title="${esc(`${item.model} · ${item.runtime} · ${workPercent(item.rate)} pushback over ${count(item.samples)} labeled follow-ups`)}"><span class=workScoreName><b>${esc(item.model)}</b><small>${esc(item.runtime)} · ${workPercent(item.rate)}</small></span></button></td>`;};
- const cells=(row,total)=>{
-  const name=workBreakdownName(row),drill=total||!row.key?null:{work_type:row.key,...(chosen?{model:chosen.model,model_runtime:chosen.runtime}:{})};
-  const label=total?'<strong>All work</strong>':drill?`<button type=button class=workDrillBtn data-drill="${esc(JSON.stringify(drill))}" data-drill-label="${esc(chosen?`${name} · ${chosen.model}`:name)}">${esc(name)}</button>`:esc(name);
-  return `<td>${label}</td>
-<td class=num><b>${money(row.spend)}</b>${total?'':`<small> ${workPercent(row.share)}</small>`}${total?'':workCellBar(row.spend,maxSpend)}</td>
-<td class=num title="${esc(`${count(row.sessions)} session${row.sessions===1?'':'s'}`)}">${count(row.requests)}${row.few_samples&&!total?'<small class=workCellNote>few</small>':''}</td>
-<td class=workOutcomeCell>${outcomeBar(row)}</td>
-<td class=num>${row.cost_per_resolved==null?'<span class=workMuted>--</span>':money(row.cost_per_resolved)}</td>
-<td class=num title="${esc(row.human_turns?`${count(row.agent_turns)} agent turns, ${count(row.human_turns)} human turns`:'Not recorded by these apps')}"><b>${ratio(row)}</b>${total?'':workCellBar(row.agent_per_human,maxRatio)}</td>
-<td class=num>${workRateText(row.pushback)}</td>${chosen?'':modelCell(row,'best_model')+modelCell(row,'worst_model')}`;};
- const head=columns.map(([key,label,tip])=>{const active=workBreakdownSort.key===key;
-  return `<th${key==='name'?'':' class=num'} aria-sort="${active?(workBreakdownSort.direction==='asc'?'ascending':'descending'):'none'}"><button class=efficiencySort type=button data-work-sort=${key} title="${esc(tip)}">${esc(label)}<span class=efficiencySortMark aria-hidden=true>${active?(workBreakdownSort.direction==='asc'?'↑':'↓'):''}</span></button></th>`;}).join('');
- table.innerHTML=`<thead><tr>${head}</tr></thead><tbody><tr class=workBreakdownTotal>${cells(overall,true)}</tr>${rows.map(row=>`<tr${muted(row)?' class=workMuted':''}>${cells(row,false)}</tr>`).join('')}</tbody>`;
- const unanswered=overall.requests-overall.human_turns,unjudged=(overall.outcomes||{}).unjudged||0;
- const excludedDetail=[unanswered>0?`${count(unanswered)} of ${count(overall.requests)} requests come from apps that don't split model calls by request, so Agent : human leaves them out.`:'',unjudged?`${count(unjudged)} of ${count(overall.tasks)} tasks had no labeled follow-up and aren't in Task outcomes.`:''].filter(Boolean).join(' ');
- const excludedShort=[unanswered>0?`${count(unanswered)} ${unanswered===1?'request':'requests'}`:'',unjudged?`${count(unjudged)} ${unjudged===1?'task':'tasks'}`:''].filter(Boolean).join(', ');
- $('w-breakdown-foot').innerHTML=excludedShort?`<span class=fieldtip tabindex=0 aria-description="${esc(excludedDetail)}" data-tip="${esc(excludedDetail)}">· ${esc(excludedShort)} excluded</span>`:'';
-}
-$('w-breakdown-model').addEventListener('change',event=>{workBreakdownModel=event.target.value;if(WORK)renderWorkBreakdown(WORK.insights);});
-$('w-breakdown-table').addEventListener('click',event=>{const button=event.target.closest('[data-work-sort]');if(!button)return;event.stopPropagation();const key=button.dataset.workSort;
- workBreakdownSort=workBreakdownSort.key===key?{key,direction:workBreakdownSort.direction==='desc'?'asc':'desc'}:{key,direction:key==='name'||key==='best_model'?'asc':'desc'};if(WORK)renderWorkBreakdown(WORK.insights);});
-function drawWorkTrend(svg,points,{value,axis,tip,average,averageText,empty,floor,daily}){
- // Drawn in pixels at the chart's own width, so labels stay at the 11px floor in a half-width card.
- const W=Math.max(320,Math.round(svg.parentElement.clientWidth||560));
- if(!points.length){svg.setAttribute('viewBox',`0 0 ${W} 120`);svg.innerHTML=`<text x=${W/2} y=60 text-anchor=middle class=workAxisText>${esc(empty)}</text>`;return;}
- const H=260,left=40,right=12,top=16,bottom=28,max=Math.max(floor,...points.map(value))*1.15,fill=`${svg.id}-fill`;
- svg.setAttribute('viewBox',`0 0 ${W} ${H}`);
- const x=index=>points.length===1?(left+W-right)/2:left+(W-left-right)*index/(points.length-1),y=v=>top+(H-top-bottom)*(1-v/max);
- const path=points.map((point,index)=>`${index?'L':'M'}${x(index).toFixed(1)},${y(value(point)).toFixed(1)}`).join('');
- const area=points.length>1?`<path class=workArea style="fill:url(#${fill})" d="${path}L${x(points.length-1).toFixed(1)},${y(0).toFixed(1)}L${x(0).toFixed(1)},${y(0).toFixed(1)}Z"></path>`:'';
- const grid=[0,max/2,max].map(v=>`<line class=workGridLine x1=${left} x2=${W-right} y1="${y(v).toFixed(1)}" y2="${y(v).toFixed(1)}"></line><text class=workAxisText x=${left-6} y="${(y(v)+3).toFixed(1)}" text-anchor=end>${esc(axis(v))}</text>`).join('');
- const avg=average==null?'':`<line class=workTrendAvg x1=${left} x2=${W-right} y1="${y(average).toFixed(1)}" y2="${y(average).toFixed(1)}"></line><text class=workTrendAvgText x=${W-right} y="${(y(average)-5).toFixed(1)}" text-anchor=end>${esc(averageText)}</text>`;
- const label=point=>daily?workMonthName(point.week,{year:false}):`Week of ${workMonthName(point.week,{year:false})}`;
- const dots=points.map((point,index)=>`<circle class="workPoint${point.few_samples?' few':''}" cx="${x(index).toFixed(1)}" cy="${y(value(point)).toFixed(1)}" r=4><title>${esc(`${label(point)} · ${tip(point)}${point.few_samples?' (few samples)':''}`)}</title></circle>`).join('');
- svg.innerHTML=`<defs><linearGradient id=${fill} x1=0 y1=0 x2=0 y2=1><stop offset=0 style="stop-color:var(--signal);stop-opacity:.28"/><stop offset=1 style="stop-color:var(--signal);stop-opacity:0"/></linearGradient></defs>${grid}${area}<path class=workLine d="${path}"></path>${dots}${avg}<text class=workAxisText x=${left} y=${H-6}>${esc(workMonthName(points[0].week,{year:false}))}</text><text class=workAxisText x=${W-right} y=${H-6} text-anchor=end>${esc(workMonthName(points[points.length-1].week,{year:false}))}</text>`;
-}
-function renderWorkRework(insights){
- const rework=insights?.rework||{},select=$('w-rework-model'),series=rework.weekly_by_model||[];
- const keys=series.map(item=>`${item.model}␟${item.runtime}`);
- if(select.value&&!keys.includes(select.value))select.value='';
- const current=select.value;
- select.innerHTML='<option value="">All models</option>'+series.map((item,index)=>`<option value="${esc(keys[index])}">${esc(`${item.model} · ${item.runtime}`)}</option>`).join('');
- select.value=current;
- const chosen=current?series[keys.indexOf(current)]:null,weeks=(chosen?chosen.weeks:rework.weekly||[]).slice(rework.grain==='day'?-31:-26);
- const samples=weeks.reduce((sum,week)=>sum+week.samples,0),hits=weeks.reduce((sum,week)=>sum+week.rate*week.samples,0),daily=rework.grain==='day';
- const average=samples?hits/samples:0;
- $('w-rework-note').textContent=weeks.length?`${workPercent(average)} of ${samples.toLocaleString()} follow-ups · ${daily?'daily':'weekly'}`:'Waiting for labeled follow-ups';
- drawWorkTrend($('w-rework-trend'),weeks,{value:week=>week.rate,axis:v=>`${Math.round(v*100)}%`,tip:week=>`${workPercent(week.rate)} of ${week.samples} turns`,
-  average,averageText:`avg ${workPercent(average)}`,empty:'No labeled follow-ups in this period yet',floor:.1,daily});
-}
-function workAgentRatio(value){return value==null?'--':`${value.toLocaleString(undefined,{maximumFractionDigits:1})} : 1`;}
-function renderWorkAgentTrend(insights){
- const models=insights?.breakdown?.models||[],select=$('w-agent-model'),keys=models.map(item=>`${item.model}␟${item.runtime}`);
- if(select.value&&!keys.includes(select.value))select.value='';
- const current=select.value;
- select.innerHTML='<option value="">All models</option>'+models.map((item,index)=>`<option value="${esc(keys[index])}">${esc(`${item.model} · ${item.runtime}`)}</option>`).join('');
- select.value=current;
- const chosen=current?models[keys.indexOf(current)]:null;
- const trend=(chosen?chosen.agent_trend:insights?.breakdown?.agent_trend)||{},daily=trend.grain==='day',points=(trend.points||[]).slice(daily?-31:-26);
- const human=points.reduce((sum,point)=>sum+point.human_turns,0),agent=points.reduce((sum,point)=>sum+point.agent_turns,0),average=human?agent/human:null;
- $('w-agent-note').textContent=points.length?`${workAgentRatio(average)} over ${human.toLocaleString()} human turns · ${daily?'daily':'weekly'}`:'Waiting for requests with model calls';
- drawWorkTrend($('w-agent-trend'),points,{value:point=>point.agent_per_human,axis:v=>v.toLocaleString(undefined,{maximumFractionDigits:0}),
-  tip:point=>`${workAgentRatio(point.agent_per_human)} · ${point.agent_turns.toLocaleString()} agent / ${point.human_turns.toLocaleString()} human turns`,
-  average,averageText:`avg ${workAgentRatio(average)}`,empty:'No requests with model calls in this period yet',floor:1,daily});
-}
-function openWorkSessions(filters,label){
- const query=new URLSearchParams({months:workMonths});
- if(workRuntime)query.set('runtime',workRuntime);
- const project=filters.project||workProject;if(project)query.set('project',project);
- Object.entries(filters).forEach(([key,value])=>{if(key!=='project'&&value!=null&&value!=='')query.set(key,value);});
- query.set('label',label||'Work');
- location.hash=`sessions-all?work=1&${query}`;
-}
-function renderWorkSizing(insights){
- const cells=insights?.right_sizing?.cells||[],grid=$('w-sizing');
- if(!insights?.right_sizing?.tiers_known){grid.innerHTML='<div class=workEmpty style="grid-column:1/-1">Model price tiers are unavailable for these sessions.</div>';return;}
- const tiers=['light','standard','premium'],groups=['routine','everyday','complex'];
- const head=`<div role=row style="display:contents"><div class=workSizingHead role=columnheader></div>${tiers.map(tier=>`<div class=workSizingHead role=columnheader>${esc(WORK_TIER_LABELS[tier])}</div>`).join('')}</div>`;
- grid.innerHTML=head+groups.map(group=>`<div role=row style="display:contents"><div class=workSizingRowHead role=rowheader>${group==='complex'?'Complex+':esc(WORK_COMPLEXITY_LABELS[group])}</div>${tiers.map(tier=>{
-  const cell=cells.find(item=>item.complexity===group&&item.tier===tier)||{requests:0,spend:0};
-  const flag=cell.flag==='possible_overspend'?'<span class=workFlag><span aria-hidden=true>▲</span>Possible overspend (estimate)</span>':cell.flag==='possible_false_economy'?'<span class=workFlag><span aria-hidden=true>▲</span>Possible false economy (estimate)</span>':'';
-  const body=`<strong class=mono>${cell.requests?money(cell.spend):'--'}</strong><span>${cell.requests} request${cell.requests===1?'':'s'}</span>${cell.rework?`<span>Rework ${workRateText(cell.rework)}</span>`:''}${flag}`;
-  return `<div class=workSizingCell role=cell data-flag="${esc(cell.flag||'')}">${cell.requests?`<button type=button class="workDrillBtn workSizingBtn" data-drill="${esc(JSON.stringify({complexity:group,tier}))}" data-drill-label="${esc(`${group==='complex'?'Complex+':WORK_COMPLEXITY_LABELS[group]} · ${WORK_TIER_LABELS[tier]}`)}">${body}</button>`:body}</div>`;
- }).join('')}</div>`).join('');
-}
-function renderWorkEffort(insights){
- const effort=insights?.right_sizing?.effort,table=$('w-effort-table');
- if(!effort||!(effort.efforts||[]).length){table.innerHTML='<tbody><tr><td><div class=workEmpty>No reasoning-effort data for these sessions.</div></td></tr></tbody>';return;}
- const groups=['routine','everyday','complex'],cell=(group,level)=>(effort.cells||[]).find(item=>item.complexity===group&&item.effort===level);
- table.innerHTML=`<thead><tr><th>Complexity</th>${effort.efforts.map(level=>`<th class=num>${esc(level)}</th>`).join('')}</tr></thead><tbody>${groups.map(group=>`<tr><td>${group==='complex'?'Complex+':esc(WORK_COMPLEXITY_LABELS[group])}</td>${effort.efforts.map(level=>{const item=cell(group,level);if(!item||!item.requests)return '<td class="num workMuted">--</td>';return `<td class="num mono workFitCell"><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify({complexity:group,effort:level}))}" data-drill-label="${esc(`${group==='complex'?'Complex+':WORK_COMPLEXITY_LABELS[group]} · ${level} effort`)}">${money(item.spend)}${item.flag?'<span class=workFitBest style="color:var(--warn);border-color:rgb(var(--orange-rgb)/.5)">▲ Overthinking?</span>':''}<small>${item.requests} · rework ${item.rework?workRateText(item.rework):'--'}</small></button></td>`;}).join('')}</tr>`).join('')}</tbody>`;
-}
-const WORK_TIER_COLORS={light:'var(--w-tier-light)',standard:'var(--w-tier-standard)',premium:'var(--w-tier-premium)'};
-const WORK_EFFORT_BANDS=[{key:'default',label:'Default',levels:['default'],note:'not recorded'},{key:'normal',label:'Low–medium',levels:['low','medium']},{key:'high',label:'High',levels:['high']},{key:'extra',label:'Extra high+',levels:['xhigh','max','ultra']}];
-const WORK_EFFORT_BAND_COLORS={default:'var(--w-unclear)',normal:'var(--w-tier-light)',high:'var(--w-tier-standard)',extra:'var(--w-tier-premium)'};
-const WORK_EFFORT_COLORS={low:'var(--w-e1)',medium:'var(--w-e2)',high:'var(--w-e3)',xhigh:'var(--w-e4)',max:'var(--w-e5)',ultra:'var(--w-e6)'};
-const WORK_GROUP_LABELS={routine:'Routine',everyday:'Everyday',complex:'Complex+'};
-function workMeter(rate,max,{few=false,color=''}={}){
- if(rate==null)return '<span class=workMuted>--</span>';
- return `<span class=workMeter data-few="${few}"${few?' title="Fewer than 20 labeled turns"':''}><i><b style="width:${(100*Math.min(1,rate/Math.max(1e-9,max))).toFixed(1)}%${color?`;--meter:${color}`:''}"></b></i><em class=mono>${workPercent(rate)}</em></span>`;
-}
-let workScoreSort={key:'spend',direction:'desc'};
-const WORK_SCORE_COLUMNS=[['model','Model'],['tasks','Tasks'],['spend','Spend'],['pushback','Pushback'],['resolved_rate','Resolved'],['cost_per_resolved','Per resolved'],
- ['kinds','Best / weakest at','Kinds of work where this model drew the least (best) or most (weakest) pushback among models with 20+ labeled follow-ups and 3+ sessions. Sorts by how many it is best at.']];
-function workScoreValue(row,key){
- if(key==='model')return `${row.model} ${row.runtime}`.toLowerCase();
- if(key==='pushback')return row.rework?row.rework.rate:null;
- if(key==='kinds')return (row.best_at||[]).length*100-(row.worst_at||[]).length;
- return row[key]??null;
-}
-function sortWorkScore(rows,sort=workScoreSort){
- const sign=sort.direction==='asc'?1:-1;
- return [...rows].sort((a,b)=>{const x=workScoreValue(a,sort.key),y=workScoreValue(b,sort.key);
-  if(x==null&&y==null)return b.spend-a.spend;if(x==null)return 1;if(y==null)return -1;
-  return (x<y?-1:x>y?1:0)*sign||b.spend-a.spend;});
-}
-function renderWorkScorecard(insights){
- const rows=insights?.model_scorecard||[],table=$('w-scorecard');
- if(!rows.length){table.innerHTML='<tbody><tr><td><div class=workEmpty>Waiting for sessions in this period.</div></td></tr></tbody>';return;}
- // Colors follow spend rank, so a model keeps its color however the table is sorted.
- const identities=rows.map(row=>`${row.model}::${row.runtime}`);
- const maxPush=Math.max(.05,...rows.map(row=>row.rework?.rate||0)),ranked=rows.filter(row=>row.cost_per_resolved!=null&&row.judged_tasks>=5&&(row.judged_sessions??0)>=3);
- const lowestCost=ranked.length>=2?Math.min(...ranked.map(row=>row.cost_per_resolved)):null;
- const kindChips=(label,list,tone)=>list&&list.length?`<div class=workScoreKinds><small>${label}</small>${list.map(kind=>`<span class="chip${tone?` ${tone}`:''}">${esc(WORK_TYPE_LABELS[kind]||kind)}</span>`).join('')}</div>`:'';
- const kinds=row=>kindChips('Best',row.best_at,'')+kindChips('Weakest',row.worst_at,'tone-warn')||'<span class=workMuted>--</span>';
- const head=WORK_SCORE_COLUMNS.map(([key,label,tip])=>{const active=workScoreSort.key===key;
-  return `<th aria-sort="${active?(workScoreSort.direction==='asc'?'ascending':'descending'):'none'}"><button class=efficiencySort type=button data-work-score-sort=${key}${tip?` title="${esc(tip)}"`:''}>${esc(label)}<span class=efficiencySortMark aria-hidden=true>${active?(workScoreSort.direction==='asc'?'↑':'↓'):''}</span></button></th>`;}).join('');
- table.innerHTML=`<thead><tr>${head}</tr></thead><tbody>${sortWorkScore(rows).map(row=>{
-  const few=!row.rework||row.rework.few_samples,best=lowestCost!=null&&ranked.includes(row)&&row.cost_per_resolved===lowestCost,thin=row.judged_tasks<5,identity=`${row.model}::${row.runtime}`;
-  return `<tr><td><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify({model:row.model,model_runtime:row.runtime}))}" data-drill-label="${esc(`${row.model} · ${row.runtime}`)}"><i class=workScoreDot style="--swatch:${modelColor(identity,identities)}"></i><span class=workScoreName><b>${esc(row.model)}</b><small>${esc(row.runtime)}${row.tier?` · ${esc(WORK_TIER_LABELS[row.tier]||row.tier)}`:''}</small></span></button></td><td><span class=mono>${row.tasks.toLocaleString()}</span></td><td><span class=mono>${money(row.spend)}</span></td><td><span>${row.rework?workMeter(row.rework.rate,maxPush,{few}):'<span class=workMuted>--</span>'}</span></td><td><span class=mono>${row.resolved_rate==null?'<span class=workMuted>--</span>':thin?`<span class=workMuted title="${esc(`${row.judged_tasks} judged task${row.judged_tasks===1?'':'s'}`)}">${workPercent(row.resolved_rate)} · few</span>`:workPercent(row.resolved_rate)}</span></td><td><span class=mono${best?' style="color:var(--good)"':''}>${row.cost_per_resolved==null?'<span class=workMuted>--</span>':money(row.cost_per_resolved)}${best?'<em class=workLowest>lowest</em>':''}</span></td><td>${kinds(row)}</td></tr>`;
- }).join('')}</tbody>`;
-}
-$('w-scorecard').addEventListener('click',event=>{const button=event.target.closest('[data-work-score-sort]');if(!button)return;event.stopPropagation();const key=button.dataset.workScoreSort;
- workScoreSort=workScoreSort.key===key?{key,direction:workScoreSort.direction==='desc'?'asc':'desc'}:{key,direction:key==='model'?'asc':'desc'};if(WORK)renderWorkScorecard(WORK.insights);});
-function workMixRows(groups,levels,cellFor,colorFor,labelFor,drillFor,flagged){
- return groups.map(group=>{
-  const cells=levels.map(level=>({level,cell:cellFor(group,level)})).filter(item=>item.cell&&item.cell.spend>0);
-  const total=cells.reduce((sum,item)=>sum+item.cell.spend,0);
-  if(!total)return `<div class=workMixRow><span class=workMixLabel>${esc(WORK_GROUP_LABELS[group])}</span><div class=workStack></div><span class="workMixTotal workMuted">--</span></div>`;
-  return `<div class=workMixRow><span class=workMixLabel>${esc(WORK_GROUP_LABELS[group])}</span><div class=workStack>${cells.map(({level,cell})=>{const share=cell.spend/total;return `<button type=button style="flex:${share.toFixed(4)} 0 0;--seg:${colorFor(level)}" data-flag="${flagged(cell)}" data-drill="${esc(JSON.stringify(drillFor(group,level)))}" data-drill-label="${esc(`${WORK_GROUP_LABELS[group]} · ${labelFor(level)}`)}" title="${esc(`${WORK_GROUP_LABELS[group]} · ${labelFor(level)}: ${money(cell.spend)} · ${workPercent(share)} · ${cell.requests} request${cell.requests===1?'':'s'}${cell.rework?` · pushback ${workPercent(cell.rework.rate)}`:''}${flagged(cell)?` · ${workFlagReason(cell)}`:''}`)}" aria-label="${esc(`${WORK_GROUP_LABELS[group]}, ${labelFor(level)}, ${money(cell.spend)}, ${workPercent(share)} of spend`)}">${share>=.14?`<span>${workPercent(share)}</span>`:''}</button>`;}).join('')}</div><span class=workMixTotal>${money(total)}</span></div>`;
- }).join('');
-}
-function renderWorkMix(insights){
- const sizing=insights?.right_sizing||{},groups=['routine','everyday','complex'],tiers=['light','standard','premium'];
- const tierHost=$('w-tier-mix'),effortHost=$('w-effort-mix');
- if(!sizing.tiers_known){tierHost.innerHTML='<div class=workEmpty>Model price tiers are unavailable for these sessions.</div>';}
- else{
-  const cell=(group,tier)=>(sizing.cells||[]).find(item=>item.complexity===group&&item.tier===tier);
-  tierHost.innerHTML=workMixRows(groups,tiers,cell,tier=>WORK_TIER_COLORS[tier],tier=>WORK_TIER_LABELS[tier],(group,tier)=>({complexity:group,tier}),item=>Boolean(item.flag))+`<div class=workMixLegend>${tiers.map(tier=>`<span><i style="--swatch:${WORK_TIER_COLORS[tier]}"></i>${esc(WORK_TIER_LABELS[tier])}</span>`).join('')}<span><i class=flag></i>Premium on routine · light on complex</span></div>`;
- }
- const effort=sizing.effort||{},levels=effort.efforts||[];
- if(!levels.length){effortHost.innerHTML='<div class=workEmpty>No reasoning-effort data for these sessions.</div>';}
- else{
-  // Effort levels are folded into readable groups (unrecorded ones into Default); the tables below keep every level.
-  const bands=WORK_EFFORT_BANDS.map(band=>({...band,levels:band.levels.filter(level=>levels.includes(level))})).filter(band=>band.levels.length);
-  const cell=(group,key)=>{
-   const band=bands.find(item=>item.key===key),members=(effort.cells||[]).filter(item=>item.complexity===group&&band.levels.includes(item.effort));
-   if(!members.length)return null;
-   const samples=members.reduce((sum,item)=>sum+(item.rework?.samples||0),0),hits=members.reduce((sum,item)=>sum+(item.rework?(item.rework.rate*item.rework.samples):0),0);
-   return {spend:members.reduce((sum,item)=>sum+item.spend,0),requests:members.reduce((sum,item)=>sum+item.requests,0),flag:members.some(item=>item.flag)?'possible_overthinking':'',rework:samples?{rate:hits/samples,samples}:null,levels:members.filter(item=>item.requests).map(item=>item.effort)};
-  };
-  effortHost.innerHTML=workMixRows(groups,bands.map(band=>band.key),cell,key=>WORK_EFFORT_BAND_COLORS[key],key=>bands.find(band=>band.key===key).label,(group,key)=>({complexity:group,effort:(cell(group,key)?.levels||[]).join(',')}),item=>Boolean(item.flag))+`<div class=workMixLegend>${bands.map(band=>`<span><i style="--swatch:${WORK_EFFORT_BAND_COLORS[band.key]}"></i>${esc(band.label)}<small>${esc(band.note||band.levels.join(', '))}</small></span>`).join('')}<span><i class="flag effort"></i>High effort on routine work</span></div>`;
- }
-}
-function workFlagReason(cell){
- return {possible_overspend:'premium model on routine work',possible_false_economy:'light model on complex work',possible_overthinking:'high effort on routine work'}[cell?.flag]||'worth reviewing';
-}
-function workSuggestion(item){
- const work=WORK_TYPE_LABELS[item.work_type]||item.work_type||'';
- switch(item.kind){
-  case 'premium_routine':{
-   const from=(item.from_models||[]).map(entry=>entry.model).join(', ');
-   const to=(item.to_models||[]).map(entry=>`${entry.model} in ${entry.runtime}`).join(' or ');
-   return{title:to?`Try ${to} for routine work`:'Use a cheaper model for routine work',detail:`${item.requests.toLocaleString()} routine request${item.requests===1?'':'s'} ran on your most expensive models${from?` (${from})`:''}.${to?` ${item.to_models.length===1?'That model is':'Those are'} your most-used mid-priced model${item.to_models.length===1?'':'s'} in the same app.`:''}`,drill:{complexity:item.complexity,tier:item.tier}};
-  }
-  case 'family_upgrade':return{title:`Use ${item.to_model} instead of ${item.model}`,detail:`A newer version in ${item.runtime}: ${Math.round(100*(1-item.to_price/item.from_price))}% cheaper per token. It resolved ${workPercent(item.to_rate)} of your tasks, vs ${workPercent(item.from_rate)} on ${item.model}.`,drill:{model:item.model,model_runtime:item.runtime}};
-  case 'effort_routine':return{title:`Lower reasoning effort on routine work`,detail:`${item.requests.toLocaleString()} routine request${item.requests===1?'':'s'} used ${item.effort} effort.`,drill:{complexity:item.complexity,effort:item.effort}};
-  case 'light_complex':return{title:'Use a stronger model for complex work',detail:`Complex work on light models got pushback on ${workPercent(item.rework?.rate)} of follow-ups.`,drill:{complexity:item.complexity,tier:item.tier}};
-  case 'switch_model':{
-   const level={routine:'routine',everyday:'everyday',complex:'complex'}[item.complexity]||'',app=item.to_runtime&&item.to_runtime!==item.runtime?` in ${item.to_runtime}`:'';
-   return{title:`Try ${item.to_model}${app} for ${level} ${item.work_type==='other'?'non-software requests':work.toLowerCase()}`,detail:`On ${level} requests: ${workPercent(item.to_rate)} resolved at ${money(item.to_cost)} per resolved task, vs ${workPercent(item.from_rate)} at ${money(item.from_cost)} on ${item.model} (${item.runtime})${item.to_pushback!=null&&item.from_pushback!=null?`; pushback ${workPercent(item.to_pushback)} vs ${workPercent(item.from_pushback)}`:''}.${item.to_untested_harder?` Keep ${item.model} for harder work: ${item.to_model} hasn’t been used on it yet.`:''}`,drill:{work_type:item.work_type,complexity:item.complexity,model:item.model,model_runtime:item.runtime}};
-  }
-  case 'long_threads':return{title:'Start a fresh session sooner',detail:`Sessions with ${item.threshold_turns}+ requests cost ${item.ratio.toFixed(1)}× more per request than short ones, because each request re-sends the growing context.`,drill:{tag:'long_thread'}};
-  default:return{title:item.kind,detail:'',drill:null};
- }
-}
-function workSuggestionBasis(item){
- const [count,unit]=item.requests!=null?[item.requests,'request']:item.tasks!=null?[item.tasks,'task']:[item.sessions||0,'session'];
- return `${count.toLocaleString()} ${unit}${count===1?'':'s'}`;
-}
-const WORK_MODEL_SUGGESTIONS=['family_upgrade','switch_model','premium_routine','light_complex'];
-function workDollars(value){return value>0&&value<1?money(value):`$${Math.round(value||0).toLocaleString()}`;}
-function workModelSwap(item){
- const short=name=>String(name||'').replace(/^claude-/,'');
- switch(item.kind){
-  case 'family_upgrade':return{from:short(item.model),to:short(item.to_model),note:`resolves ${item.to_rate>=item.from_rate?'as often':'about as often'} · ${workPercent(item.from_rate)} → ${workPercent(item.to_rate)}`};
-  case 'switch_model':return{from:short(item.model),to:short(item.to_model),note:`${item.complexity?`${item.complexity} work · `:''}${workPercent(item.from_rate)} → ${workPercent(item.to_rate)}`};
-  case 'premium_routine':return{from:'premium models',to:short(item.to_models?.[0]?.model)||'mid-priced',note:`routine work · ${(item.requests||0).toLocaleString()} requests`};
-  case 'light_complex':return{from:'light models',to:'a stronger model',note:`complex work · ${workPercent(item.rework?.rate)} pushback`};
-  default:return{from:'',to:'',note:''};
- }
-}
-function workSparkline(points){
- const usable=points.filter(point=>point.rate!=null);
- if(usable.length<2)return '';
- const W=300,H=44,max=Math.max(...usable.map(point=>point.rate),0.01),x=index=>(W*index/(usable.length-1)).toFixed(1),y=rate=>(H-3-(H-8)*rate/max).toFixed(1);
- const line=usable.map((point,index)=>`${x(index)},${y(point.rate)}`).join(' '),last=usable[usable.length-1];
- return `<svg class=workSuggestSpark viewBox="0 0 ${W} ${H+10}" role=img aria-label="Pushback rate by week"><polyline fill=none stroke="var(--warn)" stroke-width=2 stroke-linejoin=round points="${line}"/><circle cx="${x(usable.length-1)}" cy="${y(last.rate)}" r=3.5 fill="var(--warn)"/><text x=0 y="${H+9}" fill="var(--faint)" font-size=9>${esc(usable[0].label)}</text><text x="${W-2}" y="${H+9}" fill="var(--faint)" font-size=9 text-anchor=end>${esc(last.label)}</text></svg>`;
-}
-// Effort by model: one model at a time, because a level such as "high" means different things on different models.
-let workEffortModel=localStorage.getItem('tm_work_effort_model')||'',workEffortGridHtml='';
-const WORK_EFFORT_ROWS={routine:'Routine',everyday:'Everyday',complex:'Complex+'};
-function workEffortRate(rework){return rework?`${Math.round(rework.rate*100)}%`:'';}
-function workEffortVerdict(verdict){
- const row=esc(WORK_EFFORT_ROWS[verdict.complexity]||verdict.complexity),evidence=`${workEffortRate({rate:verdict.lower_rate})} vs ${workEffortRate({rate:verdict.higher_rate})} pushback`;
- const title=esc(`From ${verdict.lower_samples} and ${verdict.higher_samples} labeled follow-ups, 99% confidence`);
- if(verdict.kind==='lower')return `<li data-kind=lower title="${title}"><b>${row}: ${esc(verdict.higher)} → ${esc(verdict.lower)} looks safe</b> · ${evidence} · saves ${money(verdict.saving)}</li>`;
- return `<li data-kind=raise title="${title}"><b>${row}: raise ${esc(verdict.lower)} → ${esc(verdict.higher)}</b> · ${evidence}</li>`;
-}
-function renderWorkEffortModels(insights){
- const data=insights?.effort_by_model||{},models=data.models||[],box=$('w-effort-models');
- box.hidden=!insights||!models.length; // only models with labeled requests
- if(!models.length)return;
- // JSON rather than a NUL-joined key: the HTML parser rewrites NUL inside attributes.
- const key=model=>JSON.stringify([model.model,model.runtime]);
- const chosen=models.find(model=>key(model)===workEffortModel)||models[0];
- $('w-effort-model').innerHTML=models.map(model=>`<option value="${esc(key(model))}"${model===chosen?' selected':''}>${esc(model.model)} · ${esc(model.runtime)}</option>`).join('');
- const efforts=chosen.efforts||[],grid=$('w-effort-grid');
- // One number per cell (pushback); cost per request sits once per effort column.
- const columnCost=effort=>{let spend=0,requests=0;(chosen.rows||[]).forEach(row=>{const cell=(row.cells||[]).find(item=>item.effort===effort);if(cell&&cell.cost_per_request!=null){spend+=cell.spend;requests+=cell.requests;}});return requests?spend/requests:null;};
- grid.style.gridTemplateColumns=`110px repeat(${efforts.length},minmax(72px,1fr))`;
- const head=`<div role=row style="display:contents"><div class=workSizingHead role=columnheader></div>${efforts.map(effort=>{const cost=columnCost(effort);const tip=esc('No effort recorded: the app\'s default level');return `<div class="workSizingHead workEffortHead${effort==='default'?' fieldtip':''}" role=columnheader${effort==='default'?` tabindex=0 aria-description="${tip}" data-tip="${tip}"`:''}>${esc(effort)}${cost!=null?`<small>${money(cost)}/req</small>`:''}</div>`;}).join('')}</div>`;
- const html=head+(chosen.rows||[]).map(row=>`<div role=row style="display:contents"><div class=workSizingRowHead role=rowheader>${esc(WORK_EFFORT_ROWS[row.complexity]||row.complexity)}</div>${(row.cells||[]).map(cell=>{
-  if(!cell.requests)return '<div class=workEffortCell data-empty role=cell aria-label="No requests">·</div>';
-  const cost=cell.cost_per_request!=null?`${money(cell.cost_per_request)}/request`:'cost unavailable';
-  const label=`${WORK_EFFORT_ROWS[row.complexity]||row.complexity} at ${cell.effort}: `;
-  if(!cell.rework||cell.rework.few_samples){const detail=`${label}too few labeled follow-ups (${cell.rework?.samples||0}) · ${f(cell.requests)} requests · ${cost}`;return `<div class=workEffortCell data-few role=cell tabindex=0 data-cell="${esc(row.complexity+':'+cell.effort)}" title="${esc(detail)}" aria-label="${esc(detail)}" data-detail="${esc(detail)}">·</div>`;}
-  const heat=Math.min(.32,cell.rework.rate*.8).toFixed(3);
-  const detail=`${label}${workEffortRate(cell.rework)} pushback · ${f(cell.rework.samples)} labeled follow-ups · ${f(cell.requests)} requests · ${cost}`;
-  return `<div class=workEffortCell role=cell tabindex=0 data-cell="${esc(row.complexity+':'+cell.effort)}" style="--heat:${heat}" title="${esc(detail)}" aria-label="${esc(detail)}" data-detail="${esc(detail)}">${workEffortRate(cell.rework)}</div>`;
- }).join('')}</div>`).join('');
- // The Work poll re-renders every few seconds: leave unchanged cells alone, and keep focus on the same cell when they do change.
- if(html!==workEffortGridHtml){
-  const focused=grid.contains?.(document.activeElement)?document.activeElement.dataset.cell:'';
-  grid.innerHTML=workEffortGridHtml=html;
-  const again=focused&&[...grid.querySelectorAll('[data-cell]')].find(node=>node.dataset.cell===focused);
-  if(again){again.focus();$('w-effort-detail').textContent=again.dataset.detail;}
-  else $('w-effort-detail').textContent='';
- }
- const verdicts=chosen.verdicts||[];
- $('w-effort-verdicts').innerHTML=verdicts.map(workEffortVerdict).join('');
- $('w-effort-note').textContent=`Faint dots: too few follow-ups${data.unrecorded_spend>0?` · ${money(data.unrecorded_spend)} without a recorded effort left out`:''}`;
-}
-// A cell's evidence for keyboard, touch, and pointer alike: focusing, tapping, or hovering shows it under the table.
-['focusin','mouseover'].forEach(type=>$('w-effort-grid').addEventListener(type,event=>{
- const cell=event.target.closest('[data-detail]');
- if(cell)$('w-effort-detail').textContent=cell.dataset.detail;
-}));
-$('w-effort-model').addEventListener('change',event=>{
- workEffortModel=event.target.value;localStorage.setItem('tm_work_effort_model',workEffortModel);
- $('w-effort-detail').textContent='';
- if(WORK?.insights)renderWorkEffortModels(WORK.insights);
-});
-function renderWorkSuggestCards(insights){
- const rows=insights?.recommendations||[],box=$('w-suggest-cards');
- const drill=item=>{const tip=workSuggestion(item);return tip.drill?` data-drill="${esc(JSON.stringify(tip.drill))}" data-drill-label="${esc(tip.title)}"`:'';};
- // Models
- const models=rows.filter(item=>WORK_MODEL_SUGGESTIONS.includes(item.kind)).sort((a,b)=>(b.saving||0)-(a.saving||0));
- const best=models.find(item=>(item.saving||0)>0);
- const modelRows=models.slice(0,3).map(item=>{const swap=workModelSwap(item);return `<button type=button class=workDrillBtn${drill(item)} title="${esc(swap.note)}"><span class=workSwap>${esc(swap.from)}<b>→</b>${esc(swap.to)}</span><span class=workSwapSave>${item.saving>0?workDollars(item.saving):'--'}</span></button>`;}).join('');
- const modelCard=`<div class=workSuggestCard><div class=workSuggestEyebrow><i style="background:var(--good)"></i>Model suggestions</div>${models.length?`<div class=workSuggestHero>${best?`${workDollars(best.saving)}<small title="Savings can overlap">biggest saving</small>`:`${models.length}<small>model suggestion${models.length===1?'':'s'}</small>`}</div><div class=workSuggestRows>${modelRows}</div><div class=workSuggestFoot><span>${models.length>3?`+${models.length-3} more`:''}</span><button type=button data-open-sizing-tables>See all</button></div>`:'<div class=workSuggestEmpty>No model changes suggested for this period.</div>'}</div>`;
- // Reasoning
- // Several high levels can be flagged at once (for example xhigh and max): count them together.
- const efforts=rows.filter(item=>item.kind==='effort_routine').sort((a,b)=>(b.spend||0)-(a.spend||0));
- // The drill filter takes a comma-separated effort list; the card shows the levels joined with "or".
- const effort=efforts.length?{...efforts[0],requests:efforts.reduce((sum,item)=>sum+(item.requests||0),0),spend:efforts.reduce((sum,item)=>sum+(item.spend||0),0),effort:efforts.map(item=>item.effort).join(','),label:efforts.map(item=>item.effort).join(' or ')}:null;
- const cells=(insights?.right_sizing?.effort?.cells||[]).filter(cell=>cell.complexity==='routine'&&cell.spend>0).sort((a,b)=>b.spend-a.spend);
- const routineSpend=cells.reduce((sum,cell)=>sum+cell.spend,0),shades=['var(--reason)','var(--w-routine-2)','var(--w-routine-3)','var(--w-routine-4)'];
- const shown=cells.slice(0,3),rest=routineSpend-shown.reduce((sum,cell)=>sum+cell.spend,0);
- const parts=[...shown.map(cell=>({label:cell.effort||'unknown',spend:cell.spend})),...(rest>0?[{label:'other',spend:rest}]:[])];
- const bar=routineSpend?`<div class=workSuggestBar role=img aria-label="Routine spend by reasoning effort">${parts.map((part,index)=>`<span style="flex:${part.spend.toFixed(4)};background:${shades[index]}"></span>`).join('')}</div><div class=workSuggestLegend>${parts.map((part,index)=>`<span><i style="background:${shades[index]}"></i>${esc(part.label)}</span>`).join('')}</div>`:'';
- const effortCard=`<div class=workSuggestCard><div class=workSuggestEyebrow><i style="background:var(--reason)"></i>Reasoning suggestions</div>${effort?`<div class=workSuggestHero>${(effort.requests||0).toLocaleString()}<small>routine request${effort.requests===1?'':'s'} ran at ${esc(effort.label)} effort</small></div>`:`<div class=workSuggestEmpty>No reasoning changes suggested for this period.</div>`}${bar}<div class=workSuggestFoot><span></span>${effort&&drill(effort)?`<button type=button${drill(effort)}>Open requests</button>`:''}</div></div>`;
- // Pushback
- const rework=insights?.rework||{},overall=rework.overall||{};
- const weekly=(rework.weekly||[]).filter(point=>point.samples>=20).map(point=>({rate:point.rate,label:workMonthName(point.week,{year:false})}));
- // Least and most need 50+ judged follow-ups each and a gap bigger than noise (two-proportion check, about 95%).
- const ranked=(rework.models||[]).filter(model=>model.samples>=50&&model.rate!=null&&model.model&&model.model!=='unknown-model').sort((a,b)=>a.rate-b.rate);
- const lo=ranked[0],hi=ranked[ranked.length-1],pooled=ranked.length>1?(lo.rate*lo.samples+hi.rate*hi.samples)/(lo.samples+hi.samples):0;
- const distinct=ranked.length>1&&hi.rate-lo.rate>1.96*Math.sqrt(pooled*(1-pooled)*(1/lo.samples+1/hi.samples));
- const chip=(label,model)=>model?`<div><span>${label}</span><b title="${esc(model.model)} · ${esc(model.runtime)}">${esc(model.model.replace(/^claude-/,''))} <s>${workPercent(model.rate)}</s></b></div>`:'';
- const pushCard=`<div class=workSuggestCard><div class=workSuggestEyebrow><i style="background:var(--warn)"></i>Pushback</div>${overall.samples?`<div class=workSuggestHero>${workPercent(overall.rate)}<small>of ${overall.samples.toLocaleString()} follow-ups pushed back${overall.few_samples?' · few samples':''}</small></div>${workSparkline(weekly)}${distinct?`<div class=workSuggestChips>${chip('Least pushback',lo)}${chip('Most pushback',hi)}</div>`:''}<div class=workSuggestFoot><span></span><button type=button data-scroll-work=w-module-rework>Pushback over time</button></div>`:'<div class=workSuggestEmpty>No labeled follow-ups in this period yet.</div>'}</div>`;
- box.innerHTML=modelCard+effortCard+pushCard;
-}
-function renderWorkOpportunities(insights){
- const rows=insights?.recommendations||[],table=$('w-opportunities');
- renderWorkSuggestCards(insights);
- if(!rows.length){table.innerHTML='';return;}
- table.innerHTML=`<thead><tr><th>Suggestion</th><th>Based on</th><th>Spend</th><th>Possible saving</th></tr></thead><tbody>${rows.map(item=>{
-  const tip=workSuggestion(item);
-  const label=tip.drill?`<button type=button class=workDrillBtn data-drill="${esc(JSON.stringify(tip.drill))}" data-drill-label="${esc(tip.title)}"><span class=workIssueKind aria-hidden=true>▲</span><span class=workSuggestion><b>${esc(tip.title)}</b><small>${esc(tip.detail)}</small></span></button>`:esc(tip.title);
-  return `<tr><td>${label}</td><td><span class=mono>${esc(workSuggestionBasis(item))}</span></td><td><span class=mono>${money(item.spend)}</span></td><td><span class=mono>${item.saving!=null&&item.saving>0?`<span style="color:var(--good)">${money(item.saving)}</span> est`:'<span class=workMuted>--</span>'}</span></td></tr>`;
- }).join('')}</tbody>`;
-}
-function renderWorkFilters(insights){
- const filters=insights?.filters||{};
- $('w-runtime').innerHTML='<option value="">All apps</option>'+(filters.runtimes||[]).map(value=>`<option value="${esc(value)}"${value===workRuntime?' selected':''}>${esc(value)}</option>`).join('');
- const projects=filters.projects||[];
- if(workProject&&!projects.includes(workProject))projects.unshift(workProject);
- $('w-project').innerHTML='<option value="">All projects</option>'+projects.map(value=>`<option value="${esc(value)}"${value===workProject?' selected':''}>${esc(deliveryProjectName(value))}</option>`).join('');
-}
-const WORK_OUTCOME_LABELS={accepted:'Accepted without pushback',recovered:'Recovered after pushback',ended_on_pushback:'Ended on pushback',unclear:'Unclear',single_shot:'Single request',pending:'Not labeled yet'};
-const WORK_OUTCOME_COLORS={accepted:'var(--w-accepted)',recovered:'var(--w-recovered)',ended_on_pushback:'var(--w-ended)',unclear:'var(--w-unclear)',single_shot:'var(--w-single)',pending:'var(--w-pending)'};
-function renderWorkFit(insights){
- const fit=insights?.model_fit||{},models=fit.models||[],table=$('w-fit-table');
- if(!models.length||!(fit.work_types||[]).length){table.innerHTML='<tbody><tr><td><div class=workEmpty>Waiting for labeled sessions.</div></td></tr></tbody>';return;}
- const cell=(work,model)=>(fit.cells||[]).find(item=>item.work_type===work&&item.model===model.model&&item.runtime===model.runtime);
- table.innerHTML=`<thead><tr><th>Work type</th>${models.map(model=>`<th class=num title="${esc(model.runtime)} · ${model.tasks} tasks">${esc(model.model)}<br><small class=workMuted>${esc(model.runtime)}</small></th>`).join('')}</tr></thead><tbody>${fit.work_types.map(work=>`<tr><td>${esc(WORK_TYPE_LABELS[work]||work)}</td>${models.map(model=>{const item=cell(work,model);if(!item||!item.tasks)return '<td class="num workMuted">--</td>';return `<td class="num mono workFitCell"><button type=button class=workDrillBtn data-drill="${esc(JSON.stringify({work_type:work,model:model.model,model_runtime:model.runtime}))}" data-drill-label="${esc(`${WORK_TYPE_LABELS[work]||work} · ${model.model}`)}">${workRateText(item.rework)}${item.best?'<span class=workFitBest>Best</span>':''}<small>${item.tasks} · ${money(item.cost_per_task)}/task</small></button></td>`;}).join('')}</tr>`).join('')}</tbody>`;
-}
-$('view-work').addEventListener('click',event=>{
- const tables=event.target.closest('[data-open-sizing-tables]');
- if(tables){const details=$('w-sizing-tables');details.open=true;details.scrollIntoView({behavior:'smooth',block:'start'});return;}
- const scroll=event.target.closest('[data-scroll-work]');
- if(scroll){$(scroll.dataset.scrollWork)?.scrollIntoView({behavior:'smooth',block:'start'});return;}
- const single=event.target.closest('[data-open-work-session]');
- if(single){selectSession(single.dataset.openWorkSession,{returnScope:'all'});return;}
- const target=event.target.closest('[data-drill]');if(!target)return;
- let filters={};try{filters=JSON.parse(target.dataset.drill);}catch(error){return;}
- openWorkSessions(filters,target.dataset.drillLabel);
-});
-let workResizeTimer=0;
-window.addEventListener('resize',()=>{clearTimeout(workResizeTimer);workResizeTimer=setTimeout(()=>{if(WORK&&$('view-work').classList.contains('on')){renderWorkRework(WORK.insights);renderWorkAgentTrend(WORK.insights);}},150);});
-function workHours(seconds){const minutes=Math.round((seconds||0)/60);return minutes>=90?`${(minutes/60).toFixed(minutes%60?1:0)} h`:`${minutes} min`;}
-const WORK_BANDS={night:['Night','midnight–6 am'],morning:['Morning','6 am–noon'],afternoon:['Afternoon','noon–6 pm'],evening:['Evening','6 pm–midnight']};
-const WORK_TAG_INFO={
- marathon:['Marathon',t=>`More than ${workHours(t.marathon_s)} of active time`,'var(--w5)'],
- big_spend:['Big spender',t=>`Top 10% by cost, over ${money(t.big_spend)}`,'var(--w2)'],
- team:['Subagent team',t=>`${t.team_children} or more subagent runs`,'var(--w7)'],
- overkill:['Overkill',()=>'Routine work on a premium model or high effort','var(--warn)'],
- underpowered:['Underpowered',()=>'Complex work on a light model that got pushback','var(--warn)'],
- rescued:['Rescued',()=>'Back on track after a pushback','var(--w-recovered)'],
- stuck:['Ended on pushback',()=>'The last follow-up was a pushback','var(--bad)'],
- one_shot:['One-shot',()=>'Done in a single request','var(--good)'],
- long_thread:['Long thread',()=>'30 or more requests in one session','var(--w1)'],
-};
-function renderWorkTagCards(insights){
- const tags=insights?.tags||{},items=tags.items||[],thresholds=tags.thresholds||{},host=$('w-tags');
- const sessions=insights?.coverage?.sessions||0;
- $('w-tags-note').textContent=items.length?`${sessions.toLocaleString()} sessions`:'';
- host.innerHTML=items.length?items.map(item=>{
-  const [name,describe,tone]=WORK_TAG_INFO[item.tag]||[item.tag,()=>'','var(--w-unclear)'];
-  const stats=[money(item.spend),item.share!=null?`${workPercent(item.share)} of spend`:'',item.resolved_rate!=null&&item.judged_sessions>=5?`${workPercent(item.resolved_rate)} resolved`:''].filter(Boolean).join(' · ');
-  return `<button type=button class=workTagTile style="--tone:${tone}" data-drill="${esc(JSON.stringify({tag:item.tag}))}" data-drill-label="${esc(name)}"><span class=workTagName><i aria-hidden=true></i>${esc(name)}</span><strong class=num>${item.sessions.toLocaleString()}</strong><span class=workTagStats>${esc(stats)}</span><small>${esc(describe(thresholds))}</small></button>`;
- }).join(''):'<div class=workEmpty>No sessions in this period yet.</div>';
-}
-function renderWorkRhythm(insights){
- const rhythm=insights?.rhythm||{},cells=rhythm.cells||[],heat=$('w-heat'),bands=rhythm.bands||[];
- const days=['Mon','Tue','Wed','Thu','Fri','Sat','Sun'],max=Math.max(1,...cells.map(cell=>cell.sessions));
- const lookup=new Map(cells.map(cell=>[`${cell.weekday}:${cell.hour}`,cell]));
- const busiest=cells.length?cells.reduce((a,b)=>b.sessions>a.sessions?b:a):null;
- const hourText=hour=>new Date(2000,0,1,hour).toLocaleTimeString([],{hour:'numeric'});
- $('w-rhythm-note').textContent=busiest?`${(rhythm.sessions||0).toLocaleString()} sessions · most start on ${days[busiest.weekday]} around ${new Date(2000,0,1,busiest.hour).toLocaleTimeString([],{hour:'numeric',minute:'2-digit'})}`:'';
- heat.innerHTML=cells.length?days.map((day,weekday)=>`<span>${day}</span>${Array.from({length:24},(_,hour)=>{const cell=lookup.get(`${weekday}:${hour}`);return cell?`<i data-v style="--v:${(0.2+0.8*cell.sessions/max).toFixed(2)}" title="${esc(`${day} ${hourText(hour)} · ${cell.sessions} session${cell.sessions===1?'':'s'} · ${money(cell.spend)}`)}"></i>`:'<i></i>';}).join('')}`).join('')+`<span></span>${[0,6,12,18].map(hour=>`<span class=h>${esc(hourText(hour))}</span>`).join('')}`:'<div class=workEmpty style="grid-column:1/-1">No session start times in this period.</div>';
- const total=bands.reduce((sum,band)=>sum+band.sessions,0),maxRate=Math.max(.05,...bands.map(band=>band.pushback?.rate||0));
- $('w-bands').innerHTML=total?bands.filter(band=>band.sessions).map(band=>{const [name,range]=WORK_BANDS[band.band]||[band.band,''];const few=!band.pushback||band.pushback.few_samples;return `<div class=workBand data-few="${few}"><span>${esc(name)}<small>${esc(range)}</small></span><span class=workBarTrack><i style="width:${band.pushback?(100*band.pushback.rate/maxRate).toFixed(1):0}%"></i></span><b class=num>${band.pushback?workPercent(band.pushback.rate):'--'}</b><small>${band.sessions.toLocaleString()} session${band.sessions===1?'':'s'} · ${money(band.spend)}${few&&band.pushback?' · few follow-ups':''}</small></div>`;}).join(''):'';
- const solid=bands.filter(band=>band.pushback&&!band.pushback.few_samples);
- let note='';
- if(solid.length>=2){
-  const high=solid.reduce((a,b)=>b.pushback.rate>a.pushback.rate?b:a),low=solid.reduce((a,b)=>b.pushback.rate<a.pushback.rate?b:a);
-  note=low.pushback.rate>0&&high.pushback.rate/low.pushback.rate>=1.3?`Pushback is ${(high.pushback.rate/low.pushback.rate).toFixed(1)}× higher in the ${WORK_BANDS[high.band][0].toLowerCase()} than in the ${WORK_BANDS[low.band][0].toLowerCase()}.`:'Pushback is about the same at every time of day.';
- }else if(total)note='Needs at least 20 labeled follow-ups in two parts of the day to compare.';
- $('w-band-note').textContent=note;
-}
-function renderWork(payload){
- WORK=payload;renderWorkStatus(payload);
- const insights=payload?.insights,areas=(payload?.settings?.areas||[]).map(area=>area.name);
- renderWorkFilters(insights);renderWorkBreakdown(insights);renderWorkTagCards(insights);renderWorkRhythm(insights);
- renderWorkRework(insights);renderWorkAgentTrend(insights);
- renderWorkScorecard(insights);renderWorkEffortModels(insights);renderWorkFit(insights);renderWorkMix(insights);renderWorkOpportunities(insights);renderWorkSizing(insights);renderWorkEffort(insights);
-}
-async function loadWork(){
- const request=++workRequest,query=new URLSearchParams({months:workMonths});
- if(workRuntime)query.set('runtime',workRuntime);if(workProject)query.set('project',workProject);
- try{
-  const response=await fetch(`/work?${query}`,{cache:'no-store'});
-  const payload=await response.json();if(request!==workRequest)return;
-  if(!response.ok||!payload.ok){
-   if(response.status===404&&(workProject||workRuntime)){workProject='';workRuntime='';loadWork();return;}
-   throw new Error(payload.error||'Work insights unavailable');
-  }
-  workLastLoadedAt=Date.now();renderWork(payload);
- }catch(error){
-  if(request!==workRequest)return;
-  $('w-state').dataset.state='storage_error';$('w-state').textContent='Error';
-  $('w-status-title').textContent='Work insights are unavailable';$('w-status-detail').textContent='Token Meter will try again shortly.';
- }
-}
-async function postWorkAction(path,payload){
- const token=agentActionToken();
- if(!token)throw new Error('Controls are not ready yet. Wait a moment and try again.');
- const response=await fetch(path,{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify(payload)});
- let result={};try{result=await response.json();}catch(error){}
- if(!response.ok||!result.ok)throw new Error(result.error||'Token Meter could not save that change.');
- return result;
-}
-$('w-rework-model').addEventListener('change',()=>{if(WORK)renderWorkRework(WORK.insights);});
-$('w-agent-model').addEventListener('change',()=>{if(WORK)renderWorkAgentTrend(WORK.insights);});
-$('w-months').addEventListener('change',event=>{workMonths=event.target.value;loadWork();});
-$('w-runtime').addEventListener('change',event=>{workRuntime=event.target.value;loadWork();});
-$('w-project').addEventListener('change',event=>{workProject=event.target.value;loadWork();});
-$('w-pause').addEventListener('change',async event=>{
- const duration=event.target.value;if(!duration)return;
- try{const result=await postWorkAction('/work-insights/pause',{duration});if(WORK){WORK.status=result.status;WORK.settings=result.work_insights;renderWorkStatus(WORK);}}
- catch(error){$('w-status-detail').textContent=error.message;}
- finally{event.target.value='';}
-});
-$('w-resume').addEventListener('click',async()=>{
- try{const result=await postWorkAction('/work-insights/pause',{duration:'resume'});if(WORK){WORK.status=result.status;WORK.settings=result.work_insights;renderWorkStatus(WORK);}loadWork();}
- catch(error){$('w-status-detail').textContent=error.message;}
-});
-$('w-open-settings').addEventListener('click',()=>setHashRoute('settings-work-insights'));
-$('w-turn-on').addEventListener('click',()=>setHashRoute('settings-work-insights'));
-$('w-setup-retry').addEventListener('click',async()=>{
- try{const result=await postWorkAction('/work-insights/setup',{start:true});if(WORK){WORK.status=result.status;renderWorkStatus(WORK);}}
- catch(error){$('w-status-detail').textContent=error.message;}
-});
-function renderWorkSettings(payload,{force=false}={}){
- if(!payload)return;
- applyWorkSupport(payload.settings?.supported);  // known here long before the first full state on a cold start
- WORK_SETTINGS=payload;
- const settings=payload.settings||{},status=payload.status||{};
- const badge=status.reason==='delete_pending'?'Delete pending':({disabled:'Off',setup_needed:'Setup needed',running:'Running',idle:'Up to date',paused:'Paused',throttled:'Waiting',backoff:'Retrying',storage_error:'Error'}[settings.enabled?status.state:'disabled']||'On');
- $('work-settings-badge').textContent=badge;
- if(!force&&settingsInteractionActive()){updateWorkSaveState();return;}
- $('work-enable-cta').hidden=Boolean(settings.enabled);
- $('work-enabled').checked=Boolean(settings.enabled);$('work-battery').checked=settings.pause_on_battery!==false;$('work-live-notify').checked=settings.live_notifications!==false;$('work-live-notify').disabled=!settings.enabled;$('work-live-notify').closest('label').title=settings.enabled?'':'Turn on labeling to get live-suggestion notifications.';
- $('work-model').value=settings.model||'';$('work-url').value=settings.ollama_url||'';
- $('work-rate').value=String(settings.rate_per_minute||'auto');$('work-backfill').value=String(settings.backfill_days??90);
- workAreasDraft=(settings.areas||[]).map(area=>({...area}));renderWorkAreas();
-}
-function workSettingsDraft(){
- return {model:$('work-model').value.trim(),ollama_url:$('work-url').value.trim(),areas:(workAreasDraft||[]).map(area=>({name:area.name.split(/\s+/).join(' ').trim(),description:area.description.split(/\s+/).join(' ').trim()}))};
-}
-// Save covers the model, address, and areas; it is live only when one of them differs from what is saved.
-function workSettingsDirty(){
- const saved=WORK_SETTINGS?.settings||{},draft=workSettingsDraft();
- const savedAreas=(saved.areas||[]).map(area=>({name:area.name,description:area.description}));
- return draft.model!==(saved.model||'')||draft.ollama_url!==(saved.ollama_url||'')||JSON.stringify(draft.areas)!==JSON.stringify(savedAreas);
-}
-const WORK_UNSAVED_NOTE=' Other changes are not saved yet.';
-function updateWorkSaveState(){
- const dirty=Boolean(WORK_SETTINGS)&&workSettingsDirty(),line=$('work-settings-status');
- $('work-save').disabled=!dirty;
- if(dirty&&(line.textContent===''||line.textContent==='Saved'))line.textContent='Unsaved changes';
- else if(!dirty&&(line.textContent==='Unsaved changes'||line.textContent.endsWith(WORK_UNSAVED_NOTE)))line.textContent='';
-}
-function renderWorkAreas(){
- const limits=WORK_SETTINGS?.settings?.limits||{min_areas:2,max_areas:8,name:40,description:200},areas=workAreasDraft||[];
- $('work-areas').innerHTML=areas.map((area,index)=>`<div class=workAreaRow><i class=workSwatch style="--swatch:${index<8?`var(--w${index+1})`:'var(--w-unclear)'}"></i><input data-area-index=${index} data-area-field=name value="${esc(area.name)}" maxlength=${limits.name} aria-label="Area ${index+1} name"><input data-area-index=${index} data-area-field=description value="${esc(area.description)}" maxlength=${limits.description} aria-label="Area ${index+1} description"><button class="tbtn clearFilters" type=button data-area-remove=${index} ${areas.length<=limits.min_areas?'disabled':''} aria-label="Remove area ${index+1}">Remove</button></div>`).join('');
- $('work-areas-count').textContent=`${areas.length} of ${limits.max_areas} · changing areas relabels them in the background`;
- $('work-area-add').disabled=areas.length>=limits.max_areas;
- updateWorkSaveState();
-}
-async function loadWorkSettings(){
- try{const response=await fetch('/work-insights/status',{cache:'no-store'});const payload=await response.json();if(payload.ok)renderWorkSettings(payload);}catch(error){}
-}
-async function saveWorkSettings(payload,message){
- // A toggle saves at once; keep unsaved model, address, and area edits that it does not include.
- const kept=!('model' in payload)&&workSettingsDirty()?{draft:workSettingsDraft(),areas:'areas' in payload||payload.reset_areas?null:workAreasDraft}:null;
- $('work-settings-status').textContent='Saving…';
- try{
-  const result=await postWorkAction('/settings/work-insights',payload);
-  renderWorkSettings({settings:result.work_insights,status:result.status},{force:true});
-  if(kept){$('work-model').value=kept.draft.model;$('work-url').value=kept.draft.ollama_url;if(kept.areas)workAreasDraft=kept.areas;renderWorkAreas();}
-  const unsaved=kept&&workSettingsDirty();
-  $('work-settings-status').textContent=unsaved?`${message||'Saved.'}${WORK_UNSAVED_NOTE}`:message||'Saved';
-  workLastLoadedAt=0;
- }catch(error){$('work-settings-status').textContent=error.message;}
-}
-$('work-areas').addEventListener('input',event=>{const input=event.target.closest('[data-area-index]');if(!input||!workAreasDraft)return;workAreasDraft[Number(input.dataset.areaIndex)][input.dataset.areaField]=input.value;updateWorkSaveState();});
-['work-model','work-url'].forEach(id=>$(id).addEventListener('input',updateWorkSaveState));
-$('work-areas').addEventListener('click',event=>{const button=event.target.closest('[data-area-remove]');if(!button||!workAreasDraft)return;workAreasDraft.splice(Number(button.dataset.areaRemove),1);renderWorkAreas();});
-$('work-area-add').addEventListener('click',()=>{if(!workAreasDraft)return;workAreasDraft.push({name:'',description:''});renderWorkAreas();$('work-areas').querySelector('.workAreaRow:last-child input')?.focus();});
-$('work-enable-button').addEventListener('click',()=>{const box=$('work-enabled');box.checked=true;box.dispatchEvent(new Event('change'));$('work-enable-cta').hidden=true;box.focus();});
-$('work-enabled').addEventListener('change',event=>saveWorkSettings({enabled:event.target.checked},event.target.checked?'On. Labeling starts in the background.':'Off. Labeling stopped.'));
-$('work-battery').addEventListener('change',event=>saveWorkSettings({pause_on_battery:event.target.checked}));
-$('work-live-notify').addEventListener('change',event=>saveWorkSettings({live_notifications:event.target.checked}));
-$('work-rate').addEventListener('change',event=>saveWorkSettings({rate_per_minute:event.target.value==='auto'?'auto':Number(event.target.value)}));
-$('work-backfill').addEventListener('change',event=>saveWorkSettings({backfill_days:Number(event.target.value)}));
-$('work-save').addEventListener('click',()=>{if(workSettingsDirty())saveWorkSettings(workSettingsDraft());});
-$('work-areas-reset').addEventListener('click',()=>saveWorkSettings({reset_areas:true},'Default areas restored.'));
-$('work-pause').addEventListener('change',async event=>{
- const duration=event.target.value;if(!duration)return;
- try{const result=await postWorkAction('/work-insights/pause',{duration});renderWorkSettings({settings:result.work_insights,status:result.status},{force:true});$('work-settings-status').textContent=duration==='resume'?'Resumed.':'Paused.';}
- catch(error){$('work-settings-status').textContent=error.message;}
- finally{event.target.value='';}
-});
-$('work-clear').addEventListener('click',async()=>{
- if(!window.confirm('Delete all work labels? They are rebuilt in the background if work insights stay on.'))return;
- try{await postWorkAction('/work-insights/clear',{confirm:true});$('work-settings-status').textContent='Labels deleted.';workLastLoadedAt=0;loadWorkSettings();}
- catch(error){$('work-settings-status').textContent=error.message;}
-});
-async function applyWorkSessionFilter(params){
- const query=new URLSearchParams();
- ['months','runtime','project','month','start_month','area','work_type','complexity','tier','effort','outcome','model','model_runtime','tag'].forEach(key=>{if(params.get(key))query.set(key,params.get(key));});
- query.set('ids','1');
- const label=params.get('label')||'Work',request=++workFilterRequest;
- if(history.replaceState)history.replaceState(null,'','/#sessions-all');
- setSessionScope('all');showTab('session');showCurrentPanel('sessions');
- workSessionFilter={label,keys:new Set(),loading:true};
- renderCurrentSessions();if(LATEST)renderAllSessions(LATEST.xsession);
- try{
-  const response=await fetch(`/work/sessions?${query}`,{cache:'no-store'}),payload=await response.json();
-  if(request!==workFilterRequest)return;
-  if(!response.ok||!payload.ok)throw new Error(payload.error||'Work filter unavailable');
-  workSessionFilter={label,keys:new Set(payload.keys.map(String)),total:payload.total,truncated:payload.truncated};
- }catch(error){if(request!==workFilterRequest)return;workSessionFilter={label:`${label} (unavailable)`,keys:new Set(),failed:true};}
- if(LATEST)renderAllSessions(LATEST.xsession);
-}
-async function loadDelivery(){
- const request=++deliveryRequest,query=new URLSearchParams({range:deliveryRange});if(deliveryProject)query.set('project',deliveryProject);
- try{
-  const response=await fetch(`/git-delivery?${query}`,{cache:'no-store'});if(!response.ok)throw new Error('Git data unavailable');
-  const payload=await response.json();if(request!==deliveryRequest)return;
-  deliveryLastLoadedAt=Date.now();renderDelivery(payload);
-  clearTimeout(deliveryRetryTimer);
-  if(!payload?.coverage?.last_checked&&deliveryLoadRetries<8){deliveryLoadRetries++;deliveryRetryTimer=setTimeout(loadDelivery,1500);}else deliveryLoadRetries=0;
- }catch(error){
-  if(request!==deliveryRequest)return;
-  const coverageBar=$('d-coverage-bar');coverageBar.style.setProperty('--delivery-coverage',0);coverageBar.classList.add('partial');coverageBar.removeAttribute('aria-valuenow');coverageBar.setAttribute('aria-valuetext','Spend coverage unavailable');
-  $('d-coverage-percent').textContent='--';$('d-coverage').classList.add('partial');$('d-coverage').textContent='Git evidence unavailable';
-  $('d-model-note').textContent='';$('d-model-table').querySelector('tbody').innerHTML='<tr><td colspan=5><div class="deliveryEmpty emptyState">Git evidence unavailable.</div></td></tr>';$('d-project-table').querySelector('tbody').innerHTML='<tr><td colspan=4><div class="deliveryEmpty emptyState">Git evidence unavailable.</div></td></tr>';
-  $('d-push-yield').textContent='--';$('d-push-yield-note').textContent='Waiting for output tokens.';$('d-rework').textContent='--';
-	  $('d-signals').innerHTML='<div class="deliverySignalEmpty emptyState">Git evidence unavailable.</div>';
-	  $('d-shape').innerHTML='<div class="deliveryShapeEmpty emptyState">Git evidence unavailable.</div>';
-	  $('d-evidence-spend').textContent='--';setDeliveryEvidenceRatio('Git evidence unavailable.','Git evidence unavailable. Ratios require overlapping spend and Git evidence.');$('d-evidence-freshness').textContent='Git scan unavailable.';
-	  ['comparable','spend','git','unavailable'].forEach(key=>{$(`d-evidence-count-${key}`).textContent='--';});
-	 }
-}
-$('d-coverage').addEventListener('click',()=>setDeliveryEvidencePanel($('d-evidence-panel').hidden));
-$('d-evidence-close').addEventListener('click',()=>setDeliveryEvidencePanel(false));
-document.querySelectorAll('[data-delivery-evidence-filter]').forEach(button=>button.addEventListener('click',()=>{setDeliveryEvidenceFilter(button.dataset.deliveryEvidenceFilter);setDeliveryEvidencePanel(false);}));
-$('d-evidence-filter').addEventListener('change',event=>setDeliveryEvidenceFilter(event.target.value,{scroll:false}));
-$('d-day-prev').addEventListener('click',()=>selectAdjacentDeliveryDay(-1));
-$('d-day-next').addEventListener('click',()=>selectAdjacentDeliveryDay(1));
-$('d-day-close').addEventListener('click',dismissGitChartInspector);
-$('d-chart-hits').addEventListener('pointerleave',event=>{if(event.pointerType!=='touch')hideDeliveryChartTip();});
-$('d-project').addEventListener('change',event=>{deliveryProject=event.target.value;deliverySelectedDay='';deliveryEvidenceFilter='all';localStorage.setItem('tm_delivery_project',deliveryProject);loadDelivery();});
-$('d-range').addEventListener('change',event=>{deliveryRange=DELIVERY_RANGES.includes(event.target.value)?event.target.value:'30';deliverySelectedDay='';localStorage.setItem('tm_delivery_range',deliveryRange);loadDelivery();});
-$('d-project-table').querySelector('thead').addEventListener('click',event=>{
- const button=event.target.closest('[data-delivery-sort]');if(!button)return;
- const key=button.dataset.deliverySort;deliverySort=deliverySort.key===key?{key,direction:deliverySort.direction==='asc'?'desc':'asc'}:{key,direction:key==='project'?'asc':'desc'};renderDeliveryTable(deliveryPayload?.project_rows||[]);
-});
-$('d-model-table').querySelector('thead').addEventListener('click',event=>{
- const button=event.target.closest('[data-delivery-model-sort]');if(!button)return;
- const key=button.dataset.deliveryModelSort;deliveryModelSort=deliveryModelSort.key===key?{key,direction:deliveryModelSort.direction==='asc'?'desc':'asc'}:{key,direction:key==='model'?'asc':'desc'};renderDeliveryModelTable(deliveryPayload?.model_rows||[],deliveryPayload?.model_coverage);
-});
-$('d-mobile-sort').addEventListener('change',event=>{
- const [key,direction]=event.target.value.split(':');
- if(!['project','covered_cost','changed_lines','spend_per_1k'].includes(key)||!['asc','desc'].includes(direction))return;
- deliverySort={key,direction};renderDeliveryTable(deliveryPayload?.project_rows||[]);
-});
-$('delivery-clear').addEventListener('click',async()=>{
- if(!window.confirm('Clear Token Meter Git evidence? This removes only Token Meter totals and starts a new baseline. Your repositories are not changed.'))return;
- const status=$('delivery-clear-status'),token=agentActionToken();status.textContent='Clearing…';
- try{
-  const response=await fetch('/git-delivery/clear',{method:'POST',headers:{'Content-Type':'application/json','X-Token-Meter-Action':token},body:JSON.stringify({confirm:true})});
-  const payload=await response.json();if(!response.ok||!payload.ok)throw new Error('clear failed');
-  deliveryPayload=null;deliverySelectedDay='';deliveryLastLoadedAt=0;status.textContent='Git evidence cleared. New pushes start a fresh baseline.';loadDelivery();
- }catch(error){status.textContent='Git evidence could not be cleared.';}
-});
-
-const MODEL_COUNTER_KEYS=['input_tokens','output_tokens','io_covered_input_tokens','io_covered_output_tokens','cost_covered_output_tokens','cost_covered_cost','executions','token_covered_executions','io_covered_executions','cost_covered_executions','cost','cache_read_tokens','cache_write_tokens','cache_covered_input_tokens','reasoning_tokens','reasoning_output_tokens','reasoning_executions','reasoning_unavailable_executions','thinking_executions','thinking_covered_executions','attempts','retries','failed_attempts','attempt_samples','timed_output_tokens','timed_seconds','timed_samples','tool_free_output_tokens','tool_free_seconds','tool_free_samples','ttft_total_s','ttft_samples','wait_seconds','wait_samples','user_pause_seconds'];
-const MODEL_ARRAY_KEYS=['wait_durations_s','workload_peak_inputs','workload_outputs','workload_tool_calls','workload_model_calls','workload_cache_ratios'];
-const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all'];
-function loadEfficiencyFilters(project=''){
- if(project){
-  const stored=localStorage.getItem('tm_efficiency_project_filters');
-  try{const scoped=JSON.parse(stored||'{}'),values=scoped?.[project];return Array.isArray(values)?[...new Set(values.filter(value=>typeof value==='string'&&value))]:[];}catch(error){return [];}
- }
- try{const stored=JSON.parse(localStorage.getItem('tm_efficiency_filters')||'[]');return Array.isArray(stored)?[...new Set(stored.filter(value=>typeof value==='string'&&value))]:[];}catch(error){return [];}
-}
-function saveActiveEfficiencyFilters(){
- if(!efficiencyProject)localStorage.setItem('tm_efficiency_filters',JSON.stringify(efficiencyFilters));
- else{
-  let scoped={};try{const stored=JSON.parse(localStorage.getItem('tm_efficiency_project_filters')||'{}');if(stored&&typeof stored==='object'&&!Array.isArray(stored))scoped=stored;}catch(error){}
-  scoped[efficiencyProject]=efficiencyFilters;localStorage.setItem('tm_efficiency_project_filters',JSON.stringify(scoped));
- }
-}
-let efficiencyProject=migrateStoredProjectFilters('tm_efficiency_project');
-let efficiencyFilters=loadEfficiencyFilters(efficiencyProject);
-let efficiencyRange=localStorage.getItem('tm_efficiency_range')||'30';
-if(!EFFICIENCY_RANGES.includes(efficiencyRange))efficiencyRange='30';
-let efficiencySort={key:'cost',direction:'desc'};
-let activeEfficiencyStats=null,activeEfficiencyScope='',activeEfficiencyGeneration=0;
-let efficiencyProjectRequest=0,efficiencyProjectLoadingKey='';
-const efficiencyProjectCache=new Map();
-// model-color-logic-start
-const MODEL_COLORS={
- codex:['#6F9CFF','#8EC5FF','#4C86F0','#B6CFFF','#647DB4'],
- claude:['#E3825C','#F4A26E','#B55332','#FBC6A6','#CF8B76'],
- 'claude-3p':['#A46AF4','#AD88F0','#7459F0','#B799E5','#9A35F6'],
- cursor:['#3CC6C0','#65D6A6','#A0D56E','#2E9C8E','#BEE0D4'],
- kiro:['#E3CC5C','#C9A43A','#EFE0A0','#B8B850','#CCE236'],
- opencode:['#FF8FB8','#FF5E93','#FFC2D8','#E86FA0','#E236A9'],
- fallback:['#A9B8C7','#8FB1C5','#B3A8D8','#83C8BD','#7D8AA0'],
-};
-const MODEL_RUNTIME_COLOR_FAMILIES={
- codex:'codex','claude code':'claude','claude-3p':'claude-3p',cursor:'cursor',kiro:'kiro',opencode:'opencode',
-};
-const MODEL_OUTPUT_BAR_FILL='#536879',MODEL_OUTPUT_BAR_STROKE='#7890A3';
-function modelRuntimeColorFamily(identity){
- const parts=String(identity||'').split('::'),runtime=(parts.length>1?parts[1]:parts[0]).trim().toLowerCase();
- return MODEL_RUNTIME_COLOR_FAMILIES[runtime]||'fallback';
-}
-function modelColor(name,names){
- const family=modelRuntimeColorFamily(name),palette=MODEL_COLORS[family]||MODEL_COLORS.fallback;
- const siblings=[...new Set((names||[]).filter(identity=>modelRuntimeColorFamily(identity)===family))].sort((a,b)=>a.localeCompare(b));
- return palette[Math.max(0,siblings.indexOf(name))%palette.length];
-}
-// Ranked groups (top five) take shades in rank order per runtime, so the visible top five never share a color.
-function modelRankedColors(groups){
- const used=new Map();
- return new Map(groups.map(group=>{const family=modelRuntimeColorFamily(group.ids?.[0]||group.key),palette=MODEL_COLORS[family]||MODEL_COLORS.fallback,index=used.get(family)||0;used.set(family,index+1);return [group.key,palette[index%palette.length]];}));
-}
-function modelTrendPaint(seriesColor){return {barFill:MODEL_OUTPUT_BAR_FILL,barStroke:MODEL_OUTPUT_BAR_STROKE,line:seriesColor};}
-// model-color-logic-end
-function localDateKey(date){return `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;}
-function dateKeyAgo(days,now=new Date()){const date=new Date(now);date.setHours(12,0,0,0);date.setDate(date.getDate()-days);return localDateKey(date);}
-function calendarMonthWindow(monthsAgo,now=new Date()){
- const start=new Date(now.getFullYear(),now.getMonth()-monthsAgo,1,12,0,0,0),days=[];
- for(const date=new Date(start);date.getMonth()===start.getMonth();date.setDate(date.getDate()+1))days.push(localDateKey(date));
- return {days,daySet:new Set(days)};
-}
-function monthToDateWindow(now=new Date()){
- const days=Array.from({length:now.getDate()},(_,index)=>dateKeyAgo(now.getDate()-1-index,now));
- return {days,daySet:new Set(days)};
-}
-function modelRangeWindow(range,now=new Date()){
- if(range==='all')return {days:null,daySet:null};
- if(range==='month')return monthToDateWindow(now);
- if(range==='last_month')return calendarMonthWindow(1,now);
- if(range==='today'||range==='yesterday'){
-  const day=dateKeyAgo(range==='today'?0:1,now);
-  return {days:[day],daySet:new Set([day])};
- }
- const count=Number(range),days=Array.from({length:count},(_,index)=>dateKeyAgo(count-1-index,now));
- return {days,daySet:new Set(days)};
-}
-function modelDayInRange(day,window){return !window.daySet||window.daySet.has(day);}
-function modelRangeLabel(range){return range==='today'?'Today':range==='yesterday'?'Yesterday':range==='month'?'Month':range==='last_month'?'Last month':range==='all'?'all history':`${range}d`;}
-function modelWaitDistribution(values){
- const sorted=(values||[]).map(Number).filter(value=>value>0).sort((a,b)=>a-b),count=sorted.length;
- if(!count)return {median_wait_s:0,p95_wait_s:0};
- const middle=Math.floor(count/2),median=count%2?sorted[middle]:(sorted[middle-1]+sorted[middle])/2;
- return {median_wait_s:median,p95_wait_s:sorted[Math.min(count-1,Math.max(0,Math.ceil(count*.95)-1))]};
-}
-function modelMedian(values){
- const sorted=(values||[]).map(Number).filter(value=>Number.isFinite(value)&&value>=0).sort((a,b)=>a-b),count=sorted.length;
- if(!count)return 0;const middle=Math.floor(count/2);return count%2?sorted[middle]:(sorted[middle-1]+sorted[middle])/2;
-}
-function aggregateModelDays(rows){
-	 const total=MODEL_COUNTER_KEYS.reduce((out,key)=>(out[key]=0,out),{});
-	 rows=rows||[];const tokenCovered=rows.filter(row=>metricAvailable(row,'tokens')).length,inputCovered=rows.filter(row=>metricAvailable(row,'input_tokens')).length,outputCovered=rows.filter(row=>metricAvailable(row,'output_tokens')).length,costCovered=rows.filter(row=>metricAvailable(row,'cost')).length,cacheCovered=rows.filter(row=>metricAvailable(row,'cache')).length,reasoningCovered=rows.filter(row=>row.availability?.reasoning_tokens===true).length,attemptCovered=rows.filter(row=>row.availability?.attempts===true).length,tokenPartial=rows.some(row=>metricPartial(row,'tokens')),costPartial=rows.some(row=>metricPartial(row,'cost')||(row.cost_covered_executions!==undefined&&Number(row.cost_covered_executions||0)<Number(row.executions||0))),cachePartial=rows.some(row=>metricPartial(row,'cache')),reasoningPartial=rows.some(row=>row.coverage?.reasoning_tokens?.complete===false),attemptPartial=rows.some(row=>row.coverage?.attempts?.complete===false);
-	 const estimated=rows.some(hasLocalEstimate),reported=rows.some(row=>['reported','mixed'].includes(usageBasis(row)));total.usage_basis=estimated?(reported?'mixed':'local_estimate'):'reported';total.provenance={usage_basis:total.usage_basis};
-	 total.availability={tokens:tokenCovered>0,input_tokens:inputCovered>0,output_tokens:outputCovered>0,cost:costCovered>0,cache:cacheCovered>0,reasoning_tokens:reasoningCovered>0,attempts:attemptCovered>0,throughput:outputCovered>0};
-	 total.coverage={tokens:{complete:tokenCovered===rows.length&&!tokenPartial,covered_rows:tokenCovered,total_rows:rows.length},cost:{complete:costCovered===rows.length&&!costPartial,covered_rows:costCovered,total_rows:rows.length},cache:{complete:cacheCovered===rows.length&&!cachePartial,covered_rows:cacheCovered,total_rows:rows.length},reasoning_tokens:{complete:reasoningCovered===rows.length&&!reasoningPartial,covered_rows:reasoningCovered,total_rows:rows.length},attempts:{complete:attemptCovered===rows.length&&!attemptPartial,covered_rows:attemptCovered,total_rows:rows.length}};
-	 rows.forEach(row=>MODEL_COUNTER_KEYS.forEach(key=>total[key]+=Number(row[key]||0)));
-	 total.reasoning_efforts=[...new Set(rows.flatMap(row=>row.reasoning_efforts||[]))].sort((a,b)=>String(a).localeCompare(String(b))).slice(0,8);
-	 MODEL_ARRAY_KEYS.forEach(key=>total[key]=rows.flatMap(row=>(row[key]||[]).map(Number).filter(value=>Number.isFinite(value)&&value>=0)));
-	 total.max_wait_s=Math.max(0,...rows.map(row=>Number(row.max_wait_s||0)));
- const toolFree=total.tool_free_samples>0&&total.tool_free_seconds>0;
- const timed=total.timed_samples>0&&total.timed_seconds>0;
- const seconds=toolFree?total.tool_free_seconds:total.timed_seconds;
- const speedOutput=toolFree?total.tool_free_output_tokens:total.timed_output_tokens;
- total.available=Boolean((toolFree||timed)&&seconds>0&&speedOutput>0);
- total.output_tps=total.available?speedOutput/seconds:0;
- total.throughput_basis=toolFree?'tool_free':timed?'end_to_end':'unavailable';
- total.throughput_samples=toolFree?total.tool_free_samples:total.timed_samples;
- total.timing_coverage=total.output_tokens?Math.min(1,speedOutput/total.output_tokens):0;
-	 total.avg_ttft_ms=total.ttft_samples?total.ttft_total_s*1000/total.ttft_samples:0;
-	 total.avg_wait_s=total.wait_samples?total.wait_seconds/total.wait_samples:0;
-	 Object.assign(total,modelWaitDistribution(total.wait_durations_s));
-	 total.median_peak_input_tokens=modelMedian(total.workload_peak_inputs);
-	 total.median_workload_output_tokens=modelMedian(total.workload_outputs);
-	 total.median_tool_calls=modelMedian(total.workload_tool_calls);
-	 total.median_model_calls=modelMedian(total.workload_model_calls);
-	 total.median_cache_ratio=modelMedian(total.workload_cache_ratios);
- return total;
-}
-function mergeModelDays(models,window){
- const days=new Map();
- (models||[]).forEach(model=>(model.daily||[]).forEach(day=>{
-  if(!modelDayInRange(day.day,window))return;
-	  const target=days.get(day.day)||{day:day.day};
-	  MODEL_COUNTER_KEYS.forEach(key=>target[key]=Number(target[key]||0)+Number(day[key]||0));
-	  MODEL_ARRAY_KEYS.forEach(key=>target[key]=[...(target[key]||[]),...(day[key]||[])]);
-	  target._metricRows=Number(target._metricRows||0)+1;target._tokenCovered=Number(target._tokenCovered||0)+(metricAvailable(day,'tokens')?1:0);target._inputCovered=Number(target._inputCovered||0)+(metricAvailable(day,'input_tokens')?1:0);target._outputCovered=Number(target._outputCovered||0)+(metricAvailable(day,'output_tokens')?1:0);target._costCovered=Number(target._costCovered||0)+(metricAvailable(day,'cost')?1:0);target._cacheCovered=Number(target._cacheCovered||0)+(metricAvailable(day,'cache')?1:0);target._reasoningCovered=Number(target._reasoningCovered||0)+(day.availability?.reasoning_tokens===true?1:0);target._attemptCovered=Number(target._attemptCovered||0)+(day.availability?.attempts===true?1:0);target._tokenComplete=target._tokenComplete!==false&&day.coverage?.tokens?.complete!==false;target._costComplete=target._costComplete!==false&&day.coverage?.cost?.complete!==false;target._cacheComplete=target._cacheComplete!==false&&day.coverage?.cache?.complete!==false;target._reasoningComplete=target._reasoningComplete!==false&&day.coverage?.reasoning_tokens?.complete!==false;target._attemptComplete=target._attemptComplete!==false&&day.coverage?.attempts?.complete!==false;
-	  target._estimated=Boolean(target._estimated||hasLocalEstimate(day));target._reported=Boolean(target._reported||['reported','mixed'].includes(usageBasis(day)));target.usage_basis=target._estimated?(target._reported?'mixed':'local_estimate'):'reported';target.provenance={usage_basis:target.usage_basis};
-	  target.availability={tokens:target._tokenCovered>0,input_tokens:target._inputCovered>0,output_tokens:target._outputCovered>0,cost:target._costCovered>0,cache:target._cacheCovered>0,reasoning_tokens:target._reasoningCovered>0,attempts:target._attemptCovered>0,throughput:target._outputCovered>0};target.coverage={tokens:{complete:target._tokenCovered===target._metricRows&&target._tokenComplete},cost:{complete:target._costCovered===target._metricRows&&target._costComplete},cache:{complete:target._cacheCovered===target._metricRows&&target._cacheComplete},reasoning_tokens:{complete:target._reasoningCovered===target._metricRows&&target._reasoningComplete},attempts:{complete:target._attemptCovered===target._metricRows&&target._attemptComplete}};
-	  target.max_wait_s=Math.max(Number(target.max_wait_s||0),Number(day.max_wait_s||0));
-  days.set(day.day,target);
- }));
- return [...days.values()].sort((a,b)=>a.day.localeCompare(b.day));
-}
-function efficiencyMetrics(row){
- const data=row||{},availability=data.availability||{},input=Math.max(0,Number(data.input_tokens)||0),output=Math.max(0,Number(data.output_tokens)||0),coveredOutput=data.cost_covered_output_tokens===undefined?output:Math.max(0,Number(data.cost_covered_output_tokens)||0),cost=Math.max(0,Number(data.cost)||0),coveredCost=data.cost_covered_cost===undefined?cost:Math.max(0,Number(data.cost_covered_cost)||0),executions=Math.max(0,Number(data.executions)||0),coveredExecutions=data.token_covered_executions===undefined?executions:Math.max(0,Number(data.token_covered_executions)||0),ioCoveredExecutions=data.io_covered_executions===undefined?coveredExecutions:Math.max(0,Number(data.io_covered_executions)||0),costCoveredExecutions=data.cost_covered_executions===undefined?executions:Math.max(0,Number(data.cost_covered_executions)||0),reasoning=Math.max(0,Number(data.reasoning_tokens)||0),reasoningOutput=Math.max(0,Number(data.reasoning_output_tokens)||0),cacheRead=Math.max(0,Number(data.cache_read_tokens)||0),cacheInput=data.cache_covered_input_tokens===undefined?input:Math.max(0,Number(data.cache_covered_input_tokens)||0),attempts=Math.max(0,Number(data.attempts)||0),retries=Math.max(0,Number(data.retries)||0),failed=Math.max(0,Number(data.failed_attempts)||0),tokensAvailable=availability.tokens===true,inputAvailable=availability.input_tokens===true||(availability.input_tokens===undefined&&tokensAvailable),outputAvailable=availability.output_tokens===true||(availability.output_tokens===undefined&&tokensAvailable),reasoningAvailable=availability.reasoning_tokens===true,cacheAvailable=availability.cache===true,attemptsAvailable=availability.attempts===true,ioComplete=ioCoveredExecutions>=executions&&data.coverage?.tokens?.complete!==false,pairedTotals=data.io_covered_input_tokens!==undefined&&data.io_covered_output_tokens!==undefined,pairedInput=Math.max(0,Number(data.io_covered_input_tokens)||0),pairedOutput=Math.max(0,Number(data.io_covered_output_tokens)||0);
- return {output_per_dollar:outputAvailable&&availability.cost===true&&costCoveredExecutions>0&&coveredCost>0?coveredOutput/coveredCost:null,reasoning_ratio:reasoningAvailable&&reasoningOutput>0?Math.min(1,reasoning/reasoningOutput):null,context_load:inputAvailable&&outputAvailable?(pairedTotals?(ioCoveredExecutions>0&&pairedOutput>0?pairedInput/pairedOutput:null):(ioComplete&&output>0?input/output:null)):null,cache_hit_ratio:tokensAvailable&&cacheAvailable&&cacheInput>0?Math.min(1,cacheRead/cacheInput):null,retry_waste:attemptsAvailable&&attempts>0?Math.min(1,retries/attempts):null,failure_rate:attemptsAvailable&&attempts>0?Math.min(1,failed/attempts):null};
-}
-function thinkingUnavailableExecutions(row){
- const data=row||{},observed=Math.max(0,Number(data.thinking_executions)||0),covered=data.thinking_covered_executions===undefined?Math.min(observed,Math.max(0,Number(data.reasoning_executions)||0)):Math.max(0,Number(data.thinking_covered_executions)||0);
- return Math.max(0,observed-covered);
-}
-function efficiencyRangeWindow(){return modelRangeWindow(efficiencyRange);}
-function filterEfficiencyModels(models,filters){
- const allSelected=!(filters||[]).length;
- return (models||[]).filter(model=>allSelected||(filters||[]).includes(model.id));
-}
-function efficiencyModelRows(models,window){
- return (models||[]).map(row=>{const daily=window.daySet?(row.daily||[]).filter(day=>modelDayInRange(day.day,window)):[row];return {...row,window:aggregateModelDays(daily)};}).filter(row=>Number(row.window.executions||0)>0||Number(row.window.input_tokens||0)>0||Number(row.window.output_tokens||0)>0||Number(row.window.cost||0)>0).sort((a,b)=>Number(b.window.cost||0)-Number(a.window.cost||0)||Number(b.window.output_tokens||0)-Number(a.window.output_tokens||0)||modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b)));
-}
-function efficiencySortValue(row,key){
- const data=row?.window||{},metric=efficiencyMetrics(data);
- if(key==='model')return modelRuntimeLabel(row);
- if(key==='cost')return data.availability?.cost===true?Number(data.cost)||0:null;
- const value=metric[key];return value===null||!Number.isFinite(value)?null:value;
-}
-function sortEfficiencyRows(rows,sort=efficiencySort){
- const direction=sort.direction==='asc'?1:-1;
- return [...(rows||[])].sort((a,b)=>{const left=efficiencySortValue(a,sort.key),right=efficiencySortValue(b,sort.key);if(left===null&&right===null)return modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b));if(left===null)return 1;if(right===null)return -1;const compared=typeof left==='string'?left.localeCompare(right):left-right;return compared?compared*direction:modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b));});
-}
-function efficiencyTrendDays(rows,window){
- const grouped=new Map((window.days||[]).map(day=>[day,[]]));
- (rows||[]).forEach(row=>(row.daily||[]).forEach(day=>{if(!modelDayInRange(day.day,window))return;if(!grouped.has(day.day))grouped.set(day.day,[]);grouped.get(day.day).push(day);}));
- return [...grouped].sort(([a],[b])=>a.localeCompare(b)).map(([day,items])=>({day,metrics:efficiencyMetrics(aggregateModelDays(items))}));
-}
-function efficiencyTrendDelta(trend,key){
- const values=(trend||[]).map(row=>row?.metrics?.[key]).filter(value=>value!==null&&value!==undefined&&Number.isFinite(Number(value))).map(Number);
- if(values.length<2||values.at(-2)<=0)return {text:'No comparable prior day',direction:''};
- const change=(values.at(-1)-values.at(-2))/values.at(-2);
- if(!Number.isFinite(change))return {text:'No comparable prior day',direction:''};
- const direction=change>0?'up':change<0?'down':'flat',symbol=direction==='up'?'↑':direction==='down'?'↓':'→';
- return {text:`${symbol} ${Math.abs(change*100).toFixed(1)}% vs prior covered day`,direction};
-}
-function efficiencyComparisonWindows(range,now=new Date()){
- if(range==='today')return {current:modelRangeWindow('today',now),prior:modelRangeWindow('yesterday',now),label:'yesterday'};
- if(range==='yesterday')return {current:modelRangeWindow('yesterday',now),prior:{days:[dateKeyAgo(2,now)],daySet:new Set([dateKeyAgo(2,now)])},label:'the day before'};
- if(range==='month')return {current:monthToDateWindow(now),prior:calendarMonthWindow(1,now),label:'last month'};
- if(range==='last_month')return {current:calendarMonthWindow(1,now),prior:calendarMonthWindow(2,now),label:'the month before'};
- const count=Number(range);
- if(!Number.isInteger(count)||count<=0)return null;
- const priorDays=Array.from({length:count},(_,index)=>dateKeyAgo(count*2-1-index,now));
- return {current:modelRangeWindow(String(count),now),prior:{days:priorDays,daySet:new Set(priorDays)},label:`prior ${count} days`};
-}
-function efficiencyPeriodDelta(current,prior,key,label){
- if(current?.[key]==null||prior?.[key]==null)return {text:'No comparable prior period',direction:''};
- const latest=Number(current[key]),baseline=Number(prior[key]);
- if(!Number.isFinite(latest)||!Number.isFinite(baseline)||latest<0||baseline<=0)return {text:'No comparable prior period',direction:''};
- const change=(latest-baseline)/baseline;
- if(!Number.isFinite(change))return {text:'No comparable prior period',direction:''};
- const direction=change>0?'up':change<0?'down':'flat',symbol=direction==='up'?'↑':direction==='down'?'↓':'→';
- return {text:`${symbol} ${Math.abs(change*100).toFixed(1)}% vs ${label}`,direction};
-}
-// Shared rise/fall readout under a number: <div class=trendDelta><strong>↑ 8.5%</strong><span>vs prior 30 days</span></div>
-function percentTrendDelta(percent,label){
- const value=Number(percent);
- if(percent===null||percent===undefined||percent===''||!Number.isFinite(value))return {text:'No comparable prior period',direction:''};
- const direction=Math.abs(value)<.05?'flat':value>0?'up':'down',symbol=direction==='up'?'↑':direction==='down'?'↓':'→';
- return {text:`${symbol} ${Math.abs(value).toFixed(1)}% vs ${label}`,direction};
-}
-function trendTone(delta,improvingDirection=''){
- const direction=delta?.direction||'';
- return direction&&improvingDirection?(direction===improvingDirection?'improving':'degrading'):'';
-}
-function renderTrendDelta(target,delta,improvingDirection='',hidden=false){
- const change=typeof target==='string'?$(target):target,parts=delta.direction?delta.text.split(' vs '):[delta.text,''];
- change.hidden=hidden;change.querySelector('strong').textContent=parts[0];change.querySelector('span').textContent=parts[1]?`vs ${parts[1]}`:'';change.dataset.direction=delta.direction;change.dataset.tone=trendTone(delta,improvingDirection);
-}
-function efficiencyChartPointerIndex(clientX,rect,count){
- if(count<=1)return 0;
- const rectWidth=Math.max(1,Number(rect?.width)||0),localX=Math.max(0,Math.min(rectWidth,Number(clientX)-(Number(rect?.left)||0))),viewX=localX/rectWidth*520;
- return Math.max(0,Math.min(count-1,Math.round((viewX-9)/502*(count-1))));
-}
-function efficiencyChartKeyIndex(key,index,count){
- const last=Math.max(0,count-1),current=Math.max(0,Math.min(last,index));
- if(key==='Home')return 0;
- if(key==='End')return last;
- if(key==='ArrowLeft')return Math.max(0,current-1);
- if(key==='ArrowRight')return Math.min(last,current+1);
- return current;
-}
-function efficiencyChartMetricPresentation(value,key){
- if(key==='reasoning_ratio')return {axis:pct(value),detail:`${pct(value)} reasoning`};
- if(key==='context_load')return {axis:efficiencyDecimal(value),detail:`${efficiencyDecimal(value)} context / output`};
- if(key==='cache_hit_ratio')return {axis:pct(value),detail:`${pct(value)} input from cache`};
- return {axis:compactNumber(value),detail:`${Math.round(value).toLocaleString('en-US')} output tokens / $`};
-}
-function efficiencyChartInspection(sample,key){
- const parts=String(sample?.day||'').split('-').map(Number),months=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],date=parts.length===3&&months[parts[1]-1]?`${months[parts[1]-1]} ${parts[2]}`:String(sample?.day||'Unknown day'),value=sample?.value;
- if(value===null||!Number.isFinite(value))return {date,value:'No data'};
- return {date,value:efficiencyChartMetricPresentation(value,key).detail};
-}
-function efficiencyChartAnnouncement(detail,announce){
- return announce?`${detail.date} · ${detail.value}`:'';
-}
-function chartGapRuns(points){
- const segments=[];let segment=[];
- (points||[]).forEach(point=>{if(segment.length&&point.index!==segment.at(-1).index+1){segments.push(segment);segment=[];}segment.push(point);});
- if(segment.length)segments.push(segment);
- return {segments,bridges:segments.slice(1).map((run,index)=>[segments[index].at(-1),run[0]])};
-}
-function chartGapBridge(x1,y1,x2,y2,color=''){return `<line class=chartGapBridge x1="${x1.toFixed(1)}" y1="${y1.toFixed(1)}" x2="${x2.toFixed(1)}" y2="${y2.toFixed(1)}"${color?` style="stroke:${color};stroke-opacity:.55"`:''}/>`;}
-function efficiencyChartSmoothPath(rows,x,y){
- const points=(rows||[]).map(row=>({x:Number(x(row)),y:Number(y(row.value))})),format=value=>value.toFixed(1);
- if(!points.length)return '';
- if(points.length===1)return `M${format(points[0].x)} ${format(points[0].y)}`;
- if(points.length===2)return `M${format(points[0].x)} ${format(points[0].y)} L${format(points[1].x)} ${format(points[1].y)}`;
- const intervals=points.slice(1).map((point,index)=>point.x-points[index].x),slopes=points.slice(1).map((point,index)=>(point.y-points[index].y)/intervals[index]),tangents=points.map((point,index)=>index===0?slopes[0]:index===points.length-1?slopes.at(-1):0);
- for(let index=1;index<points.length-1;index++){const previous=slopes[index-1],next=slopes[index],previousWidth=intervals[index-1],nextWidth=intervals[index];if(previous===0||next===0||previous*next<=0)tangents[index]=0;else{const left=2*nextWidth+previousWidth,right=nextWidth+2*previousWidth;tangents[index]=(left+right)/(left/previous+right/next);}}
- let path=`M${format(points[0].x)} ${format(points[0].y)}`;
- for(let index=0;index<points.length-1;index++){const start=points[index],end=points[index+1],width=intervals[index];path+=` C${format(start.x+width/3)} ${format(start.y+tangents[index]*width/3)} ${format(end.x-width/3)} ${format(end.y-tangents[index+1]*width/3)} ${format(end.x)} ${format(end.y)}`;}
- return path;
-}
-function renderEfficiencyChart(id,trend,key,label){
- const svg=$(id),tip=svg.parentElement?.querySelector('.efficiencyChartTip'),status=svg.parentElement?.querySelector('.efficiencyChartStatus'),hoverRatio=Number(svg.dataset.efficiencyHoverRatio),width=Math.max(120,Math.round(svg.clientWidth||520)),height=Math.max(40,Math.round(svg.clientHeight||96)),pad={left:9,right:9,top:10,bottom:16},samples=(trend||[]).map((row,index)=>({day:row.day,index,value:row.metrics?.[key]})),valid=samples.filter(row=>row.value!==null&&Number.isFinite(row.value));
- if(tip)tip.hidden=true;
- if(status)status.textContent='';
- if(!samples.length){delete svg.dataset.efficiencyHoverRatio;svg.setAttribute('viewBox',`0 0 ${width} ${height}`);svg.innerHTML=`<text class=efficiencyChartEmpty x=10 y="${Math.round(height/2+4)}">No daily evidence</text>`;svg.setAttribute('aria-label',`${label}: unavailable`);svg.onpointermove=null;svg.onpointerleave=null;svg.onfocus=null;svg.onkeydown=null;svg.onblur=null;return;}
- const maxValue=key==='reasoning_ratio'||key==='cache_hit_ratio'?1:valid.length?Math.max(1,...valid.map(row=>row.value)):1,plotWidth=width-pad.left-pad.right,plotHeight=height-pad.top-pad.bottom,x=row=>pad.left+(samples.length<=1?plotWidth/2:row.index*plotWidth/(samples.length-1)),y=value=>pad.top+plotHeight-(Math.max(0,value)/maxValue)*plotHeight;
- const last=valid.at(-1),{segments,bridges}=chartGapRuns(valid);
- const paths=bridges.map(([from,to])=>chartGapBridge(x(from),y(from.value),x(to),y(to.value))).join('')+segments.map(rows=>{if(rows.length===1)return rows[0]===last?'':`<circle class=efficiencyChartDot cx="${x(rows[0]).toFixed(1)}" cy="${y(rows[0].value).toFixed(1)}" r="2.5"/>`;const line=efficiencyChartSmoothPath(rows,x,y),area=`${line} L${x(rows.at(-1)).toFixed(1)} ${(pad.top+plotHeight).toFixed(1)} L${x(rows[0]).toFixed(1)} ${(pad.top+plotHeight).toFixed(1)} Z`;return `<path class=efficiencyChartArea d="${area}"/><path class=efficiencyChartLine d="${line}"/>`;}).join('');
- const format=value=>efficiencyChartMetricPresentation(value,key).axis,firstDay=samples[0]?.day?.slice(5)||'',lastDay=samples.at(-1)?.day?.slice(5)||'',latest=last?`<circle class=efficiencyChartDot cx="${x(last).toFixed(1)}" cy="${y(last.value).toFixed(1)}" r="3.5"/>`:'',empty=valid.length?'':`<text class=efficiencyChartEmpty x=10 y="${Math.round(height/2+4)}">No daily evidence</text>`,maxLabel=valid.length?`<text class=efficiencyChartLabel x="${width-pad.right}" y="${pad.top+8}" text-anchor=end>${esc(format(maxValue))}</text>`:'';
- svg.setAttribute('viewBox',`0 0 ${width} ${height}`);
- svg.innerHTML=`<line class=efficiencyChartGrid x1="${pad.left}" x2="${width-pad.right}" y1="${pad.top}" y2="${pad.top}"/><line class=efficiencyChartGrid x1="${pad.left}" x2="${width-pad.right}" y1="${pad.top+plotHeight}" y2="${pad.top+plotHeight}"/>${paths}${latest}${empty}<text class=efficiencyChartLabel x="${pad.left}" y="${height-2}">${esc(firstDay)}</text><text class=efficiencyChartLabel x="${width-pad.right}" y="${height-2}" text-anchor=end>${esc(lastDay)}</text>${maxLabel}<g class=efficiencyChartInspect visibility=hidden><line class=efficiencyChartInspectLine y1="${pad.top}" y2="${pad.top+plotHeight}"/><circle class=efficiencyChartInspectDot r="4"/></g>`;
- const instruction='Use Left and Right arrow keys to inspect daily values.',summaryLabel=`${last?`${label}: ${valid.length} daily values, latest ${format(last.value)}`:`${label}: unavailable`}. ${instruction}`;
- svg.setAttribute('aria-label',summaryLabel);
- let activeIndex=samples.length-1;
- const inspect=svg.querySelector('.efficiencyChartInspect'),line=inspect?.querySelector('line'),dot=inspect?.querySelector('circle'),hideInspection=()=>{inspect?.setAttribute('visibility','hidden');if(tip)tip.hidden=true;};
- const showInspection=(index,localX,announce=false)=>{const sample=samples[index],detail=efficiencyChartInspection(sample,key),pointX=x(sample);inspect?.setAttribute('visibility','visible');line?.setAttribute('x1',pointX.toFixed(1));line?.setAttribute('x2',pointX.toFixed(1));if(dot){if(sample.value===null||!Number.isFinite(sample.value))dot.setAttribute('visibility','hidden');else{dot.setAttribute('visibility','visible');dot.setAttribute('cx',pointX.toFixed(1));dot.setAttribute('cy',y(sample.value).toFixed(1));}}const text=`${detail.date} · ${detail.value}`;if(tip){const rect=svg.getBoundingClientRect(),edge=Math.min(105,rect.width/2);tip.textContent=text;tip.style.left=`${Math.max(edge,Math.min(rect.width-edge,localX))}px`;tip.hidden=false;}if(status)status.textContent=efficiencyChartAnnouncement(detail,announce);};
- svg.onpointermove=event=>{const rect=svg.getBoundingClientRect(),localX=Math.max(0,Math.min(rect.width,event.clientX-rect.left));svg.dataset.efficiencyHoverRatio=String(localX/Math.max(1,rect.width));activeIndex=efficiencyChartPointerIndex(event.clientX,rect,samples.length);showInspection(activeIndex,localX);};
- svg.onpointerleave=()=>{delete svg.dataset.efficiencyHoverRatio;hideInspection();svg.setAttribute('aria-label',summaryLabel);};
- svg.onfocus=()=>{const rect=svg.getBoundingClientRect();activeIndex=samples.length-1;showInspection(activeIndex,rect.width*x(samples[activeIndex])/width,true);};
- svg.onkeydown=event=>{if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;event.preventDefault();activeIndex=efficiencyChartKeyIndex(event.key,activeIndex,samples.length);const rect=svg.getBoundingClientRect();showInspection(activeIndex,rect.width*x(samples[activeIndex])/width,true);};
- svg.onblur=()=>{hideInspection();svg.setAttribute('aria-label',summaryLabel);if(status)status.textContent='';};
- if(svg.matches(':hover')&&Number.isFinite(hoverRatio)){const rect=svg.getBoundingClientRect(),localX=Math.max(0,Math.min(rect.width,rect.width*hoverRatio));activeIndex=efficiencyChartPointerIndex(rect.left+localX,rect,samples.length);showInspection(activeIndex,localX);}
-}
-function updateEfficiencySortHeaders(){
- document.querySelectorAll('[data-efficiency-sort]').forEach(button=>{const active=button.dataset.efficiencySort===efficiencySort.key,th=button.closest('th'),mark=button.querySelector('.efficiencySortMark');th?.setAttribute('aria-sort',active?(efficiencySort.direction==='asc'?'ascending':'descending'):'none');if(mark)mark.textContent=active?(efficiencySort.direction==='asc'?'↑':'↓'):'';});
-}
-function efficiencyDecimal(value,suffix='x'){
- if(value===null||!Number.isFinite(value))return '--';
- const digits=value>=100?0:value>=10?1:2;
- return value.toFixed(digits).replace(/\.0+$/,'')+suffix;
-}
-function efficiencyCoverageNote(overall,metric,label){
- const coverage=overall.coverage?.[metric]||{},covered=Number(coverage.covered_rows||0),total=Number(coverage.total_rows||0);
- if(!covered)return `${label} unavailable`;
- return `${label} · ${f(covered)} / ${f(total)} models${coverage.complete?'':' · partial'}`;
-}
-function efficiencyEstimateNote(row){
- const basis=usageBasis(row);
- return basis==='mixed'?' · includes local estimates':basis==='local_estimate'?' · local estimate':'';
-}
-function efficiencyReasoningPresentation(data,metric){
- const executions=Math.max(0,Number(data?.executions)||0),reasoningExecutions=Math.max(0,Number(data?.reasoning_executions)||0),thinkingExecutions=Math.min(executions,Math.max(0,Number(data?.thinking_executions)||0));
- if(metric?.reasoning_ratio!==null&&Number.isFinite(metric?.reasoning_ratio))return {value:pct(metric.reasoning_ratio),note:`${f(reasoningExecutions)} / ${f(executions)} exec`};
- if(thinkingExecutions>0&&executions>0)return {value:`${pct(thinkingExecutions/executions)} thinking execs`,note:'token ratio unavailable'};
- return {value:'--',note:'unavailable'};
-}
-function efficiencySummaryPresentation(data){
- const metric=efficiencyMetrics(data),reasoning=efficiencyReasoningPresentation(data,metric),estimate=hasLocalEstimate(data)?' · local est':'';
- const outputAvailable=metric.output_per_dollar!==null&&Number.isFinite(metric.output_per_dollar),outputNote=outputAvailable?(data?.coverage?.cost?.complete===false?'partial':'covered'):'unavailable';
- return {output:{value:outputAvailable?`${compactNumber(metric.output_per_dollar)} / $`:'--',note:outputNote+(outputAvailable?estimate:'')},reasoning:{value:reasoning.value,note:reasoning.note+(reasoning.value!=='--'?estimate:'')}};
-}
-function sessionEfficiencySource(s){
- if(Array.isArray(s?.selected_stats?.model_stats))return s.selected_stats;
- const id=stateSessionId(s),key=String(s?.source?.key||''),rows=s?.xsession?.sessions||[];
- const summary=key?rows.find(row=>String(row?.key||'')===key):rows.find(row=>String(row?.id||'')===String(id||''));
- return summary||s||{};
-}
-function normalizeSessionEfficiencyAggregate(overall){
- const data=overall||{},reasoningAvailable=Number(data.reasoning_executions||0)>0&&Number(data.reasoning_output_tokens||0)>0;
- return {...data,availability:{...(data.availability||{}),reasoning_tokens:reasoningAvailable}};
-}
-function renderSessionEfficiency(s){
- const source=sessionEfficiencySource(s),overall=normalizeSessionEfficiencyAggregate(aggregateModelDays(source.model_stats||[]));
- if(hasLocalEstimate(source)||hasLocalEstimate(s)){overall.usage_basis=usageBasis(source)||usageBasis(s);overall.provenance={usage_basis:overall.usage_basis};}
- const presentation=efficiencySummaryPresentation(overall);
- $('session-output-dollar').textContent=presentation.output.value;
- $('session-output-dollar-note').textContent=presentation.output.note;
- $('session-reasoning-ratio').textContent=presentation.reasoning.value;
- $('session-reasoning-ratio-note').textContent=presentation.reasoning.note;
-}
-function renderEfficiency(stats){
- const allModels=(stats?.models||[]).map(row=>({...row,id:row.id||row.model,runtime:row.runtime||(row.providers||[]).join(' + ')||'unknown runtime'})),window=efficiencyRangeWindow();
- efficiencyFilters=migrateModelRuntimeFilters(efficiencyFilters,allModels);saveActiveEfficiencyFilters();
- const allSelected=!efficiencyFilters.length,selected=filterEfficiencyModels(allModels,efficiencyFilters),options=allModels.slice().sort((a,b)=>modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b))),rows=efficiencyModelRows(selected,window),efficiencyModelRowsForRange=rows.map(row=>row.window),overall=aggregateModelDays(efficiencyModelRowsForRange),metrics=efficiencyMetrics(overall),rangeLabel=modelRangeLabel(efficiencyRange);
- const pickerOptions=`<label class="modelOption all"><input type=checkbox data-efficiency-model-choice=all ${allSelected?'checked':''}><span>All model/runtime/budget rows</span></label>`+options.map(row=>{const label=modelRuntimeLabel(row);return `<label class=modelOption title="${esc(label)}"><input type=checkbox data-efficiency-model-choice=model value="${esc(row.id)}" ${efficiencyFilters.includes(row.id)?'checked':''}><span>${esc(label)}</span></label>`;}).join('');
- setLogHtml($('e-model-options'),pickerOptions);
- if($('e-model-picker').open)requestAnimationFrame(positionEfficiencyPickerMenu);
- const selectionLabel=allSelected?'All model runtimes':selected.length===1?modelRuntimeLabel(selected[0]):`${selected.length} model runtimes selected`;
- $('e-model-summary').textContent=selectionLabel;$('e-model-summary').title=allSelected?'All model runtimes':selected.map(modelRuntimeLabel).join(', ');
- $('e-range').value=efficiencyRange;
- $('e-output-dollar').textContent=metrics.output_per_dollar===null?'--':`${compactNumber(metrics.output_per_dollar)} / $`;
- $('e-output-dollar-coverage').textContent=efficiencyCoverageNote(overall,'cost','Coverage')+efficiencyEstimateNote(overall);
- $('e-reasoning-ratio').textContent=metrics.reasoning_ratio===null?'--':pct(metrics.reasoning_ratio);
- const reasoningCovered=Number(overall.reasoning_executions||0),reasoningTotal=Number(overall.executions||0),thinkingUnavailable=efficiencyModelRowsForRange.reduce((total,row)=>total+thinkingUnavailableExecutions(row),0),thinkingNote=thinkingUnavailable?` · ${f(thinkingUnavailable)} thinking exec · token split unavailable`:'';
- $('e-reasoning-coverage').textContent=(reasoningCovered?`Thinking / reasoning coverage · ${f(reasoningCovered)} / ${f(reasoningTotal)} exec${thinkingNote}`:thinkingUnavailable?`${f(thinkingUnavailable)} thinking exec · token split unavailable`:'Thinking / reasoning coverage unavailable')+efficiencyEstimateNote(overall);
- const comparison=efficiencyComparisonWindows(efficiencyRange),priorOverall=comparison?aggregateModelDays(efficiencyModelRows(selected,comparison.prior).map(row=>row.window)):null,priorMetrics=priorOverall?efficiencyMetrics(priorOverall):null,comparisonDelta=key=>comparison?efficiencyPeriodDelta(metrics,priorMetrics,key,comparison.label):{text:'No comparable prior period',direction:''},trend=efficiencyTrendDays(rows,window),outputDelta=comparisonDelta('output_per_dollar'),reasoningDelta=comparisonDelta('reasoning_ratio'),contextDelta=comparisonDelta('context_load'),cacheHitDelta=comparisonDelta('cache_hit_ratio');
- renderTrendDelta('e-output-dollar-change',outputDelta,'up',!comparison);renderTrendDelta('e-reasoning-change',reasoningDelta,'down',!comparison);renderTrendDelta('e-context-load-change',contextDelta,'down',!comparison);renderTrendDelta('e-cache-hit-change',cacheHitDelta,'up',!comparison);
- renderEfficiencyChart('e-output-dollar-chart',trend,'output_per_dollar','Output per covered dollar');renderEfficiencyChart('e-reasoning-chart',trend,'reasoning_ratio','Reasoning ratio');renderEfficiencyChart('e-context-load-chart',trend,'context_load','Context load');renderEfficiencyChart('e-cache-hit-chart',trend,'cache_hit_ratio','Cache hit ratio');
- $('e-context-load').textContent=efficiencyDecimal(metrics.context_load);
- const ioCovered=Number(overall.io_covered_executions||0),ioTotal=Number(overall.executions||0);
- $('e-context-load-note').textContent=metrics.context_load===null?(overall.availability?.input_tokens===true&&overall.availability?.output_tokens===true?'no executions with paired input/output':'input/output evidence unavailable'):ioCovered<ioTotal?`input per output token · paired coverage ${f(ioCovered)} / ${f(ioTotal)} exec`:'input tokens per output token';
- $('e-cache-hit').textContent=metrics.cache_hit_ratio===null?'--':pct(metrics.cache_hit_ratio);
- $('e-cache-hit-note').textContent=metrics.cache_hit_ratio===null?'cache evidence unavailable':`${compactNumber(overall.cache_read_tokens||0)} cached of ${compactNumber(overall.cache_covered_input_tokens??overall.input_tokens??0)} input`+efficiencyEstimateNote(overall);
- $('e-model-meta').textContent=`${f(rows.length)} models${efficiencyEstimateNote(overall)}`;updateEfficiencySortHeaders();
-	 const sortedRows=sortEfficiencyRows(rows);$('e-model-table').querySelector('tbody').innerHTML=sortedRows.length?sortedRows.map(row=>{const data=row.window,metric=efficiencyMetrics(row.window),reasoning=efficiencyReasoningPresentation(data,metric),tokenExecutions=Number(data.token_covered_executions===undefined?data.executions:data.token_covered_executions)||0,ioExecutions=Number(data.io_covered_executions===undefined?tokenExecutions:data.io_covered_executions)||0,contextCoverage=ioExecutions>=Number(data.executions||0)&&data.coverage?.tokens?.complete!==false?'covered':'partial',estimate=hasLocalEstimate(row)?' · local est':'',effort=efficiencyEffortLabel(row);return `<tr><td><div class=modelName title="${esc(row.model)}">${esc(row.model)}</div></td><td>${esc(row.runtime)}${estimate}</td><td>${esc(effort)}</td><td class="num efficiencyMetric"><strong class=mono>${data.availability?.cost===false?'--':money(data.cost)}</strong><span>${data.availability?.cost===false?'unavailable':data.coverage?.cost?.complete?'covered':'partial'}</span></td><td class="num efficiencyMetric"><strong class=mono>${metric.output_per_dollar===null?'--':compactNumber(metric.output_per_dollar)+' / $'}</strong><span>${metric.output_per_dollar===null?'unavailable':data.coverage?.cost?.complete?'covered':'partial'}</span></td><td class="num efficiencyMetric"><strong class=mono>${reasoning.value}</strong><span>${reasoning.note}</span></td><td class="num efficiencyMetric"><strong class=mono>${efficiencyDecimal(metric.context_load)}</strong><span>${contextCoverage}</span></td><td class="num efficiencyMetric"><strong class=mono>${metric.cache_hit_ratio===null?'--':pct(metric.cache_hit_ratio)}</strong><span>${metric.cache_hit_ratio===null?'unavailable':'cache read'}</span></td></tr>`;}).join(''):'<tr><td colspan=8><div class="modelEmpty emptyState">No model activity in this range</div></td></tr>';
-}
-function paintEfficiencyProjects(stats){
- const projects=(stats?.projects||[]).filter(project=>typeof project==='string'&&project);
- if(efficiencyProject&&!projects.includes(efficiencyProject)){efficiencyProject='';efficiencyFilters=loadEfficiencyFilters('');localStorage.removeItem('tm_efficiency_project');}
- setLogSelectOptions($('e-project'),'<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(projectFilterLabel(project))}</option>`).join(''),efficiencyProject);
- $('e-project').title=stats?.projects_truncated?'Showing the first 500 discovered projects.':'';
-}
-function setEfficiencyProjectLoading(loading){if(loading)$('e-project').setAttribute('aria-busy','true');else $('e-project').removeAttribute('aria-busy');}
-function commitEfficiencyStats(stats,scope,generation){activeEfficiencyStats=stats;activeEfficiencyScope=scope;activeEfficiencyGeneration=generation;setEfficiencyProjectLoading(false);renderEfficiency(stats);}
-async function renderActiveEfficiency(){
- if(!LATEST)return;
- const machine=LATEST.xsession?.model_stats||{models:[],projects:[]},generation=Number(LATEST.xsession?.generated_at||0);paintEfficiencyProjects(machine);
- if(!efficiencyProject){efficiencyProjectRequest++;efficiencyProjectLoadingKey='';setEfficiencyProjectLoading(false);commitEfficiencyStats(machine,'',generation);return;}
- const project=efficiencyProject,key=`${generation}\n${project}`,cached=efficiencyProjectCache.get(key);
- if(cached){commitEfficiencyStats(cached,project,generation);return;}
- if(efficiencyProjectLoadingKey===key)return;
- setEfficiencyProjectLoading(true);efficiencyProjectLoadingKey=key;const request=++efficiencyProjectRequest;
- try{
-  const response=await fetch('/model-stats?project='+encodeURIComponent(project),{cache:'no-store'}),payload=await response.json();
-  if(!response.ok||!payload.ok)throw new Error('Project model stats are unavailable.');
-  if(request!==efficiencyProjectRequest||project!==efficiencyProject)return;
-  const responseGeneration=Number(payload.generated_at||generation);efficiencyProjectCache.set(key,payload.model_stats);efficiencyProjectCache.set(`${responseGeneration}\n${project}`,payload.model_stats);commitEfficiencyStats(payload.model_stats,project,responseGeneration);
- }catch(error){if(request===efficiencyProjectRequest&&project===efficiencyProject)setEfficiencyProjectLoading(false);}
- finally{if(efficiencyProjectLoadingKey===key){efficiencyProjectLoadingKey='';setEfficiencyProjectLoading(false);}}
-}
-function rerenderActiveEfficiency(){
- if(activeEfficiencyStats&&activeEfficiencyScope===efficiencyProject)renderEfficiency(activeEfficiencyStats);
- else renderActiveEfficiency();
-}
-$('e-range').value=efficiencyRange;
-$('e-range').onchange=event=>{efficiencyRange=EFFICIENCY_RANGES.includes(event.target.value)?event.target.value:'30';localStorage.setItem('tm_efficiency_range',efficiencyRange);if(LATEST)renderActiveEfficiency();};
-$('e-project').addEventListener('change',event=>{efficiencyProject=event.target.value;efficiencyFilters=loadEfficiencyFilters(efficiencyProject);if(efficiencyProject)localStorage.setItem('tm_efficiency_project',efficiencyProject);else localStorage.removeItem('tm_efficiency_project');efficiencyProjectRequest++;efficiencyProjectLoadingKey='';renderActiveEfficiency();});
-$('e-model-options').addEventListener('change',event=>{const input=event.target.closest('input[data-efficiency-model-choice]');if(!input)return;if(input.dataset.efficiencyModelChoice==='all')efficiencyFilters=[];else if(input.checked)efficiencyFilters=[...new Set([...efficiencyFilters,input.value])];else efficiencyFilters=efficiencyFilters.filter(id=>id!==input.value);saveActiveEfficiencyFilters();rerenderActiveEfficiency();});
-$('e-model-picker').addEventListener('keydown',event=>{if(event.key==='Escape')$('e-model-picker').removeAttribute('open');});
-document.addEventListener('pointerdown',event=>{const picker=$('e-model-picker');if(picker.open&&!picker.contains(event.target))picker.removeAttribute('open');});
-function positionEfficiencyPickerMenu(){const picker=$('e-model-picker'),menu=$('e-model-options');if(!picker.open){picker.classList.remove('opensUp');menu.style.maxHeight='';return;}const trigger=picker.querySelector('summary'),rect=trigger.getBoundingClientRect(),margin=12,above=Math.max(0,rect.top-margin),below=Math.max(0,window.innerHeight-rect.bottom-margin),preferred=Math.min(360,menu.scrollHeight||360),opensUp=below<preferred&&above>below,available=opensUp?above:below;picker.classList.toggle('opensUp',opensUp);menu.style.maxHeight=`${Math.min(360,available)}px`;}
-$('e-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionEfficiencyPickerMenu));
-window.addEventListener('resize',()=>{if($('e-model-picker').open)positionEfficiencyPickerMenu();});
-document.querySelectorAll('[data-efficiency-sort]').forEach(button=>button.onclick=()=>{const key=button.dataset.efficiencySort;if(efficiencySort.key===key)efficiencySort={key,direction:efficiencySort.direction==='desc'?'asc':'desc'};else efficiencySort={key,direction:key==='model'?'asc':'desc'};if(activeEfficiencyStats)renderEfficiency(activeEfficiencyStats);});
-function filledModelDays(rows,window){
- if(!window.days)return rows;
- const byDay=new Map(rows.map(row=>[row.day,row]));
- return window.days.map(day=>byDay.get(day)||{day});
-}
-function modelEffortLabel(row){
- const effort=String(row?.reasoning_effort||'').trim().replaceAll('_',' ');
- if(effort)return effort;
- return Number(row?.thinking_executions||0)>0?'thinking unavailable':'unavailable';
-}
-// Claude Code and Codex leave effort empty when the app's default is in use; other apps never record it.
-function efficiencyEffortLabel(row){
- const providers=row?.providers||[];
- if(!String(row?.reasoning_effort||'').trim()&&providers.length&&providers.every(p=>p==='claude'||p==='codex'))return 'default';
- return modelEffortLabel(row);
-}
-function modelRuntimeLabel(row){return `${row.model} · ${row.runtime||'unknown runtime'} · ${modelEffortLabel(row)}`;}
-function migrateModelRuntimeFilters(filters,models){
- const ids=new Set(models.map(row=>row.id)),migrated=[];
- (filters||[]).forEach(value=>{if(ids.has(value)){migrated.push(value);return;}const legacy=models.filter(row=>`${row.model}::${row.runtime||'unknown runtime'}`===value);if(legacy.length){migrated.push(...legacy.map(row=>row.id));return;}const candidates=models.filter(row=>row.model===value).sort((a,b)=>Number(b.output_tokens||0)-Number(a.output_tokens||0));if(candidates.length)migrated.push(candidates[0].id);});
- return [...new Set(migrated)];
-}
-function buildModelTrend(models,window,names){
- const byModel=models.map(model=>({id:model.id,model:modelRuntimeLabel(model),color:modelColor(model.id,names),estimated:hasLocalEstimate(model),byDay:new Map((model.daily||[]).filter(row=>modelDayInRange(row.day,window)).map(row=>[row.day,row]))}));
- const days=window.days||[...new Set(byModel.flatMap(model=>[...model.byDay.keys()]))].sort();
- return {days,series:byModel.map(model=>({id:model.id,model:model.model,color:model.color,estimated:model.estimated,points:days.map(day=>{const row=model.byDay.get(day)||{day};return {...row,perf:aggregateModelDays([row])};})}))};
-}
-function modelTokensPerExecution(row,key){
- const executions=Number(row.executions||0);
- return executions?Number(row[key]||0)/executions:0;
-}
-const MODEL_TREND_METRICS={
- speed:{note:'observed tok/s',axis:'tok/s',format:speedFmt,value:row=>Number(row.perf.output_tps||0),available:row=>Boolean(row.perf.available)},
- wait:{note:'median wait',axis:'median wait',format:waitFmt,value:row=>Number(row.perf.median_wait_s||0),available:row=>Number(row.perf.wait_samples||0)>0},
- avg_input:{note:'avg input / execution',axis:'input / exec',format:compactNumber,value:row=>modelTokensPerExecution(row,'input_tokens'),available:row=>metricAvailable(row,'tokens')&&Number(row.executions||0)>0},
- avg_output:{note:'avg output / execution',axis:'output / exec',format:compactNumber,value:row=>modelTokensPerExecution(row,'output_tokens'),available:row=>metricAvailable(row,'tokens')&&Number(row.executions||0)>0},
-};
-function modelTrendRowHasUsage(row){
- return Number(row?.input_tokens||0)>0||Number(row?.output_tokens||0)>0||Number(row?.executions||0)>0;
-}
-function drawModelTrend(chart){
- const svg=$('m-chart'),tip=$('m-chart-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||270)),ML=62,MR=72,MT=18,MB=38,PW=VW-ML-MR,PH=VH-MT-MB;svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- const days=chart.days||[],series=chart.series||[],metric=MODEL_TREND_METRICS[modelTrendMetric]||MODEL_TREND_METRICS.speed;
- const hasData=series.some(model=>model.points.some(row=>Number(row.input_tokens||0)||Number(row.output_tokens||0)||Number(row.executions||0)||metric.available(row)));
- if(!days.length||!series.length||!hasData){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="${svgTextPx(svg,VW,VH,13)}">No model history in this window</text>`;tip.style.display='none';return;}
- const lineValue=metric.value,lineAvailable=metric.available;
- const maxOutput=Math.max(1,...series.flatMap(model=>model.points.map(row=>Number(row.output_tokens||0)))),maxLine=Math.max(1,...series.flatMap(model=>model.points.filter(lineAvailable).map(lineValue)));
- const step=PW/Math.max(1,days.length),groupW=Math.max(2,Math.min(30,step*.72)),barW=Math.max(.8,groupW/series.length);
- const x=index=>ML+step*(index+.5),outY=value=>MT+PH-PH*(Number(value||0)/maxOutput),lineY=value=>MT+PH-PH*(Number(value||0)/maxLine),lineFormat=metric.format;
- let html='';
- for(let i=0;i<=4;i++){const y=MT+PH*i/4;html+=`<line x1="${ML}" x2="${ML+PW}" y1="${y}" y2="${y}" stroke="${CHART.grid}" stroke-width="1"/><text x="${ML-8}" y="${y+4}" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${compactNumber(maxOutput*(1-i/4))}</text><text x="${ML+PW+8}" y="${y+4}" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${lineFormat(maxLine*(1-i/4))}</text>`;}
- days.forEach((day,index)=>series.forEach((model,modelIndex)=>{const row=model.points[index],y=outY(row.output_tokens),h=MT+PH-y,barX=x(index)-groupW/2+modelIndex*barW,paint=modelTrendPaint(model.color);html+=`<rect x="${barX}" y="${y}" width="${Math.max(.8,barW-.5)}" height="${Math.max(0,h)}" rx="2" fill="${paint.barFill}" stroke="${paint.barStroke}" stroke-opacity=".78"/>`;}));
- series.forEach(model=>{const paint=modelTrendPaint(model.color),{segments,bridges}=chartGapRuns(model.points.flatMap((row,index)=>lineAvailable(row)?[{index,x:x(index),y:lineY(lineValue(row))}]:[]));bridges.forEach(([from,to])=>{html+=chartGapBridge(from.x,from.y,to.x,to.y,paint.line);});segments.filter(segment=>segment.length>1).forEach(segment=>{html+=`<path d="${segment.map((point,index)=>`${index?'L':'M'}${point.x.toFixed(1)},${point.y.toFixed(1)}`).join(' ')}" fill="none" stroke="${paint.line}" stroke-width="2.5" ${model.estimated?'stroke-dasharray="6 4"':''} stroke-linecap="round" stroke-linejoin="round"/>`;});model.points.forEach((row,index)=>{if(lineAvailable(row))html+=`<circle cx="${x(index)}" cy="${lineY(lineValue(row))}" r="3.8" fill="${paint.line}" stroke="${CHART.ink}" stroke-width="2"/>`;});});
- const labelEvery=Math.max(1,Math.ceil(days.length/8));
- days.forEach((day,index)=>{const remaining=days.length-1-index,showLabel=index===days.length-1||(index%labelEvery===0&&remaining>=Math.max(2,Math.ceil(labelEvery/2)));if(showLabel)html+=`<text x="${x(index)}" y="${VH-12}" text-anchor="middle" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(day.slice(5))}</text>`;html+=`<rect data-model-day="${esc(day)}" x="${ML+step*index}" y="${MT}" width="${step}" height="${PH}" fill="transparent" pointer-events="all"/>`;});
- html+=`<text x="8" y="12" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">output</text><text x="${VW-8}" y="12" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(metric.axis)}</text>`;
- svg.innerHTML=html;
- svg.setAttribute('aria-label',`Daily model ${metric.note} and output token volume`);
- const cancelTipHide=()=>{if(tip._hideTimer){clearTimeout(tip._hideTimer);tip._hideTimer=0;}};
- const hideTip=()=>{cancelTipHide();tip.style.display='none';};
- const scheduleTipHide=()=>{cancelTipHide();tip._hideTimer=setTimeout(hideTip,180);};
- const show=(event,index)=>{
-  cancelTipHide();
-  const rect=$('m-chart').parentElement.getBoundingClientRect(),day=days[index],rows=series.map(model=>({model:model.model,color:model.color,row:model.points[index]})).filter(item=>modelTrendRowHasUsage(item.row)),dayChanged=tip.dataset.day!==day;
-  tip.innerHTML=`<div class=h>${esc(day)}</div>`+(rows.length?'':'<div class=r><span>No data</span></div>')+rows.map(item=>{
-   const outputAvailable=metricAvailable(item.row,'tokens');
-   const selectedAvailable=metric.available(item.row);
-   return `<div class=modelTipSeries><div class=modelTipName title="${esc(item.model)}"><i class=modelSwatch style="background:${item.color}"></i>${esc(item.model)}</div><div class=modelTipMetrics><span><small>output</small><b>${outputAvailable?compactNumber(item.row.output_tokens||0):'--'}</b></span><span><small>${esc(metric.note)}</small><b>${selectedAvailable?metric.format(metric.value(item.row)):'--'}</b></span></div></div>`;
-  }).join('');
-  tip.dataset.day=day;tip.style.display='block';
-  const pointerX=event.clientX-rect.left,rightX=pointerX+12,leftX=pointerX-tip.offsetWidth-12;
-  tip.style.left=(rightX+tip.offsetWidth<=rect.width-8?rightX:Math.max(8,leftX))+'px';tip.style.top=Math.max(8,event.clientY-rect.top-tip.offsetHeight-10)+'px';if(dayChanged)tip.scrollTop=0;
- };
- [...svg.querySelectorAll('[data-model-day]')].forEach((hit,index)=>{hit.onpointerenter=event=>show(event,index);hit.onpointermove=event=>show(event,index);hit.onpointerleave=scheduleTipHide;});
- tip.onpointerenter=cancelTipHide;tip.onpointerleave=scheduleTipHide;tip.onfocus=cancelTipHide;tip.onblur=scheduleTipHide;
-}
-function setModelKpiHelp(labelId,detail){
- const label=$(labelId);if(!label)return;
- const definition=label.dataset.helpDefinition||label.dataset.tip||'';
- if(!label.dataset.helpDefinition)label.dataset.helpDefinition=definition;
- const copy=[definition,detail].filter(Boolean).join(' ');
- label.dataset.tip=copy;label.setAttribute('aria-description',copy);
-}
-function renderMatchedPace(stats,selected){
- const value=$('m-change'),note=$('m-change-note');note.className='subline modelDelta';value.title='';note.title='';
- if(selected.length!==2){value.textContent='--';note.textContent='Select 2 models';note.title='Matched pace compares exactly two model-runtime histories.';return;}
- if(selected.some(hasLocalEstimate)){value.textContent='--';note.textContent='Unavailable for local estimates';note.title='Cursor local input-context and visible-output estimates are excluded from matched pace.';return;}
- const ids=new Set(selected.map(row=>row.id)),comparison=(stats?.matched_pace?.windows?.[modelRange]||[]).find(row=>ids.has(row.a_id)&&ids.has(row.b_id));
- if(!comparison){value.textContent='--';note.textContent='No pairwise timing';note.title='The selected histories do not contain comparable completed timing samples in this window.';return;}
- if(!comparison.available){value.textContent='--';note.textContent='Not enough matched evidence';note.title=`${comparison.reason} · ${f(comparison.a_samples)}/${f(comparison.b_samples)} timed. Token Meter withholds the verdict until there are at least 20 matched pairs covering 30% of the smaller eligible history.`;return;}
- const byId=new Map(selected.map(row=>[row.id,row])),ratio=Number(comparison.pace_ratio||0),low=Number(comparison.ci_low||0),high=Number(comparison.ci_high||0),uncertain=low<=1&&high>=1;
- const evidence=`${f(comparison.matched_pairs)} matched · ${pct(comparison.coverage)} coverage · 95% CI ${low.toFixed(2)}–${high.toFixed(2)}×`;
- if(uncertain){value.textContent='≈ same';note.textContent='No clear difference';value.title=`Observed ratio ${ratio.toFixed(2)}×; confidence interval includes parity.`;note.title=`${evidence}. The 95% confidence interval crosses 1.00, so the observed histories do not provide a clear faster-runtime verdict.`;return;}
- const fasterId=ratio>1?comparison.a_id:comparison.b_id,factor=ratio>1?ratio:1/ratio,faster=byId.get(fasterId);
- value.textContent=`${factor.toFixed(2)}×`;note.classList.add('up');note.textContent=`${modelRuntimeLabel(faster)} faster`;note.title=`${note.textContent} · ${evidence}`;
-}
-function setModelKpiValue(id,value,qualifier){
- const el=$(id);el.textContent=value;
- if(qualifier.trim()){const tag=document.createElement('small');tag.className='modelValueQual';tag.textContent=qualifier.trim();el.append(tag);}
-}
-const MODEL_OTHER_COLOR=THEME.modelOther;
-const MODEL_MIX_METRICS={
- cost:{label:'Cost',unit:'est. cost',value:day=>metricAvailable(day,'cost')?Number(day.cost||0):0,format:value=>money(value)},
- output:{label:'Output',unit:'output tokens',value:day=>metricAvailable(day,'tokens')?Number(day.output_tokens||0):0,format:compactNumber},
- executions:{label:'Executions',unit:'executions',value:day=>Number(day.executions||0),format:value=>f(Math.round(value))},
-};
-function modelGroupKey(row){return `${row.model}::${row.runtime||'unknown runtime'}`;}
-function modelGroupRows(selected,rangeWindow){
- const groups=new Map();
- selected.forEach(model=>{
-  const daily=(model.daily||[]).filter(day=>modelDayInRange(day.day,rangeWindow)),window=aggregateModelDays(daily);
-  if(!(window.input_tokens||window.output_tokens||window.executions||window.wait_samples||window.cost))return;
-  const key=modelGroupKey(model),group=groups.get(key)||{key,model:model.model,runtime:model.runtime,variants:[],daily:[]};
-  group.variants.push({...model,window});group.daily.push(...daily);groups.set(key,group);
- });
- return [...groups.values()].map(group=>({...group,window:aggregateModelDays(group.daily),ids:group.variants.map(row=>row.id),estimated:group.variants.some(hasLocalEstimate)}));
-}
-function modelBoardValue(row,key){
- const data=row.window||{},costAvailable=data.availability?.cost===true;
- if(key==='model')return `${row.model} · ${row.runtime}`;
- if(key==='cost')return costAvailable?Number(data.cost||0):null;
- if(key==='cost_per_exec'){
-  if(!costAvailable)return null;
-  const covered=Number(data.cost_covered_executions||0);
-  if(covered>0)return (Number(data.cost_covered_cost||0)||Number(data.cost||0))/covered;
-  return Number(data.executions||0)>0?Number(data.cost||0)/Number(data.executions):null;
- }
- if(key==='cache')return efficiencyMetrics(data).cache_hit_ratio;
- if(key==='executions')return Number(data.executions||0);
- if(key==='output')return metricAvailable(data,'tokens')?Number(data.output_tokens||0):null;
- if(key==='speed')return data.available?Number(data.output_tps||0):null;
- if(key==='wait')return data.wait_samples?Number(data.median_wait_s||0):null;
- if(key==='pushback')return row.variants?modelPushbackFor(row)?.rate??null:null;
- return null;
-}
-function sortModelBoard(rows,sort=modelSort){
- const direction=sort.direction==='asc'?1:-1,label=row=>`${row.model} · ${row.runtime} · ${row.reasoning_effort||''}`;
- return [...(rows||[])].sort((a,b)=>{const left=modelBoardValue(a,sort.key),right=modelBoardValue(b,sort.key);if(left===null&&right===null)return label(a).localeCompare(label(b));if(left===null)return 1;if(right===null)return -1;const compared=typeof left==='string'?left.localeCompare(right):left-right;return compared?compared*direction:label(a).localeCompare(label(b));});
-}
-function modelSpendRanking(groups){
- const label=row=>`${row.model} · ${row.runtime}`;
- return [...(groups||[])].sort((a,b)=>{const left=modelBoardValue(a,'cost'),right=modelBoardValue(b,'cost');if(left!==right&&(left===null||right===null))return left===null?1:-1;if(left!==null&&right!==null&&right!==left)return right-left;return (Number(modelBoardValue(b,'output'))||0)-(Number(modelBoardValue(a,'output'))||0)||label(a).localeCompare(label(b));});
-}
-function renderModelSpend(groups,ranking,top,allSelected){
- const costed=groups.filter(group=>modelBoardValue(group,'cost')!==null),uncosted=groups.length-costed.length,total=costed.reduce((sum,group)=>sum+Number(group.window.cost||0),0),partial=costed.some(group=>metricPartial(group.window,'cost'));
- $('m-spend-total').textContent=total>0?`≈ ${money(total)} est. · ${modelRangeLabel(modelRange)}${partial?' · partial':''}`:'Cost unavailable';
- const topKeys=new Set(top.map(group=>group.key)),topColor=modelRankedColors(top),segments=top.filter(group=>Number(modelBoardValue(group,'cost'))>0).map((group,index)=>({label:group.model,runtime:group.runtime,cost:Number(group.window.cost||0),color:topColor.get(group.key),ids:group.ids}));
- const rest=ranking.filter(group=>!topKeys.has(group.key)&&Number(modelBoardValue(group,'cost'))>0),restCost=rest.reduce((sum,group)=>sum+Number(group.window.cost||0),0);
- if(restCost>0)segments.push({label:`Other (${f(rest.length)})`,runtime:'',cost:restCost,color:MODEL_OTHER_COLOR,ids:[]});
- const share=segment=>total>0?segment.cost/total:0,name=segment=>segment.runtime?`${segment.label} · ${segment.runtime}`:segment.label;
- setLogHtml($('m-spend-bar'),total>0?segments.map(segment=>{const portion=share(segment),title=`${name(segment)} · ≈ ${money(segment.cost)} est. · ${pct(portion)}`,inner=portion>=.1?`<span>${esc(segment.label)}</span><b>${pct(portion)}</b>`:'';return segment.ids.length?`<button class=modelSpendSeg type=button style="flex:${portion} 1 0;background:${segment.color}" data-model-ids="${esc(segment.ids.join('\n'))}" title="${esc(title)} · click to focus" aria-label="${esc(title)}. Focus this model.">${inner}</button>`:`<div class=modelSpendSeg role=img style="flex:${portion} 1 0;background:${segment.color}" title="${esc(title)}" aria-label="${esc(title)}">${inner}</div>`;}).join(''):'<div class="modelSpendEmpty emptyState">No estimated cost in this window</div>');
- setLogHtml($('m-spend-legend'),segments.map(segment=>`<${segment.ids.length?`button type=button data-model-ids="${esc(segment.ids.join('\n'))}"`:'span'} class=modelSpendChip title="${esc(name(segment))}"><i style="background:${segment.color}"></i><span class=modelSpendChipName>${esc(segment.label)}</span>${segment.runtime?`<small>${esc(segment.runtime)}</small>`:''}<b class=mono>${money(segment.cost)}</b><em>${pct(share(segment))}</em></${segment.ids.length?'button':'span'}>`).join(''));
- const notes=[];
- if(uncosted){const detail=`${f(uncosted)} ${countWord(uncosted,'model runtime')} without cost data ${uncosted===1?'is':'are'} excluded, not counted as $0.`;notes.push(`<span class=fieldtip tabindex=0 aria-description="${esc(detail)}" data-tip="${esc(detail)}">${esc(`${f(uncosted)} unpriced, excluded`)}</span>`);}
- if(costed.some(group=>group.estimated))notes.push(esc('Includes Cursor local estimates.'));
- setLogHtml($('m-spend-note'),notes.join(' ')+(allSelected?'':' <button class=modelLinkBtn type=button data-model-clear>Show all models</button>'));
-}
-function drawModelMix(groups,top,rangeWindow){
- const svg=$('m-mix'),tip=$('m-mix-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||250)),ML=62,MR=18,MT=16,MB=34,PW=VW-ML-MR,PH=VH-MT-MB,metric=MODEL_MIX_METRICS[modelMixMetric];svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- const days=rangeWindow.days||[...new Set(groups.flatMap(group=>group.daily.map(day=>day.day)))].sort();
- const topIndex=new Map(top.map((group,index)=>[group.key,index])),topColor=modelRankedColors(top),series=[...top.map(group=>({label:`${group.model} · ${group.runtime}`,color:topColor.get(group.key),values:new Map()})),{label:'Other',color:MODEL_OTHER_COLOR,values:new Map()}];
- groups.forEach(group=>{const target=topIndex.has(group.key)?series[topIndex.get(group.key)]:series[series.length-1];group.daily.forEach(day=>target.values.set(day.day,(target.values.get(day.day)||0)+metric.value(day)));});
- const totals=days.map(day=>series.reduce((sum,item)=>sum+(item.values.get(day)||0),0)),max=Math.max(0,...totals);
- [...$('m-mix-metric').querySelectorAll('button')].forEach(button=>button.classList.toggle('on',button.dataset.modelMix===modelMixMetric));
- $('m-mix-note').textContent=`Top ${f(top.length)} by ${top.every(group=>Number(modelBoardValue(group,'cost'))>0)?'spend':top.some(group=>Number(modelBoardValue(group,'cost'))>0)?'spend, then output':'output'}${series[series.length-1].values.size?' + Other':''}`;
- if(!days.length||max<=0){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="${svgTextPx(svg,VW,VH,13)}">${esc(modelMixMetric==='cost'?'No estimated cost in this window. Try Output or Executions.':'No model activity in this window')}</text>`;tip.style.display='none';return;}
- const step=PW/Math.max(1,days.length),barW=Math.max(1,Math.min(34,step*.7)),x=index=>ML+step*(index+.5),h=value=>PH*value/max;
- let html='';
- for(let i=0;i<=4;i++){const y=MT+PH*i/4;html+=`<line x1="${ML}" x2="${ML+PW}" y1="${y}" y2="${y}" stroke="${CHART.grid}" stroke-width="1"/><text x="${ML-8}" y="${y+4}" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(metric.format(max*(1-i/4)))}</text>`;}
- days.forEach((day,index)=>{let base=MT+PH;series.forEach(item=>{const value=item.values.get(day)||0;if(value<=0)return;const height=h(value);base-=height;html+=`<rect x="${(x(index)-barW/2).toFixed(1)}" y="${base.toFixed(1)}" width="${barW.toFixed(1)}" height="${Math.max(0,height-.6).toFixed(1)}" fill="${item.color}" fill-opacity=".9"/>`;});});
- const labelEvery=Math.max(1,Math.ceil(days.length/8));
- days.forEach((day,index)=>{const remaining=days.length-1-index,showLabel=index===days.length-1||(index%labelEvery===0&&remaining>=Math.max(2,Math.ceil(labelEvery/2)));if(showLabel)html+=`<text x="${x(index)}" y="${VH-10}" text-anchor="middle" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(day.slice(5))}</text>`;html+=`<rect data-mix-day="${index}" x="${ML+step*index}" y="${MT}" width="${step}" height="${PH}" fill="transparent" pointer-events="all"/>`;});
- svg.innerHTML=html;svg.setAttribute('aria-label',`Daily ${metric.unit} stacked by model`);
- const hide=()=>{tip.style.display='none';};
- const show=(event,index)=>{
-  const rows=series.map(item=>({label:item.label,color:item.color,value:item.values.get(days[index])||0})).filter(item=>item.value>0);
-  if(!rows.length){hide();return;}
-  tip.innerHTML=`<div class=h>${esc(days[index])} · ${esc(metric.format(totals[index]))}</div>`+rows.map(item=>`<div class=r><span><i class=modelSwatch style="background:${item.color}"></i>${esc(item.label)}</span><b>${esc(metric.format(item.value))} · ${pct(item.value/totals[index])}</b></div>`).join('');
-  tip.style.display='block';
-  const rect=svg.parentElement.getBoundingClientRect(),pointerX=event.clientX-rect.left,rightX=pointerX+12,leftX=pointerX-tip.offsetWidth-12;
-  tip.style.left=(rightX+tip.offsetWidth<=rect.width-8?rightX:Math.max(8,leftX))+'px';tip.style.top=Math.max(8,event.clientY-rect.top-tip.offsetHeight-10)+'px';
- };
- [...svg.querySelectorAll('[data-mix-day]')].forEach(hit=>{const index=Number(hit.dataset.mixDay);hit.onpointerenter=event=>show(event,index);hit.onpointermove=event=>show(event,index);hit.onpointerleave=hide;});
-}
-const MODEL_PUSHBACK_PERIODS={today:'1d','7':'7d','30':'30d','90':'90d',month:'month',all:'0'},MODEL_PUSHBACK_TTL_MS=60000,MODEL_PUSHBACK_MAX_MODELS=20;
-let modelPushback={key:'',state:'idle',rates:new Map(),at:0,loading:false},modelPushbackRequest=0;
-function modelPushbackKey(){return `${modelRange}\u0000${modelProject}`;}
-function modelPushbackFor(row){return modelPushback.rates.get(`${row.model}\u0000${row.runtime}`)||null;}
-async function loadModelPushback(){
- const key=modelPushbackKey(),period=MODEL_PUSHBACK_PERIODS[modelRange];
- if(modelPushback.key===key&&(modelPushback.loading||modelPushback.state==='unsupported_range'||modelPushback.state==='unsupported'||Date.now()-modelPushback.at<MODEL_PUSHBACK_TTL_MS))return;
- if(!period){modelPushback={key,state:'unsupported_range',rates:new Map(),at:Date.now(),loading:false};return;}
- const request=++modelPushbackRequest,query=new URLSearchParams({months:period});
- if(modelProject)query.set('project',modelProject);
- modelPushback=modelPushback.key===key?{...modelPushback,loading:true}:{key,state:'loading',rates:new Map(),at:0,loading:true};
- let next={key,state:'unavailable',rates:new Map(),at:Date.now(),loading:false};
- try{
-  const response=await fetch(`/work?${query}`,{cache:'no-store'}),payload=await response.json();
-  if(response.ok&&payload.ok&&payload.insights){
-   const models=payload.insights.rework?.models||[];
-   next={key,state:payload.settings?.enabled?'ready':'off',rates:new Map(models.map(item=>[`${item.model}\u0000${item.runtime}`,item])),capped:models.length>=MODEL_PUSHBACK_MAX_MODELS,at:Date.now(),loading:false};
-  }else if(response.status===404&&!/project/i.test(payload.error||''))next={...next,state:'unsupported'};
- }catch(error){}
- if(request!==modelPushbackRequest)return;
- modelPushback=next;
- if(LATEST&&modelPushbackKey()===key)rerenderActiveModelStats();
-}
-function modelPushbackCell(row){
- if(!row.variants)return '<td class="num modelMuted"></td>';
- const item=modelPushbackFor(row),span=modelRange==='all'?' · last 24 months':'';
- if(item){
-  const tip=`${f(Math.round(item.rate*item.samples))} of ${f(item.samples)} labeled follow-ups pushed back${span}${item.few_samples?' · few samples, treat as a rough signal':''} · local model estimate`;
-  return `<td class="num mono${item.few_samples?' modelMuted':''}" title="${esc(tip)}">${pct(item.rate)}${item.few_samples?'*':''}</td>`;
- }
- const state=modelPushback.state;
- const reason=state==='unsupported_range'?'Pushback is not available for Yesterday or Last month. Choose another History range.':state==='unsupported'?'Work insights are not available on this system.':state==='loading'?'Loading pushback.':state==='off'?'Turn on Work insights in Settings to label follow-ups.':state==='unavailable'?'Pushback is unavailable right now. It retries shortly.':modelPushback.capped?`Not among the ${MODEL_PUSHBACK_MAX_MODELS} models with the most labeled follow-ups in this window.`:'No labeled follow-ups for this model in this window.';
- return `<td class="num modelMuted" title="${esc(reason)}">--</td>`;
-}
-function modelBoardCells(row,color,leaderCost,totalCost){
- const data=row.window,cost=modelBoardValue(row,'cost'),perExec=modelBoardValue(row,'cost_per_exec'),cache=modelBoardValue(row,'cache'),output=modelBoardValue(row,'output'),speed=modelBoardValue(row,'speed'),wait=modelBoardValue(row,'wait'),partial=metricPartial(data,'cost'),covered=Number(data.cost_covered_executions||0),perExecPartial=partial||(covered>0&&covered<Number(data.executions||0)),est=row.runtime==='Cursor'?' est':'';
- const spend=cost===null?`<td class="num modelMuted" title="Cost unavailable for this runtime">--</td>`:`<td class="num modelSpendCell"><span class=modelSpendTrack><i style="width:${leaderCost>0?Math.max(2,100*cost/leaderCost):0}%;background:${color}"></i></span><b class=mono>${money(cost)}${partial?'*':''}</b><small>${totalCost>0?pct(cost/totalCost):''}</small></td>`;
- const speedTip=data.available?`${speedFmt(data.output_tps)} tok/s average · ${data.throughput_basis==='tool_free'?'tool-free':'end-to-end'} timing · ${f(data.throughput_samples)} timed ${countWord(data.throughput_samples,'sample')} · ${pct(data.timing_coverage)} of output covered`:'No attributable output timing in this window.';
- const waitTip=data.wait_samples?`Prompt-to-completed-response wait. ${f(data.wait_samples)} timed ${countWord(data.wait_samples,'request')} · ${waitFmt(data.avg_wait_s)} average · ${waitFmt(data.p95_wait_s)} p95`:'No model-attributable completed waits in this window.';
- return `${spend}<td class="num mono">${perExec===null?'--':money(perExec)+(perExecPartial?'*':'')}</td><td class="num mono">${cache===null?'--':pct(cache)}</td><td class="num mono">${f(data.executions)}</td><td class="num mono">${output===null?'--':compactNumber(output)+est}</td><td class="num mono modelSpeedCell" title="${esc(speedTip)}">${speed===null?'--':speedFmt(speed)+est}</td><td class="num mono" title="${esc(waitTip)}">${wait===null?'--':waitFmt(wait)}</td>${modelPushbackCell(row)}`;
-}
-function modelBoardTip(row){
- const data=row.window,rowTokens=metricAvailable(data,'tokens'),cursorEstimate=row.runtime==='Cursor',basis=data.throughput_basis==='tool_free'?'tool-free':data.throughput_basis==='end_to_end'?'end-to-end':'unavailable',ttftNote=data.ttft_samples?`${Math.round(data.avg_ttft_ms)}ms avg TTFT`:'TTFT unavailable in these traces';
- const workload=`Typical workload (approximate shape, not semantic difficulty): ${compactNumber(data.median_peak_input_tokens)} median peak context · ${rowTokens?compactNumber(data.median_workload_output_tokens):'--'} median output · ${compactNumber(data.median_tool_calls)} median tools · ${compactNumber(data.median_model_calls)} median model calls${cursorEstimate?' · Cursor input/output are local proxies':''}.`;
- const pace=data.available?`Observed output pace ${speedFmt(data.output_tps)} tok/s (${basis} · ${f(data.throughput_samples)} ${countWord(data.throughput_samples,'sample')} · ${pct(data.timing_coverage)} coverage · ${ttftNote}); diagnostic, not a model verdict.`:'No attributable output timing in this window.';
- return `${row.model} · ${row.runtime}. Input ${rowTokens?compactNumber(data.input_tokens):'--'}. ${workload} ${pace}`;
-}
-const MODEL_SPEED_EXTRA_COLORS=THEME.modelSpeedExtra;
-function modelSpeedBasis(window){return Number(window?.tool_free_samples||0)>0&&Number(window?.tool_free_seconds||0)>0?'tool_free':'timed';}
-function modelSpeedSeries(daily,days,basis){
- const outKey=basis==='tool_free'?'tool_free_output_tokens':'timed_output_tokens',secKey=basis==='tool_free'?'tool_free_seconds':'timed_seconds',sampleKey=basis==='tool_free'?'tool_free_samples':'timed_samples';
- const byDay=new Map();
- (daily||[]).forEach(day=>{const target=byDay.get(day.day)||{out:0,sec:0,samples:0};target.out+=Number(day[outKey]||0);target.sec+=Number(day[secKey]||0);target.samples+=Number(day[sampleKey]||0);byDay.set(day.day,target);});
- return days.map((day,index)=>{
-  const own=byDay.get(day);if(!own||own.sec<=0||own.out<=0)return null;
-  let out=0,sec=0;for(let offset=-1;offset<=1;offset++){const near=byDay.get(days[index+offset]);if(near&&near.sec>0){out+=near.out;sec+=near.sec;}}
-  return {index,day,value:sec>0?out/sec:0,raw:own.out/own.sec,samples:own.samples};
- }).filter(Boolean);
-}
-function modelCalendarDays(values){
- const sorted=[...new Set((values||[]).filter(value=>/^\d{4}-\d{2}-\d{2}$/.test(value)))].sort();
- if(!sorted.length)return [];
- const out=[],cursor=new Date(`${sorted[0]}T12:00:00`),last=sorted[sorted.length-1];
- while(out.length<3700){const key=localDateKey(cursor);out.push(key);if(key>=last)break;cursor.setDate(cursor.getDate()+1);}
- return out;
-}
-function modelSpeedDefaultKeys(ranking){return ranking.filter(group=>group.window.available).slice(0,5).map(group=>group.key);}
-function modelSmoothPath(points){
- if(points.length<2)return '';
- const n=points.length,dx=[],slope=[],tangent=new Array(n).fill(0);
- for(let i=0;i<n-1;i++){dx[i]=points[i+1][0]-points[i][0];slope[i]=dx[i]?(points[i+1][1]-points[i][1])/dx[i]:0;}
- tangent[0]=slope[0];tangent[n-1]=slope[n-2];
- for(let i=1;i<n-1;i++)tangent[i]=slope[i-1]*slope[i]<=0?0:(slope[i-1]+slope[i])/2;
- for(let i=0;i<n-1;i++){if(slope[i]===0){tangent[i]=0;tangent[i+1]=0;continue;}const a=tangent[i]/slope[i],b=tangent[i+1]/slope[i],h=a*a+b*b;if(h>9){const t=3/Math.sqrt(h);tangent[i]=t*a*slope[i];tangent[i+1]=t*b*slope[i];}}
- let d=`M${points[0][0].toFixed(1)},${points[0][1].toFixed(1)}`;
- for(let i=0;i<n-1;i++){const [x0,y0]=points[i],[x1,y1]=points[i+1],third=dx[i]/3;d+=` C${(x0+third).toFixed(1)},${(y0+tangent[i]*third).toFixed(1)} ${(x1-third).toFixed(1)},${(y1-tangent[i+1]*third).toFixed(1)} ${x1.toFixed(1)},${y1.toFixed(1)}`;}
- return d;
-}
-function renderModelSpeedChart(groups,ranking,top,rangeWindow){
- const svg=$('m-speedchart-svg'),tip=$('m-speedchart-tip'),VW=Math.max(320,Math.round(svg.clientWidth||1040)),VH=Math.max(160,Math.round(svg.clientHeight||250)),ML=56,MR=18,MT=30,MB=34,PW=VW-ML-MR,PH=VH-MT-MB;svg.setAttribute('viewBox',`0 0 ${VW} ${VH}`);
- const timed=ranking.filter(group=>group.window.available),byKey=new Map(timed.map(group=>[group.key,group])),defaults=modelSpeedDefaultKeys(ranking);
- let keys=(modelSpeedSelection||defaults).filter(key=>byKey.has(key)),fallback=false;
- if(modelSpeedSelection&&!keys.length&&defaults.length){keys=defaults;fallback=true;}
- const topColor=modelRankedColors(top);let extra=0;
- const colorFor=key=>topColor.get(key)||MODEL_SPEED_EXTRA_COLORS[(extra++)%MODEL_SPEED_EXTRA_COLORS.length];
- const days=rangeWindow.days||modelCalendarDays(groups.flatMap(group=>group.daily.map(day=>day.day)));
- const series=keys.map(key=>{const group=byKey.get(key);return {key,label:`${group.model} · ${group.runtime}`,color:colorFor(key),estimated:group.estimated,points:modelSpeedSeries(group.daily,days,modelSpeedBasis(group.window))};});
- const custom=Boolean(modelSpeedSelection)&&!fallback;
- $('m-speedchart-summary').textContent=custom?`${f(keys.length)} ${countWord(keys.length,'model')} selected`:'Top 5 by spend';
- $('m-speedchart-reset').disabled=!modelSpeedSelection;
- const atMax=keys.length>=MODEL_SPEED_MAX_SERIES;
- setLogHtml($('m-speedchart-options'),timed.length?timed.map(group=>{const checked=keys.includes(group.key);return `<label class=modelOption title="${esc(group.model)} · ${esc(group.runtime)}"><input type=checkbox data-model-speed-choice="${esc(group.key)}" ${checked?'checked':''} ${!checked&&atMax?'disabled':''}><span>${esc(group.model)} · ${esc(group.runtime)} · ${esc(speedFmt(group.window.output_tps))} tok/s</span></label>`;}).join(''):'<div class="modelEmpty emptyState">No timed models in this window</div>');
- setLogHtml($('m-speedchart-legend'),series.map(item=>`<span class=modelSpeedChip><i style="background:${item.color}"></i>${esc(item.label)}${item.estimated?' <small>est</small>':''}</span>`).join(''));
- $('m-speedchart-note').textContent=`3-day avg output tok/s · ${custom?'your selection':`top ${f(keys.length)} by spend`}${fallback?' · your chosen models have no timing here':''}`;
- const values=series.flatMap(item=>item.points.map(point=>point.value)),max=values.length?Math.max(...values)*1.1:0;
- if(!series.length||max<=0){svg.innerHTML=`<text x="${VW/2}" y="${VH/2}" fill="${CHART.lbl}" text-anchor="middle" font-size="${svgTextPx(svg,VW,VH,13)}">No timed output in this window</text>`;tip.style.display='none';return;}
- const step=PW/Math.max(1,days.length),x=index=>ML+step*(index+.5),y=value=>MT+PH-PH*value/max;
- let html='';
- for(let i=0;i<=4;i++){const yy=MT+PH*i/4;html+=`<line x1="${ML}" x2="${ML+PW}" y1="${yy}" y2="${yy}" stroke="${CHART.grid}" stroke-width="1"/><text x="${ML-8}" y="${yy+4}" text-anchor="end" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(speedFmt(max*(1-i/4))==='--'?'0':speedFmt(max*(1-i/4)))}</text>`;}
- series.forEach(item=>{const {segments,bridges}=chartGapRuns(item.points);bridges.forEach(([from,to])=>{html+=chartGapBridge(x(from.index),y(from.value),x(to.index),y(to.value),item.color);});segments.forEach(segment=>{const pts=segment.map(point=>[x(point.index),y(point.value)]);if(pts.length>1)html+=`<path d="${modelSmoothPath(pts)}" fill="none" stroke="${item.color}" stroke-width="2.4" ${item.estimated?'stroke-dasharray="6 4"':''} stroke-linecap="round" stroke-linejoin="round"/>`;else html+=`<circle cx="${pts[0][0].toFixed(1)}" cy="${pts[0][1].toFixed(1)}" r="3.4" fill="${item.estimated?'none':item.color}" stroke="${item.color}" stroke-width="1.6"/>`;});});
- const labelEvery=Math.max(1,Math.ceil(days.length/8));
- days.forEach((day,index)=>{const remaining=days.length-1-index,showLabel=index===days.length-1||(index%labelEvery===0&&remaining>=Math.max(2,Math.ceil(labelEvery/2)));if(showLabel)html+=`<text x="${x(index)}" y="${VH-10}" text-anchor="middle" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">${esc(day.slice(5))}</text>`;html+=`<rect data-speed-day="${index}" x="${ML+step*index}" y="${MT}" width="${step}" height="${PH}" fill="transparent" pointer-events="all"/>`;});
- html+=`<text x="8" y="12" fill="${CHART.lbl}" font-size="${svgTextPx(svg,VW,VH)}">tok/s</text>`;
- svg.innerHTML=html;
- const hide=()=>{tip.style.display='none';};
- const show=(event,index)=>{
-  const rows=series.map(item=>({item,point:item.points.find(point=>point.index===index)})).filter(row=>row.point);
-  tip.innerHTML=`<div class=h>${esc(days[index])}</div>`+(rows.length?'':'<div class=r><span>No data</span></div>')+rows.map(({item,point})=>`<div class=r><span><i class=modelSwatch style="background:${item.color}"></i>${esc(item.label)}</span><b>${esc(speedFmt(point.value))} tok/s · ${f(point.samples)} ${countWord(point.samples,'sample')}</b></div>`).join('');
-  tip.style.display='block';
-  const rect=svg.parentElement.getBoundingClientRect(),pointerX=event.clientX-rect.left,rightX=pointerX+12,leftX=pointerX-tip.offsetWidth-12;
-  tip.style.left=(rightX+tip.offsetWidth<=rect.width-8?rightX:Math.max(8,leftX))+'px';tip.style.top=Math.max(8,event.clientY-rect.top-tip.offsetHeight-10)+'px';
- };
- [...svg.querySelectorAll('[data-speed-day]')].forEach(hit=>{const index=Number(hit.dataset.speedDay);hit.onpointerenter=event=>show(event,index);hit.onpointermove=event=>show(event,index);hit.onpointerleave=hide;});
-}
-function renderModelBoard(groups,ranking,top){
- loadModelPushback();
- const rank=new Map(ranking.map((group,index)=>[group.key,index+1])),topColor=modelRankedColors(top);
- const costs=groups.map(group=>modelBoardValue(group,'cost')).filter(value=>value!==null),leaderCost=Math.max(0,...costs),totalCost=costs.reduce((sum,value)=>sum+value,0);
- [...$('m-table').querySelectorAll('th')].forEach(th=>{const button=th.querySelector('[data-model-sort]');if(!button){th.removeAttribute('aria-sort');return;}const active=button.dataset.modelSort===modelSort.key;th.setAttribute('aria-sort',active?(modelSort.direction==='asc'?'ascending':'descending'):'none');button.classList.toggle('on',active);button.dataset.direction=active?modelSort.direction:'';});
- const html=sortModelBoard(groups).map(group=>{
-  const color=topColor.get(group.key)||MODEL_OTHER_COLOR,expandable=group.variants.length>1,expanded=expandable&&modelExpandedGroups.has(group.key),only=group.variants[0],tip=modelBoardTip(group);
-  const subline=expandable?`${f(group.variants.length)} reasoning efforts`:`${modelEffortLabel(only)} · ${f(only.logs)} ${countWord(only.logs,'log')}`;
-  const toggle=expandable?`<button class=modelExpand type=button data-model-expand="${esc(group.key)}" aria-expanded=${expanded} aria-label="${expanded?'Hide':'Show'} reasoning efforts for ${esc(group.model)} · ${esc(group.runtime)}">${expanded?'▾':'▸'}</button>`:'<span class=modelExpandSpacer></span>';
-  let rowHtml=`<tr class=modelGroupRow><td class="modelRankCol mono">${f(rank.get(group.key)||0)}</td><td class="fieldtip modelCellTip modelNameCell" tabindex=0 data-tip="${esc(tip)}" aria-description="${esc(tip)}"><div class=modelNameLine>${toggle}<i class=modelSwatch style="background:${color}"></i><div class=modelName title="${esc(group.model)}">${esc(group.model)}</div></div><div class=modelRuntime>${esc(group.runtime)}${group.estimated?' est':''} · ${esc(subline)}</div></td>${modelBoardCells(group,color,leaderCost,totalCost)}</tr>`;
-  if(expanded)rowHtml+=sortModelBoard(group.variants).map(variant=>`<tr class=modelVariantRow><td></td><td class="fieldtip modelCellTip" tabindex=0 data-tip="${esc(modelBoardTip(variant))}" aria-description="${esc(modelBoardTip(variant))}"><div class=modelVariantName>${esc(modelEffortLabel(variant))}<small>${f(variant.logs)} ${countWord(variant.logs,'log')}</small></div></td>${modelBoardCells(variant,color,leaderCost,totalCost)}</tr>`).join('');
-  return rowHtml;
- }).join('');
- setLogHtml($('m-table').querySelector('tbody'),html||`<tr><td colspan=10><div class="modelEmpty emptyState">No model activity in this window</div></td></tr>`);
-}
-const MODEL_FOCUS_KEYS=['modelExpand','modelIds','modelSort','modelMix','modelSpeedChoice'];
-function modelFocusKey(){
- const el=document.activeElement;if(!el||!el.dataset||!$('view-models').contains(el))return null;
- const key=MODEL_FOCUS_KEYS.find(name=>name in el.dataset);if(!key)return null;
- const container=el.closest('#m-spend-bar,#m-spend-legend,#m-table,#m-mix-metric,#m-speedchart-options')||$('view-models');
- return {el,key,value:el.dataset[key],containerId:container.id};
-}
-function restoreModelFocus(focus){
- if(!focus||focus.el.isConnected)return;
- const container=$(focus.containerId)||$('view-models'),attr='data-'+focus.key.replace(/[A-Z]/g,char=>'-'+char.toLowerCase());
- const target=[...container.querySelectorAll(`[${attr}]`)].find(el=>el.dataset[focus.key]===focus.value);
- if(target)target.focus({preventScroll:true});
-}
-function renderModelStats(stats){
- const focus=modelFocusKey();
- stats=stats||{models:[]};
- const allModels=(stats.models||[]).map(row=>({...row,id:row.id||row.model,runtime:row.runtime||(row.providers||[]).join(' + ')||'unknown runtime'})),names=allModels.map(row=>row.id).sort((a,b)=>a.localeCompare(b));
- modelFilters=migrateModelRuntimeFilters(modelFilters,allModels);saveActiveModelFilters();
- const allSelected=!modelFilters.length,selected=allModels.filter(row=>allSelected||modelFilters.includes(row.id)),rangeWindow=modelRangeWindow(modelRange),options=allModels.slice().sort((a,b)=>modelRuntimeLabel(a).localeCompare(modelRuntimeLabel(b)));
- const modelPickerOptions=`<label class="modelOption all"><input type=checkbox data-model-choice=all ${allSelected?'checked':''}><span>All model runtimes</span></label>`+options.map(row=>`<label class=modelOption title="${esc(modelRuntimeLabel(row))}"><input type=checkbox data-model-choice=model value="${esc(row.id)}" ${modelFilters.includes(row.id)?'checked':''}><span>${esc(modelRuntimeLabel(row))}</span></label>`).join('');
- setLogHtml($('m-model-options'),modelPickerOptions);
- if($('m-model-picker').open)requestAnimationFrame(positionModelPickerMenu);
- const selectionLabel=allSelected?'All model runtimes':selected.length===1?modelRuntimeLabel(selected[0]):`${selected.length} model runtimes selected`;$('m-model-summary').textContent=selectionLabel;$('m-model-summary').title=allSelected?'All model runtimes':selected.map(modelRuntimeLabel).join(', ');$('m-range').value=modelRange;
-	 const total=aggregateModelDays(mergeModelDays(selected,rangeWindow)),chart=buildModelTrend(selected,rangeWindow,names);
-	 const groups=modelGroupRows(selected,rangeWindow),ranking=modelSpendRanking(groups),top=ranking.slice(0,5);
-	 renderModelSpend(groups,ranking,top,allSelected);
-	 drawModelMix(groups,top,rangeWindow);
-	 renderModelSpeedChart(groups,ranking,top,rangeWindow);
-	 renderModelBoard(groups,ranking,top);
-	 [...$('m-metric').querySelectorAll('button')].forEach(button=>button.classList.toggle('on',button.dataset.modelMetric===modelTrendMetric));
-	 $('m-speed-label').textContent=total.throughput_basis==='tool_free'?'Tool-free output pace':'Observed output pace';
-	 setModelKpiValue('m-speed',total.available?speedFmt(total.output_tps)+' tok/s':'--',total.available?estimateSuffix(total):'');
-	 const speedDetail=total.available?`${total.throughput_basis==='tool_free'?'Tool-free':'End-to-end'} timing · ${f(total.throughput_samples)} timed ${countWord(total.throughput_samples,'sample')} · ${pct(total.timing_coverage)} output coverage.`:'No attributable timing in this window.';
-	 $('m-speed-note').textContent=total.available?`${pct(total.timing_coverage)} output covered`:'Timing unavailable';
-	 setModelKpiHelp('m-speed-label',speedDetail);
-	 $('m-coverage-bar').style.width=Math.max(0,Math.min(100,100*total.timing_coverage))+'%';
-	 $('m-coverage').setAttribute('aria-valuenow',String(Math.round(100*total.timing_coverage)));
-	 $('m-wait').textContent=total.wait_samples?waitFmt(total.median_wait_s):'--';
-	 const waitDetail=total.wait_samples?`${f(total.wait_samples)} timed · ${waitFmt(total.avg_wait_s)} average · ${waitFmt(total.p95_wait_s)} p95${total.user_pause_seconds?` · ${waitFmt(total.user_pause_seconds)} human pause excluded`:''}.`:'No model-attributable completed waits.';
-	 $('m-wait-note').textContent=total.wait_samples?`${f(total.wait_samples)} timed`:'Timing unavailable';
-	 setModelKpiHelp('m-wait-label',waitDetail);
-	 renderMatchedPace(stats,selected);
-	 setModelKpiHelp('m-change-label',$('m-change-note').title||$('m-change-note').textContent);
-	 $('m-trend-note').textContent=`Bars: daily output tokens · Lines: ${(MODEL_TREND_METRICS[modelTrendMetric]||MODEL_TREND_METRICS.speed).note} per model · ${modelScopeLabel()} · ${allSelected?'all runtimes':`${f(selected.length)} selected`} · ${modelRangeLabel(modelRange)}`;
-	 drawModelTrend(chart);
-	 restoreModelFocus(focus);
-}
-
-function capabilityCounts(capabilities,key){
- const counts=capabilities?.[key]||{},loaded=Number.isInteger(counts.loaded)?counts.loaded:null;
- return {loaded,used:Math.max(0,Number(counts.used)||0),basis:loaded==null?'unavailable':counts.basis==='configured'?'configured':'session'};
-}
-function capabilityRatio(counts){
- return `${f(counts.used)}/${counts.loaded==null?'—':f(counts.loaded)}${counts.basis==='configured'?'*':''}`;
-}
-function capabilitySummaryText(capabilities){
- return `Skills ${capabilityRatio(capabilityCounts(capabilities,'skills'))} · MCP ${capabilityRatio(capabilityCounts(capabilities,'mcp_servers'))}`;
-}
-const CAPABILITY_SUMMARY_TIP='Used / loaded skills and MCP servers. * means configured now, not recorded by this session. — means unavailable.';
-function logRowRenderKey(s,active){
- // Child subagent rows are part of this row's content, so a change in the
- // children must invalidate the cached innerHTML.
- return JSON.stringify([active,compareIds.indexOf(compareKeyFor(s)),compareIds.length>=COMPARE_MAX,sessionDeleteAvailable(s,renderedAllSessionActions),s.subagent,s.client,s.provider,s.label,s.title,s.project,s.last,s.start,s.wait_time,s.turns,s.cost,s.availability,s.models,s.model_identity,s.tokens,s.provenance,s.usage_basis,s.token_estimate,s.throughput,s.cost_approx,s.capabilities,childAgentsFor(s).map(c=>[c.id,c.cost,c.tokens,c.title,c.last,c.child_agent_role,c.child_depth,c.availability,c.models])]);
-}
-function logRowContent(s){
- const rowCost=metricAvailable(s,'cost'),localEstimate=hasLocalEstimate(s),avg=rowCost&&s.turns?money((s.cost||0)/s.turns)+estimateSuffix(s):'--';
- const wait=s.wait_time||{},waitText=wait.available?`${waitFmt(wait.total_s)} wait · ${waitFmt(wait.avg_s)} avg`:'wait unavailable';
- const identity=s.model_identity||{},unresolvedIdentity=identity.source==='unresolved',assignedIdentity=identity.source==='user_assigned',identityLabel={verified_parent:' · parent verified',verified_history:' · verified history',user_assigned:' · assigned'}[identity.source]||'';
- const candidates=Array.isArray(identity.candidates)?identity.candidates:[];
- const unresolvedModelText=identity.kind==='auto_review'?'Auto-review · model unconfirmed':(candidates.length?`${candidates.join(', ')} · configured alias candidate`:`${identity.observed_label||'Hermes model'} · unconfirmed`);
- const modelText=unresolvedIdentity?unresolvedModelText:`${(s.models||[]).join(', ')||'--'}${identityLabel}`,throughput=s.throughput||{},speed=throughput.available?` · ${speedFmt(throughput.output_tps)} ${localEstimate?'visible out tok/s est':'out tok/s'}`:'';
- const identityAction=identity.assignable&&identity.key?`<button class=sessionModelAssign data-session-model-identity="${esc(identity.key)}" type=button>${assignedIdentity?'Change model':(identity.kind==='missing_model'?'Add model':'Assign model')}</button>`:'';
- return `${compareToggleHtml(s)}<div><span class="badge app ${appBadgeClass(s)}">${runtimeMarkSvg(s)}${esc(s.label||s.provider)}</span></div>
-  <div class=sMain><div class=t>${s.subagent?'<span class="badge subagentTag">Subagent</span> ':''}${esc(s.title)}</div><div class=meta title="${esc(`${waitText} · ${avg}/exec${speed} · ${CAPABILITY_SUMMARY_TIP}`)}">${esc(s.project||'local')} · ${esc(s.last||s.start||'')} · ${esc(capabilitySummaryText(s.capabilities))}</div><div class=sbar><i></i></div>${childAgentSubsection(s)}</div>
-  <div class="badge models">${esc(modelText)}</div>
-  <div class=smetrics><div class="c mono" title="${esc(`${rowCost?(localEstimate?'local estimate':'cost'):(unresolvedIdentity?'model unconfirmed · billing unavailable':'billing unavailable')} · ${f(s.turns)} execs`)}">${costValueHtml(money(s.cost)+(s.cost_approx?' est':''),rowCost)}</div>${identityAction}</div>
-  <div class=sactions>${sessionDeleteAvailable(s,renderedAllSessionActions)?`<button class="sessionDelete sessionDeleteIcon" data-delete-session="${esc(sessionRowKey(s))}" type=button aria-label="Delete session" title="Delete session"><svg viewBox="0 0 24 24" aria-hidden=true><path d="M4 7h16M10 11v6M14 11v6M6 7l1 12a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2l1-12M9 7V4h6v3"/></svg></button>`:''}</div>`;
-}
-const CHILD_SECTION_LIMIT=6;
-function childAgentsFor(s){
- const children=childSessionMap.get(String(s?.id||''));
- return Array.isArray(children)?children:[];
-}
-function childRootId(row){return row?.is_child_session?String(row.root_session_id||''):'';}
-function indexChildSessions(rows){
- // Every descendant is keyed by its root session, so a nested run still renders
- // under the root card when its intermediate parent is itself a hidden child.
- childSessionMap=new Map();
- (rows||[]).forEach(row=>{
-  if(!row?.is_child_session)return;
-  const key=childRootId(row);
-  if(!key)return;
-  if(!childSessionMap.has(key))childSessionMap.set(key,[]);
-  childSessionMap.get(key).push(row);
- });
- childSessionMap.forEach(list=>list.sort((a,b)=>(b.cost||0)-(a.cost||0)||(b.mtime||0)-(a.mtime||0)));
- return childSessionMap;
-}
-function childAgentSubsection(s){
- const children=childAgentsFor(s);
- if(!children.length)return '';
- const shown=children.slice(0,CHILD_SECTION_LIMIT);
- const hidden=children.length-shown.length;
- const coveredCost=children.filter(row=>metricAvailable(row,'cost'));
- const totalCost=coveredCost.reduce((a,b)=>a+(b.cost||0),0);
- const coveredTokens=children.filter(row=>metricAvailable(row,'tokens'));
- const totalTokens=coveredTokens.reduce((a,b)=>a+(b.tokens||0),0);
- const stats=[
-  `<b>${f(children.length)}</b> ${countWord(children.length,'run')}`,
-  coveredCost.length?`<b>${money(totalCost)}</b> covered spend`:'spend unavailable',
-  totalTokens?`<b>${f(totalTokens)}</b> tok`:'',
- ].filter(Boolean).join(' · ');
- const rows=shown.map(child=>{
-  const childCost=metricAvailable(child,'cost');
-  const childTokens=metricAvailable(child,'tokens');
-  const role=child.child_agent_role?`<span class=subagentRole>${esc(child.child_agent_role)}</span>`:'';
-  const roleText=child.child_agent_role||'Unreported role';
-  const title=child.title||'Subagent run';
-  const depth=Number(child.child_depth)||1;
-  const detail=[roleText,depth>1?`nested depth ${f(depth)}`:'',(child.models||[]).join(', ')||child.primary_model||'--',child.last||''].filter(Boolean).join(' · ');
-  const costHtml=childCost
-   ?(child.cost>0?costValueHtml(money(child.cost)+(child.cost_approx?' est':''),true):`<span class=subagentZero title="Measured free-tier price">${money(0)}</span>`)
-   :'<span class=subagentZero>cost unavailable</span>';
-  return `<button class=subagentRow type=button data-open-session="${esc(sessionRowKey(child))}" aria-label="Open subagent run ${esc(title)}">
- <span class=subagentMain><span class=t>${role}${esc(title)}</span><span class=meta>${esc(detail)}</span></span>
- <span class=subagentTokens>${childTokens?f(child.tokens)+' tok':'tokens --'}</span>
- <span class=subagentCost>${costHtml}</span></button>`;
- }).join('');
- const more=hidden>0?`<div class=subagentMore>${f(hidden)} more ${countWord(hidden,'run')} not shown</div>`:'';
- return `<div class=subagents><div class=subagentsHead><span class=subagentsTitle>Subagents <b>${f(children.length)}</b></span><span class=subagentsStats>${stats}</span></div><div class=subagentList>${rows}</div>${more}</div>`;
-}
-function reconcileLogRows(sessions,maxCost,liveSessionIds=new Set()){
- const root=$('slist');
- const interactingLogRow=forceAllSessionRowRefresh?null:root.querySelector('.srow:hover,.srow:focus-within');
- if(interactingLogRow)return;
- forceAllSessionRowRefresh=false;
- if(!sessions.length){
-  setLogHtml(root,'<div class="signalEmpty emptyState">No sessions match the selected filters</div>');
-  return;
- }
- logHtmlCache.delete(root);
- const existing=new Map([...root.children].filter(row=>row.dataset.rowKey).map(row=>[row.dataset.rowKey,row]));
- const desired=new Set();
- let cursor=root.firstElementChild;
- const pinnedKey=pinned?(renderedAllSessions.has(pinned)?pinned:(stateSessionId(CURRENT)===pinned?stateSessionKey(CURRENT):'')):'';
- sessions.forEach(s=>{
-  const key=sessionRowKey(s),rowKey=compareKeyFor(s),active=pinned?key===pinnedKey:Boolean(LATEST&&key===stateSessionKey(LATEST));
-  desired.add(rowKey);
-  let row=existing.get(rowKey);
-  if(!row){
-   row=document.createElement('div');
-   row.dataset.id=key;
-   row.dataset.rowKey=rowKey;
-   row.setAttribute('role','button');
-   row.tabIndex=0;
-  }
-  const live=liveSessionIds.has(key),renderKey=logRowRenderKey(s,active),restoreDeleteFocus=document.activeElement?.dataset.deleteSession===key;
-  const hasChildren=childAgentsFor(s).length>0;
-  const compareIndex=compareIds.indexOf(rowKey);
-  const className=`srow${active?' active':''}${live?' live':''}${hasChildren?' hasChildren':''}${compareIndex>=0?' compareSelected':''}`,ariaLabel=`Open ${s.title}`;
-  if(compareIndex>=0)row.style.setProperty('--compare-color',COMPARE_COLORS[compareIndex]);else row.style.removeProperty('--compare-color');
-  if(row.className!==className)row.className=className;
-  if(row.getAttribute('aria-label')!==ariaLabel)row.setAttribute('aria-label',ariaLabel);
-  if(row._logRenderKey!==renderKey){
-   row.innerHTML=logRowContent(s);
-   row._logRenderKey=renderKey;
-   if(restoreDeleteFocus)requestAnimationFrame(()=>row.querySelector('[data-delete-session]')?.focus({preventScroll:true}));
-  }
-  const bar=row.querySelector('.sbar i'),width=metricAvailable(s,'cost')?Math.max(2,100*(s.cost||0)/maxCost):0,widthValue=`${width}%`;
-  if(bar&&bar.style.width!==widthValue)bar.style.width=widthValue;
-  if(row===cursor)cursor=cursor.nextElementSibling;
-  else root.insertBefore(row,cursor);
- });
- [...root.children].forEach(row=>{if(!desired.has(row.dataset.rowKey||''))row.remove();});
-}
-function compareColor(index){return COMPARE_COLORS[index%COMPARE_COLORS.length];}
-function compareKeyFor(row){return String(row?.key||row?.id||'');}
-function compareToggleHtml(s){
- const id=compareKeyFor(s),index=compareIds.indexOf(id),selected=index>=0,full=!selected&&compareIds.length>=COMPARE_MAX;
- const label=selected?`Remove ${s.title||'session'} from comparison`:full?`Comparison is full (${COMPARE_MAX} sessions)`:`Add ${s.title||'session'} to comparison`;
- return `<button class=compareToggle data-compare-toggle="${esc(id)}" data-compare-title="${esc(s.title||'')}" type=button aria-pressed="${selected}"${full?' aria-disabled=true':''} aria-label="${esc(label)}" title="${esc(selected?'Remove from comparison':full?`Comparison is full (${COMPARE_MAX})`:'Add to comparison')}"${selected?` style="--compare-color:${compareColor(index)}"`:''}><svg viewBox="0 0 16 16" aria-hidden=true><path d="M3.5 8.5l3 3 6-7"/></svg></button>`;
-}
-function compareTitle(key){
- if(!compareTitles.has(key)){
-  const row=(compareData?.sessions||[]).find(item=>item.key===key)||(compareData?.matches||[]).find(item=>item.key===key)||(allSessionInventory||[]).find(item=>compareKeyFor(item)===key);
-  if(row?.title)compareTitles.set(key,row.title);
- }
- return compareTitles.get(key)||'Session';
-}
-function setCompareIds(ids,{reload=true}={}){
- compareIds=[...new Set(ids.map(String).filter(Boolean))].slice(0,COMPARE_MAX);
- localStorage.setItem('tm_compare_ids',JSON.stringify(compareIds));
- if(!compareIds.includes(compareBaseline)){
-  compareBaseline=compareIds[0]||'';
-  localStorage.setItem('tm_compare_baseline',compareBaseline);
- }
- syncCompareSelectionUi();
- if(reload&&$('view-session').classList.contains('on')&&sessionScope==='compare')loadComparison();
-}
-function toggleCompareId(id){
- id=String(id||'');
- if(!id)return;
- if(compareIds.includes(id))setCompareIds(compareIds.filter(item=>item!==id));
- else if(compareIds.length<COMPARE_MAX){compareTitle(id);setCompareIds([...compareIds,id]);}
-}
-function syncCompareSelectionUi(){
- const count=compareIds.length,full=count>=COMPARE_MAX,badge=$('compare-tab-count');
- badge.hidden=!count;
- badge.textContent=count?String(count):'';
- badge.setAttribute('aria-label',`${count} selected`);
- document.querySelectorAll('#slist [data-compare-toggle]').forEach(button=>{
-  const id=button.dataset.compareToggle,index=compareIds.indexOf(id),selected=index>=0,row=button.closest('.srow');
-  button.setAttribute('aria-pressed',String(selected));
-  if(!selected&&full)button.setAttribute('aria-disabled','true');else button.removeAttribute('aria-disabled');
-  const title=button.dataset.compareTitle||'session';
-  button.setAttribute('aria-label',selected?`Remove ${title} from comparison`:full?`Comparison is full (${COMPARE_MAX} sessions)`:`Add ${title} to comparison`);
-  button.title=selected?'Remove from comparison':full?`Comparison is full (${COMPARE_MAX})`:'Add to comparison';
-  if(selected){button.style.setProperty('--compare-color',compareColor(index));row?.style.setProperty('--compare-color',compareColor(index));}
-  else{button.style.removeProperty('--compare-color');row?.style.removeProperty('--compare-color');}
-  row?.classList.toggle('compareSelected',selected);
- });
- const tray=$('compare-tray');
- tray.hidden=!count;
- if(!count){setLogHtml(tray,'');return;}
- const note=count<2?'Select one more session, or open Compare to find runs with the same title.':full?`Comparison is full (${COMPARE_MAX}).`:'';
- setLogHtml(tray,`<div class=compareTrayItems>${compareIds.map((id,index)=>`<span class=compareChip><b class=compareLetter style="--compare-color:${compareColor(index)}">${COMPARE_LETTERS[index]}</b><span title="${esc(compareTitle(id))}">${esc(compareTitle(id))}</span><button type=button data-compare-remove="${esc(id)}" aria-label="Remove ${esc(compareTitle(id))} from comparison">×</button></span>`).join('')}</div><div class=compareTrayActions>${note?`<span class=compareTrayNote>${esc(note)}</span>`:''}<button class=tbtn type=button data-compare-open>Compare ${count}</button><button class="tbtn compareClear" type=button data-compare-clear>Clear</button></div>`);
-}
-$('compare-tray').onclick=event=>{
- const remove=event.target.closest('[data-compare-remove]');
- if(remove){setCompareIds(compareIds.filter(id=>id!==remove.dataset.compareRemove));return;}
- if(event.target.closest('[data-compare-open]')){openSessionScope('compare');return;}
- if(event.target.closest('[data-compare-clear]'))setCompareIds([]);
-};
-async function loadComparison({force=false}={}){
- const key=compareIds.join(',');
- if(!compareIds.length){compareData=null;compareError='';compareNotice='';compareMissing=[];compareLoadedKey='';renderComparison();return;}
- if(!force&&key===compareLoadedKey&&(compareData||compareError))return;
- const request=++compareRequestSeq;
- compareLoading=true;
- if(key!==compareLoadedKey){compareError='';compareNotice='';compareMissing=[];renderComparison();}
- try{
-  const response=await fetch(`/session/compare?ids=${encodeURIComponent(key)}`,{cache:'no-store'});
-  const payload=await response.json().catch(()=>({}));
-  if(request!==compareRequestSeq)return;
-  const missing=Array.isArray(payload.missing)?payload.missing:[];
-  compareMissing=missing;
-  if(!response.ok||!payload.ok){
-   compareData=null;
-   compareError=payload.error||`Comparison request failed (${response.status}).`;
-  }else{
-   compareError='';
-   compareData=payload;
-   [...(payload.sessions||[]),...(payload.matches||[])].forEach(row=>compareTitles.set(row.key,row.title));
-  }
-  compareNotice=missing.length&&payload.ok?`${missing.length} selected ${countWord(missing.length,'session')} could not be loaded right now.`:'';
-  compareLoadedKey=key;
-  compareLoadedAt=Date.now();
- }catch(error){
-  if(request!==compareRequestSeq)return;
-  compareError='Token Meter could not load the comparison. Check that the local server is running.';
-  compareLoadedKey=key;
- }finally{
-  if(request===compareRequestSeq){compareLoading=false;renderComparison();}
- }
-}
-const COMPARE_ROWS=[
- {group:'Spend'},
- {key:'cost',label:'Cost',fmt:(v,s)=>money(v)+(s.cost_approx||s.usage_basis!=='reported'?' est':''),lower:true,tip:COST_UNAVAILABLE_TIP},
- {key:'cost_per_turn',label:'Cost per execution',fmt:v=>money(v),lower:true},
- {key:'cache_saved',label:'Saved by cache',fmt:v=>money(v),lower:false},
- {group:'Tokens'},
- {key:'tokens',label:'Total tokens',fmt:compactNumber,lower:true},
- {key:'fresh_input_tokens',label:'Fresh input',fmt:compactNumber,lower:true},
- {key:'cache_read_tokens',label:'Cache reads',fmt:compactNumber},
- {key:'cache_write_tokens',label:'Cache writes',fmt:compactNumber,lower:true},
- {key:'output_tokens',label:'Output',fmt:compactNumber},
- {key:'cache_hit_ratio',label:'Cache hit rate',fmt:pct,lower:false,points:true},
- {key:'tokens_per_turn',label:'Tokens per execution',fmt:compactNumber,lower:true},
- {group:'Work'},
- {key:'turns',label:'Executions',fmt:f,lower:true},
- {key:'subagent_turns',label:'Subagent executions',fmt:f},
- {key:'duration_s',label:'Active time',fmt:waitFmt,lower:true},
- {key:'wall_duration_s',label:'Wall time',fmt:waitFmt,lower:true},
- {key:'wait_avg_s',label:'Average wait',fmt:waitFmt,lower:true},
- {key:'output_tps',label:'Output speed',fmt:v=>`${speedFmt(v)} tok/s`,lower:false},
- {key:'context_peak',label:'Peak context',fmt:(v,s)=>compactNumber(v)+(s.context_window?` · ${pct(v/s.context_window)}`:''),lower:true},
- {key:'reasoning_share',label:'Reasoning share',fmt:pct,points:true},
- {group:'Tools'},
- {key:'tool_calls',label:'Tool calls',fmt:f},
- {key:'tool_errors',label:'Tool errors',fmt:f,lower:true},
- {key:'tools_unique',label:'Distinct tools',fmt:f},
- {key:'top_tools',label:'Most used',text:s=>(s.top_tools||[]).slice(0,3).map(t=>`${t.name} ${f(t.calls)}`).join(' · ')||'none'},
-];
-const COMPARE_SETUP_ROWS=[
- {label:'App',text:s=>s.label||s.provider||'--'},
- {label:'Model',text:s=>s.primary_model||(s.models||[]).join(', ')||'--'},
- {label:'Reasoning effort',text:s=>s.reasoning_effort||'default'},
- {label:'Project',text:s=>projectFilterLabel(s.project||'')||'local'},
- {label:'Started',text:s=>s.start||'--',same:true},
-];
-function compareDelta(row,value,base){
- if(value==null||base==null||row.text)return '';
- if(row.points){
-  const diff=Math.round(100*(value-base));
-  if(!diff)return '<span class=compareDelta>same</span>';
-  const better=row.lower===undefined?'':(diff<0)===row.lower?' better':' worse';
-  return `<span class="compareDelta${better}">${diff>0?'+':'−'}${Math.abs(diff)} pts</span>`;
- }
- if(value===base)return '<span class=compareDelta>same</span>';
- if(!base)return '';
- const ratio=(value-base)/Math.abs(base),better=row.lower===undefined?'':(ratio<0)===row.lower?' better':' worse';
- const text=Math.abs(ratio)>=1.95?`${(value/base).toFixed(1)}×`:`${ratio>0?'+':'−'}${Math.round(Math.abs(ratio)*100)}%`;
- return `<span class="compareDelta${better}">${text}</span>`;
-}
-function compareTableHtml(sessions,best){
- const baseline=sessions.find(s=>s.key===compareBaseline)||sessions[0];
- const head=`<thead><tr><th scope=col>Metric</th>${sessions.map((s,i)=>`<th scope=col><span class=compareLetter style="--compare-color:${compareColor(i)}">${s.letter}</span>${s.key===baseline.key?'Baseline':'vs '+esc(baseline.letter)}</th>`).join('')}</tr></thead>`;
- const setup=COMPARE_SETUP_ROWS.map(row=>{
-  const values=sessions.map(row.text),differs=!row.same&&new Set(values).size>1;
-  return `<tr${differs?' class=differs':''}><td>${esc(row.label)}</td>${values.map(value=>`<td class=text title="${esc(value)}">${esc(value)}</td>`).join('')}</tr>`;
- }).join('');
- const body=COMPARE_ROWS.map(row=>{
-  if(row.group)return `<tr class=compareGroup><th colspan=${sessions.length+1} scope=colgroup>${esc(row.group)}</th></tr>`;
-  if(row.text)return `<tr><td>${esc(row.label)}</td>${sessions.map(s=>`<td class=text title="${esc(row.text(s))}">${esc(row.text(s))}</td>`).join('')}</tr>`;
-  if(sessions.every(s=>s[row.key]==null))return '';
-  return `<tr><td>${esc(row.label)}</td>${sessions.map(s=>{
-   const value=s[row.key];
-   if(value==null)return `<td class="mono compareUnavailable"${row.key==='cost'?` ${tipAttrs(COST_UNAVAILABLE_TIP)}`:' title="Not reported for this session"'}>--</td>`;
-   const isBest=best[row.key]===s.key,delta=s.key===baseline.key?'':compareDelta(row,value,baseline[row.key]);
-   return `<td class=mono>${esc(row.fmt(value,s))}${isBest?'<span class=compareBest>best</span>':''}${delta}</td>`;
-  }).join('')}</tr>`;
- }).join('');
- return `<div class=compareTableWrap><table class=compareTable><caption class=compareCaption>Metric comparison against the baseline session</caption>${head}<tbody><tr class=compareGroup><th colspan=${sessions.length+1} scope=colgroup>Setup</th></tr>${setup}${body}</tbody></table></div>`;
-}
-function compareChartHtml(sessions){
- const metric=compareChartMetric==='cost'&&sessions.some(s=>s.cost!=null)?'cost':'tokens';
- const lines=sessions.map((s,i)=>({s,i,points:(s.series||[]).filter(p=>p[metric]!=null)})).filter(line=>line.points.length);
- const toggle=`<div class=seg role=group aria-label="Chart metric"><button type=button data-compare-chart=cost aria-pressed="${metric==='cost'}" class="${metric==='cost'?'on':''}">Cost</button><button type=button data-compare-chart=tokens aria-pressed="${metric==='tokens'}" class="${metric==='tokens'?'on':''}">Tokens</button></div>`;
- const head=`<div class=compareSectionHead><h3>Cumulative ${metric==='cost'?'cost':'tokens'} by execution</h3>${toggle}</div>`;
- if(!lines.length)return `<section class="card compareSection">${head}<div class="signalEmpty emptyState">No execution series is available for these sessions.</div></section>`;
- const VW=1040,VH=250,ML=64,MR=74,MT=14,MB=30,PW=VW-ML-MR,PH=VH-MT-MB;
- const maxX=Math.max(1,...lines.map(line=>line.points[line.points.length-1].i)),maxY=Math.max(metric==='cost'?.001:1,...lines.map(line=>Math.max(...line.points.map(p=>p[metric]))));
- const x=v=>ML+PW*(v/maxX),y=v=>MT+PH*(1-v/maxY),fmt=metric==='cost'?money:compactNumber;
- let svg='';
- for(let k=0;k<=4;k++){const yy=MT+PH*k/4;svg+=`<line x1="${ML}" x2="${ML+PW}" y1="${yy}" y2="${yy}" stroke="${CHART.grid}"/><text x="${ML-8}" y="${yy+4}" text-anchor="end" fill="${CHART.lbl}" font-size="11">${esc(fmt(maxY*(1-k/4)))}</text>`;}
- const ticks=Math.min(8,maxX);
- for(let k=0;k<=ticks;k++){const v=Math.round(maxX*k/ticks);svg+=`<text x="${x(v)}" y="${VH-10}" text-anchor="middle" fill="${CHART.lbl}" font-size="11">${f(v)}</text>`;}
- lines.forEach(line=>{
-  const pts=[{i:0,[metric]:0},...line.points],color=compareColor(line.i),last=line.points[line.points.length-1];
-  svg+=`<path d="${pts.map((p,k)=>`${k?'L':'M'}${x(p.i).toFixed(1)},${y(p[metric]).toFixed(1)}`).join(' ')}" fill="none" stroke="${color}" stroke-width="2.4" stroke-linejoin="round" stroke-linecap="round"/><circle cx="${x(last.i)}" cy="${y(last[metric])}" r="4" fill="${color}" stroke="${CHART.ink}" stroke-width="2"/><text x="${Math.min(VW-4,x(last.i)+8)}" y="${y(last[metric])+4}" fill="${color}" font-size="11" font-weight="700"${x(last.i)+8>VW-MR?' text-anchor="end"':''}>${line.s.letter} ${esc(fmt(last[metric]))}</text>`;
- });
- const label=lines.map(line=>`${line.s.letter}: ${fmt(line.points[line.points.length-1][metric])} over ${f(line.points[line.points.length-1].i)} executions`).join('; ');
- return `<section class="card compareSection">${head}<svg class=compareChart viewBox="0 0 ${VW} ${VH}" role=img aria-label="${esc(`Cumulative ${metric} by execution. ${label}`)}">${svg}<text x="${ML+PW}" y="${VH-10}" text-anchor="end" fill="${CHART.lbl}" font-size="11" dx="${MR-4}">execution</text></svg><div class=compareLegend>${lines.map(line=>`<span><i style="--compare-color:${compareColor(line.i)}"></i>${line.s.letter} · ${esc(line.s.title)}</span>`).join('')}</div></section>`;
-}
-function compareBreakdownHtml(sessions){
- const rows=sessions.map((s,i)=>({s,i})).filter(row=>row.s.cost_parts&&row.s.cost>0);
- if(!rows.length)return '';
- const parts=[['input','Fresh input','var(--c-input)'],['cache_write','Cache writes','var(--c-cache-write)'],['cache_read','Cache reads','var(--c-cache-read)'],['output','Output','var(--c-output)'],['server_tools','Server tools','var(--faint)']];
- const max=Math.max(...rows.map(row=>row.s.cost));
- return `<section class="card compareSection"><h3>Where the cost went</h3><div class=compareBreakdown>${rows.map(({s,i})=>`<div class=compareBreakdownRow><span class=compareLetter style="--compare-color:${compareColor(i)}">${s.letter}</span><div class=compareBreakdownBar role=img aria-label="${esc(`${s.letter}: `+parts.filter(([key])=>s.cost_parts[key]>0).map(([key,label])=>`${label} ${money(s.cost_parts[key])}`).join(', '))}" style="width:${Math.max(4,100*s.cost/max)}%">${parts.filter(([key])=>s.cost_parts[key]>0).map(([key,label,color])=>`<i style="width:${100*s.cost_parts[key]/s.cost}%;background:${color}" title="${esc(`${label}: ${money(s.cost_parts[key])}`)}"></i>`).join('')}</div><b class=mono>${esc(money(s.cost))}</b></div>`).join('')}</div><div class=compareLegend>${parts.filter(([key])=>rows.some(row=>row.s.cost_parts[key]>0)).map(([,label,color])=>`<span><i class=part style="background:${color}"></i>${label}</span>`).join('')}</div></section>`;
-}
-function compareMatchesHtml(matches,sessions){
- const full=compareIds.length>=COMPARE_MAX,same=sessions.length&&sessions.every(s=>s.title_key&&s.title_key===sessions[0].title_key);
- const heading=same||sessions.length===1?'Other runs with the same title':'Other runs with a matching title';
- const body=(matches||[]).length?`<div class=compareMatches>${matches.map(m=>`<div class=compareMatch><div style="min-width:0"><div class=t title="${esc(m.title)}">${esc(m.title)}</div><div class=meta>${esc(m.label)} · ${esc((m.models||[]).join(', ')||'model unknown')} · ${esc(m.last||m.start||'')} · ${f(m.turns)} execs · ${m.cost==null?'cost unavailable':esc(money(m.cost))}</div></div><div class=compareMatchActions><button class=tbtn type=button data-compare-open-session="${esc(m.open_id||m.id)}">Open</button><button class=tbtn type=button data-compare-add="${esc(m.key)}"${full?' disabled title="Comparison is full"':''}>Add</button></div></div>`).join('')}</div>`:'<div class="signalEmpty emptyState">No other recorded sessions share these titles yet. Run the same prompt again and the new session will appear here.</div>';
- return `<section class="card compareSection"><h3>${heading}</h3>${body}</section>`;
-}
-function renderComparison(){
- const root=$('compare-body');
- if(!root)return;
- const notice=compareNotice?`<div class=compareNote role=status>${esc(compareNotice)} <button class="tbtn compareClear" type=button data-compare-drop-missing>Remove ${compareMissing.length>1?'them':'it'}</button> <button class="tbtn compareClear" type=button data-compare-retry>Try again</button></div>`:'';
- if(!compareIds.length){
-  root.innerHTML=`${notice}<section class="card compareEmpty emptyState"><h3>No sessions selected</h3><p>Pick up to ${COMPARE_MAX} sessions in All sessions.</p><button class=tbtn type=button data-compare-pick>Choose sessions</button></section>`;
-  return;
- }
- if(compareError){root.innerHTML=`${notice}<section class="card compareEmpty emptyState"><h3>Comparison unavailable</h3><p>${esc(compareError)}</p><button class=tbtn type=button data-compare-retry>Try again</button>${compareMissing.length?' <button class="tbtn compareClear" type=button data-compare-drop-missing>Remove unavailable</button>':''}</section>`;return;}
- if(!compareData||compareLoadedKey!==compareIds.join(',')&&compareLoading){root.innerHTML=`${notice}<section class="card compareEmpty emptyState"><p>Loading comparison…</p></section>`;return;}
- const sessions=compareData.sessions||[],best=compareData.best||{};
- if(!sessions.some(s=>s.key===compareBaseline))compareBaseline=sessions[0]?.key||'';
- const cards=`<div class=compareCards style="grid-template-columns:repeat(${Math.max(2,sessions.length)},minmax(0,1fr))">${sessions.map((s,i)=>{
-  const baseline=s.key===compareBaseline;
-  return `<article class="card compareCard" style="--compare-color:${compareColor(i)}"><div class=compareCardTop><span class=compareLetter>${s.letter}</span><span class="badge app ${appBadgeClass(s)}">${runtimeMarkSvg(s)}${esc(s.label||s.provider)}</span>${baseline&&sessions.length>1?'<span class=compareBaselineTag>Baseline</span>':''}</div><div class=compareCardTitle title="${esc(s.title)}">${esc(s.title)}</div><div class=compareCardMeta>${esc(s.primary_model||(s.models||[]).join(', ')||'model unknown')} · ${esc(s.start||'')}</div><div class="compareCardCost mono">${s.cost==null?costValueHtml('',false):esc(money(s.cost)+(s.cost_approx||s.usage_basis!=='reported'?' est':''))}</div><div class=compareCardMeta>${f(s.turns)} execs · ${s.duration_s==null?'time unavailable':esc(waitFmt(s.duration_s))+' active'} · ${s.tokens==null?'tokens unavailable':esc(compactNumber(s.tokens))+' tok'}</div><div class=compareCardActions><button type=button data-compare-open-session="${esc(s.open_id||s.id)}">Open</button>${sessions.length>1?`<button type=button data-compare-baseline="${esc(s.key)}"${baseline?' disabled':''}>${baseline?'Baseline':'Set as baseline'}</button>`:''}<button type=button data-compare-remove="${esc(s.key)}">Remove</button></div></article>`;
- }).join('')}</div>`;
- if(sessions.length<2){
-  root.innerHTML=`${notice}${cards}<section class="card compareEmpty emptyState"><h3>Add one more session</h3><p>Pick another session in All sessions, or add a matching run below, to see side-by-side metrics.</p><button class=tbtn type=button data-compare-pick>Choose sessions</button></section>${compareMatchesHtml(compareData.matches,sessions)}`;
-  return;
- }
- const winner=(key,label,fmt)=>{
-  const index=sessions.findIndex(s=>s.key===best[key]),s=sessions[index],known=sessions.filter(row=>row[key]!=null);
-  const value=s?`<span class=compareLetter style="--compare-color:${compareColor(index)}">${s.letter}</span>${esc(fmt(s))}`:known.length>=2?'Tied':'--';
-  const note=s?esc(s.title):known.length>=2?`All at ${esc(fmt(known[0]))}`:'Not reported for enough sessions';
-  return `<div class=metric><span>${label}</span><strong>${value}</strong><small${s?` title="${esc(s.title)}"`:''}>${note}</small></div>`;
- };
- const winners=`<section class="card compareSection"><div class=compareWinners>${winner('cost','Cheapest',s=>money(s.cost)+(s.cost_approx||s.usage_basis!=='reported'?' est':''))}${winner('duration_s','Fastest',s=>waitFmt(s.duration_s)+' active')}</div></section>`;
- const table=`<section class="card compareSection"><div class=compareSectionHead><h3>Side by side</h3><span class=allSessionsHint>Deltas are against baseline ${esc((sessions.find(s=>s.key===compareBaseline)||sessions[0]).letter)} · unavailable evidence shows --</span></div>${compareTableHtml(sessions,best)}</section>`;
- root.innerHTML=notice+cards+winners+table+compareChartHtml(sessions)+compareBreakdownHtml(sessions)+compareMatchesHtml(compareData.matches,sessions);
-}
-$('session-compare').onclick=event=>{
- const target=event.target.closest('button');
- if(!target||target.disabled)return;
- if(target.id==='compare-pick'||target.hasAttribute('data-compare-pick')){openSessionScope('all');return;}
- if(target.id==='compare-clear'){compareNotice='';setCompareIds([]);return;}
- if(target.hasAttribute('data-compare-retry')){loadComparison({force:true});return;}
- if(target.hasAttribute('data-compare-drop-missing')){const drop=new Set(compareMissing);compareNotice='';compareMissing=[];setCompareIds(compareIds.filter(id=>!drop.has(id)));return;}
- if(target.dataset.compareRemove){compareNotice='';setCompareIds(compareIds.filter(id=>id!==target.dataset.compareRemove));return;}
- if(target.dataset.compareAdd){compareNotice='';toggleCompareId(target.dataset.compareAdd);return;}
- if(target.dataset.compareBaseline){compareBaseline=target.dataset.compareBaseline;localStorage.setItem('tm_compare_baseline',compareBaseline);renderComparison();return;}
- if(target.dataset.compareChart){compareChartMetric=target.dataset.compareChart;localStorage.setItem('tm_compare_chart',compareChartMetric);renderComparison();return;}
- if(target.dataset.compareOpenSession)selectSession(target.dataset.compareOpenSession,{returnScope:'compare'});
-};
-compareUiReady=true;
-renderSessionScope();
-function mergeAllSessionInventory(inventory,liveSessions){
- // One row per trace file: the server's opaque trace key when present, else the session id.
- const key=row=>row?.key?compareKeyFor(row):sessionRowKey(row);
- const rows=new Map((inventory||[]).map(row=>[key(row),row]));
- (liveSessions||[]).forEach(row=>rows.set(key(row),row));
- return [...rows.values()];
-}
-function subagentUsageIdentity(row,dimension){
- const runtime=appFilterLabel({provider:row?.runtime});
- const kind=String(row?.kind||''),kindLabel=kind?kind[0].toUpperCase()+kind.slice(1):'All kinds';
- if(dimension==='models')return {label:row?.model||'Unknown model',detail:`${runtime} · ${kindLabel}`};
- if(dimension==='depths')return {label:`Depth ${Number(row?.depth)||0}`,detail:`${runtime} · ${kindLabel}`};
- if(dimension==='kinds')return {label:kindLabel,detail:runtime};
- if(dimension==='roles')return {label:row?.role||'Unreported role',detail:`${runtime} · ${kindLabel} · provider-reported`};
- return {label:runtime,detail:'all child-agent kinds'};
-}
-function applySubagentPreset(filters,preset){
- const next={...(filters||{})};
- if(preset==='incomplete'){next.status='incomplete';next.signal='all';}
- else if(preset==='attention'){next.status='all';next.signal='attention';}
- else if(preset==='all'){next.status='all';next.signal='all';}
- return next;
-}
-function subagentPresetForFilters(filters){
- const status=String(filters?.status||'all'),signal=String(filters?.signal||'all');
- if(status==='incomplete'&&signal==='all')return 'incomplete';
- if(status==='all'&&signal==='attention')return 'attention';
- if(status==='all'&&signal==='all')return 'all';
- return 'custom';
-}
-function toggleSubagentSummaryFilter(filters,key){
- const next={...(filters||{})},filter=String(key||'');
- if(filter==='incomplete'){
-  next.status=next.status==='incomplete'?'all':'incomplete';
-  next.signal='all';
- }else if(filter){
-  next.status='all';
-  next.signal=next.signal===filter?'all':filter;
- }
- return next;
-}
-function paginateSubagentRows(rows,limit){
- rows=Array.isArray(rows)?rows:[];
- const total=rows.length,shown=Math.min(total,Math.max(0,Number(limit)||0));
- return {rows:rows.slice(0,shown),shown,total,hasMore:shown<total,nextLimit:Math.min(total,shown+50)};
-}
-function subagentActiveFilterItems(filters){
- const items=[];
- if(filters.query)items.push({key:'query',label:'Search',value:filters.query});
- if(filters.role)items.push({key:'role',label:'Role',value:filters.role});
- if(filters.kind)items.push({key:'kind',label:'Kind',value:filters.kind});
- if(filters.runtime)items.push({key:'runtime',label:'App',value:appFilterLabel({provider:filters.runtime})});
- if(filters.project)items.push({key:'project',label:'Project',value:projectFilterLabel(filters.project)});
- if(filters.window!==DEFAULT_TIME_FILTER_WINDOW)items.push({key:'window',label:'Time',value:TIME_FILTER_LABELS[filters.window]||filters.window});
- if(filters.model)items.push({key:'model',label:'Model',value:filters.model});
- if(filters.status!=='all')items.push({key:'status',label:'Status',value:filters.status});
- if(filters.signal!=='all')items.push({key:'signal',label:'Signal',value:filters.signal==='attention'?'Cost/retry signal':String(filters.signal).replaceAll('_',' ')});
- if(filters.sort!=='recent')items.push({key:'sort',label:'Sort',value:filters.sort==='work'?'Work time':filters.sort});
- return items;
-}
-function filterSubagentInventory(usage,filters,nowSeconds){
- filters=filters||{};nowSeconds=nowSeconds==null?Date.now()/1000:Number(nowSeconds);
- const inventory=Array.isArray(usage?.inventory)?usage.inventory:[],query=String(filters.query||'').trim().toLowerCase();
- const runtime=String(filters.runtime||''),project=String(filters.project||''),model=String(filters.model||''),role=String(filters.role||''),kind=String(filters.kind||''),status=String(filters.status||'all'),signal=String(filters.signal||'all'),window=String(filters.window||'all'),sort=String(filters.sort||'recent');
- const {start:rangeStart,end:rangeEnd}=timeFilterBounds(window,Number(nowSeconds)*1000);
- const rows=inventory.filter(row=>{
-  const reasons=Array.isArray(row?.attention)?row.attention:[];
-  if(runtime&&String(row?.runtime||'')!==runtime)return false;
-  if(project&&String(row?.project||'')!==project)return false;
-  if(model&&String(row?.model||'')!==model)return false;
-  if(role&&String(row?.role||'')!==role)return false;
-  if(kind&&String(row?.kind||'')!==kind)return false;
-  if(status!=='all'&&String(row?.activity_state||'unknown')!==status)return false;
-  if(signal==='attention'&&!reasons.length)return false;
-  if(signal!=='all'&&signal!=='attention'&&!reasons.some(reason=>String(reason?.code||'')===signal))return false;
-  if(rangeStart&&Number(row?.last_activity_at||0)<rangeStart)return false;
-  if(rangeEnd&&Number(row?.last_activity_at||0)>=rangeEnd)return false;
-  if(query&&!['role','label','model','project','runtime','client'].some(key=>String(row?.[key]||'').toLowerCase().includes(query)))return false;
-  return true;
- });
- const name=row=>String(row?.role||row?.label||row?.id||'').toLowerCase();
- const sorters={
-  recent:(a,b)=>Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0)||name(a).localeCompare(name(b)),
-  cost:(a,b)=>Number(b?.cost||0)-Number(a?.cost||0)||Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0),
-  tokens:(a,b)=>Number(b?.tokens||0)-Number(a?.tokens||0)||Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0),
-  work:(a,b)=>Number(b?.work_time_s!=null)-Number(a?.work_time_s!=null)||Number(b?.work_time_s||0)-Number(a?.work_time_s||0)||Number(b?.last_activity_at||0)-Number(a?.last_activity_at||0),
-  name:(a,b)=>name(a).localeCompare(name(b))||String(a?.id||'').localeCompare(String(b?.id||'')),
- };
- rows.sort(sorters[sort]||sorters.recent);
- const truncated=usage?.inventory_truncated===true,inventoryCount=Math.max(inventory.length,Number(usage?.inventory_count)||0),complete=!truncated;
- const reasons=rows.flatMap(row=>Array.isArray(row?.attention)?row.attention:[]),signalCounts={};
- reasons.forEach(reason=>{const code=String(reason?.code||'');if(code)signalCounts[code]=(signalCounts[code]||0)+1;});
- const summary=complete?{
-  complete:true,agents:rows.length,parentSessions:new Set(rows.map(row=>String(row?.root_session_id||'')).filter(Boolean)).size,
-  incomplete:rows.filter(row=>row?.activity_state==='incomplete').length,working:rows.filter(row=>row?.activity_state==='working').length,
-  attention:rows.filter(row=>Array.isArray(row?.attention)&&row.attention.length).length,
-  costCovered:rows.filter(row=>row?.cost_available===true).length,cost:rows.reduce((total,row)=>total+(row?.cost_available===true?Number(row?.cost)||0:0),0),
- }: {complete:false,agents:null,parentSessions:null,incomplete:null,working:null,attention:null,costCovered:null,cost:null};
- return {rows,summary,signalCounts,inventoryCount,truncated};
-}
-function subagentModelDistribution(rows){
- const groups=new Map();
- (Array.isArray(rows)?rows:[]).forEach(row=>{
-  const runtime=String(row?.runtime||''),model=String(row?.model||''),key=`${runtime}\n${model}`;
-  if(!groups.has(key))groups.set(key,{runtime,model,runs:0,costCovered:0,cost:0});
-  const group=groups.get(key);group.runs++;
-  if(row?.cost_available===true){group.costCovered++;group.cost+=Number(row.cost)||0;}
- });
- return [...groups.values()].sort((a,b)=>b.runs-a.runs||a.runtime.localeCompare(b.runtime)||a.model.localeCompare(b.model));
-}
-function renderSubagentModelDistribution(rows,truncated){
- const target=$('subagent-model-distribution');
- if(subagentView!=='sessions'){target.hidden=true;return;}
- target.hidden=false;
- const models=subagentModelDistribution(rows),maximum=Math.max(1,...models.map(item=>item.runs));
- const qualifier=truncated?'Visible runs only · inventory limit reached':'Matching runs';
- target.innerHTML=`<div class=subagentModelHead><h3>Model distribution</h3><small>${esc(qualifier)} · ${f(rows.length)} ${countWord(rows.length,'run')}</small></div>${models.length?`<div class=subagentModelRows>${models.map(item=>{const label=item.model||'Unknown model',app=appFilterLabel({provider:item.runtime})||'Unknown app',coverage=item.costCovered===item.runs?'':`${f(item.costCovered)} / ${f(item.runs)} cost-covered`;return `<div class=subagentModelRow><span class=subagentModelIdentity title="${esc(`${app} · ${label}`)}"><strong>${esc(label)}</strong> · ${esc(app)}</span><span class=subagentModelTrack aria-hidden=true><i style="width:${(item.runs/maximum*100).toFixed(1)}%"></i></span><span class=subagentModelNumber>${f(item.runs)}</span><span class=subagentModelCost>${item.costCovered?esc(money(item.cost)):'--'}${coverage?`<small>${esc(coverage)}</small>`:''}</span></div>`;}).join('')}</div>`:'<div class="subagentResultsEmpty emptyState">No matching models</div>'}`;
-}
-function renderSubagentExplorerLegacy(usage){
- const inventory=Array.isArray(usage?.inventory)?usage.inventory:[],filters=subagentFilters;
- const values=key=>[...new Set(inventory.map(row=>String(row?.[key]||'')).filter(Boolean))].sort((a,b)=>a.localeCompare(b,undefined,{sensitivity:'base'}));
- const runtimes=values('runtime'),projects=values('project'),models=values('model');
- if(filters.runtime&&!runtimes.includes(filters.runtime))filters.runtime='';
- if(filters.project&&!projects.includes(filters.project))filters.project='';
- if(filters.model&&!models.includes(filters.model))filters.model='';
- setLogSelectOptions($('subagent-filter-app'),'<option value="">All apps</option>'+runtimes.map(value=>`<option value="${esc(value)}">${esc(appFilterLabel({provider:value}))}</option>`).join(''),filters.runtime);
- setLogSelectOptions($('subagent-filter-project'),'<option value="">All projects</option>'+projects.map(value=>`<option value="${esc(value)}">${esc(projectFilterLabel(value))}</option>`).join(''),filters.project);
- setLogSelectOptions($('subagent-filter-model'),'<option value="">All models</option>'+models.map(value=>`<option value="${esc(value)}">${esc(value)}</option>`).join(''),filters.model);
- $('subagent-filter-search').value=filters.query;$('subagent-filter-status').value=filters.status;$('subagent-filter-signal').value=filters.signal;$('subagent-filter-time').value=filters.window;$('subagent-filter-sort').value=filters.sort;
- const advancedCount=[filters.model,filters.status!=='all',filters.signal!=='all',filters.sort!=='recent'].filter(Boolean).length;
- $('subagent-filter-advanced').hidden=!subagentAdvancedOpen;
- $('subagent-filter-more').setAttribute('aria-expanded',String(subagentAdvancedOpen));
- $('subagent-filter-more-count').textContent=advancedCount?String(advancedCount):'';
- const filterItems=subagentActiveFilterItems(filters);
- $('subagent-active-filters').innerHTML=filterItems.length?'<span>Filtered by</span>'+filterItems.map(item=>`<button class=subagentFilterChip type=button data-subagent-clear-filter="${esc(item.key)}" aria-label="Remove ${esc(item.label)} filter"><b>${esc(item.label)}: ${esc(item.value)}</b><i aria-hidden=true>×</i></button>`).join(''):'';
- $('subagent-filter-footer').hidden=!filterItems.length;
- $('subagent-filter-clear').disabled=!filterItems.length;
- const triageResult=filterSubagentInventory(usage,applySubagentPreset(filters,'all')),triageExact=triageResult.summary.complete;
- $('subagent-triage-all').textContent=triageExact?f(triageResult.summary.agents):'--';
- $('subagent-triage-incomplete').textContent=triageExact?f(triageResult.summary.incomplete):'--';
- $('subagent-triage-attention').textContent=triageExact?f(triageResult.summary.attention):'--';
- const activePreset=subagentPresetForFilters(filters);
- [...$('subagent-triage').querySelectorAll('[data-subagent-preset]')].forEach(button=>button.setAttribute('aria-pressed',String(button.dataset.subagentPreset===activePreset)));
- const result=filterSubagentInventory(usage,filters),summary=result.summary,exact=summary.complete;
- $('subagent-explorer-meta').hidden=false;$('subagent-explorer-meta').textContent=result.truncated?`${f(result.rows.length)} visible of ${f(result.inventoryCount)} child runs`:result.rows.length===result.inventoryCount?`${f(result.inventoryCount)} child runs`:`${f(result.rows.length)} of ${f(result.inventoryCount)} child runs`;
- const metric=(label,value,note)=>`<div class="subagentExplorerStat metric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
- $('subagent-explorer-summary').innerHTML=[
-  metric('Matching agents',exact?f(summary.agents):'--',exact?`${f(summary.incomplete)} incomplete · ${f(summary.working)} working`:'exact filtered total withheld'),
-  metric('Parent sessions',exact?f(summary.parentSessions):'--','open an agent to inspect its parent'),
-  metric('Estimated cost',exact&&summary.costCovered?money(summary.cost):'--','local API-rate estimate'),
-  metric('Cost evidence',exact?`${f(summary.costCovered)} / ${f(summary.agents)}`:'--',exact?'agents with estimated cost available':'exact filtered total withheld'),
- ].join('');
- const warning=$('subagent-inventory-warning');warning.hidden=!result.truncated;warning.textContent=result.truncated?'Display limit reached — filtered totals withheld.':'';
- const insights=[
-  ['Peer cost outlier','peer_cost_outlier','Covered estimated cost is at least $0.50 and 3× the median of at least three comparable peers.'],
-  ['Active cost concentration','active_cost_concentration','A working child has at least $1.00 of covered estimated spend and at least 50% of covered group spend.'],
-  ['Retry pressure','retry_pressure','Provider evidence reports at least three retries or failed attempts in the recent execution window.'],
- ];
- $('subagent-insights').innerHTML=insights.map(([label,code,description])=>`<button class=subagentInsight type=button data-subagent-signal="${esc(code)}" aria-pressed="${String(filters.signal===code)}"><strong><span>${esc(label)}</span><b>${triageExact?f(triageResult.signalCounts[code]||0):'--'}</b></strong><p>${esc(description)}</p></button>`).join('');
- if(selectedSubagentId&&!result.rows.some(row=>String(row?.id||'')===selectedSubagentId))selectedSubagentId='';
- const page=paginateSubagentRows(result.rows,subagentVisibleLimit);
- $('subagent-inventory-count').textContent=result.truncated?`${f(page.rows.length)} visible rows from a limited inventory`:`Showing ${f(page.rows.length)} of ${f(page.total)} ${countWord(page.total,'agent')}`;
- const evidenceMetric=(label,value)=>`<div class="subagentEvidenceMetric metric"><span>${esc(label)}</span><strong>${esc(value)}</strong></div>`;
- const rows=page.rows.map((row,index)=>{
-  const identity=agentIdentityPresentation(row,index),attention=Array.isArray(row.attention)&&row.attention.length,state=String(row.activity_state||'unknown'),model=row.model&&row.model!=='unknown'?row.model:'model unavailable';
-  const tokens=row.tokens_available===true?f(row.tokens):'--',cost=row.cost_available===true?money(row.cost):'--',workTime=row.work_time_s==null?'--':durationShort(row.work_time_s),secondary=[identity.secondary,row.kind].filter(Boolean).join(' · '),id=String(row.id||''),selected=id&&id===selectedSubagentId,evidenceId=`subagent-evidence-${index}`;
-  let html=`<button class="subagentInventoryRow${attention?' attention':''}${selected?' selected':''}" type=button data-subagent-id="${esc(id)}" aria-expanded="${String(selected)}" aria-controls="${evidenceId}" aria-label="Inspect evidence for ${esc(identity.primary)}"><span class=subagentInventoryIdentity><strong><span>${esc(identity.primary)}</span>${attention?'<span class="agentAttentionBadge chip tone-warn">Needs attention</span>':''}</strong><small>${esc(secondary)}</small></span><span class=subagentInventoryProject title="${esc(row.project||'')}">${esc(projectFilterLabel(row.project)||'No project')}</span><span class=subagentInventoryMetric>${esc(model)}</span><span class="agentState ${esc(state)}">${esc(state)}</span><span class=subagentInventoryMetric>${esc(tokens)}</span><span class=subagentInventoryMetric>${esc(cost)}</span><span class=subagentInventoryMetric>${esc(workTime)}</span></button>`;
-  if(selected){
-   const reasons=attention?row.attention.map(reason=>`<li><strong>${esc(String(reason?.code||'').replaceAll('_',' '))}:</strong> ${esc(reason?.explanation||'Evidence threshold met.')}</li>`).join(''):'';
-   const attempts=Number(row.retries||0)+Number(row.failed_attempts||0),runtime=appFilterLabel({provider:row.runtime});
-   html+=`<div class=subagentEvidence id="${evidenceId}" role=region aria-label="Evidence for ${esc(identity.primary)}"><div class=subagentEvidenceHead><div><h4>${esc(identity.primary)}</h4><p>${esc(identity.secondary?`Provider role · nickname ${identity.secondary}`:'Child-agent evidence')}</p></div><button class=subagentEvidenceClose type=button data-subagent-close-detail aria-label="Close agent evidence">×</button></div><div class=subagentEvidenceContext><span>${esc(runtime)}</span><span>${esc(projectFilterLabel(row.project)||'No project')}</span><span>${esc(model)}</span><span>${esc(row.kind||'child')}</span><span>${esc(state)}</span></div><div class=subagentEvidenceGrid>${evidenceMetric('Estimated cost',cost)}${evidenceMetric('Tokens',tokens)}${evidenceMetric('Work time',workTime)}${evidenceMetric('Executions',f(row.executions||0))}${evidenceMetric('Tool calls',f(row.tool_calls||0))}${evidenceMetric('Retry evidence',f(attempts))}</div><div class=subagentEvidenceSignals><strong>${attention?'Why this needs attention':'Attention evidence'}</strong>${attention?`<ul>${reasons}</ul>`:'<p>No deterministic attention signal is present in the available local evidence.</p>'}</div><div class=subagentEvidenceActions><p>Only content-free local metadata is shown here.</p><button class=subagentOpenParent type=button data-subagent-open-parent="${esc(row.root_session_id)}">Open parent session</button></div></div>`;
-  }
-  return html;
- }).join('');
- $('subagent-inventory').innerHTML=result.rows.length?'<div class=subagentInventoryHeader><span>Agent</span><span>Project</span><span>Model</span><span>Status</span><span>Tokens</span><span>Estimated cost</span><span>Work time</span></div>'+rows:'<div class="subagentInventoryEmpty emptyState">No child agents match these filters.</div>';
- $('subagent-inventory-footer').hidden=!page.hasMore;
- $('subagent-inventory-more').textContent=page.hasMore?`Show ${f(Math.min(SUBAGENT_PAGE_SIZE,page.total-page.shown))} more · ${f(page.total-page.shown)} remaining`:'';
- const fineFilter=Boolean(filters.query||filters.model||filters.status!=='all'||filters.signal!=='all');
- renderSubagentUsage(usage,filters,fineFilter);
-}
-function groupSubagentSessions(rows,issuesOnly=false,sort='priority'){
- const grouped=new Map();
- (Array.isArray(rows)?rows:[]).forEach(row=>{
-  const rootSessionId=String(row?.root_session_id||'');
-  if(!rootSessionId)return;
-  const group=grouped.get(rootSessionId)||{rootSessionId,rows:[],agents:0,attention:0,incomplete:0,working:0,cost:0,costCovered:0,knownTokens:0,tokenCovered:0,lastActivity:0,workTime:0,workTimeCovered:0,project:String(row?.project||'')};
-  group.rows.push(row);group.agents+=1;
-  if(Array.isArray(row?.attention)&&row.attention.length)group.attention+=1;
-  if(row?.activity_state==='incomplete')group.incomplete+=1;
-  if(row?.activity_state==='working')group.working+=1;
-  if(row?.cost_available===true){group.cost+=Number(row.cost)||0;group.costCovered+=1;}
-  if(row?.tokens_available===true){group.knownTokens+=Number(row.tokens)||0;group.tokenCovered+=1;}
-  group.lastActivity=Math.max(group.lastActivity,Number(row?.last_activity_at)||0);
-  if(row?.work_time_s!=null){group.workTime+=Number(row.work_time_s)||0;group.workTimeCovered+=1;}
-  grouped.set(rootSessionId,group);
- });
- let groups=[...grouped.values()];
- if(issuesOnly){
-  groups=groups.filter(group=>group.attention||group.incomplete);
-  groups.forEach(group=>group.rows.sort((a,b)=>
-   Number(b?.activity_state==='incomplete')-Number(a?.activity_state==='incomplete')||
-   Number(Boolean(b?.attention?.length))-Number(Boolean(a?.attention?.length))||
-   (Number(b?.cost)||0)-(Number(a?.cost)||0)||
-   (Number(b?.last_activity_at)||0)-(Number(a?.last_activity_at)||0)
-  ));
- }
- const sorters={
-  priority:(a,b)=>b.attention-a.attention||b.incomplete-a.incomplete||b.cost-a.cost||b.lastActivity-a.lastActivity||a.rootSessionId.localeCompare(b.rootSessionId),
-  recent:(a,b)=>b.lastActivity-a.lastActivity||b.attention-a.attention||a.rootSessionId.localeCompare(b.rootSessionId),
-  cost:(a,b)=>b.cost-a.cost||b.costCovered-a.costCovered||b.lastActivity-a.lastActivity,
-  tokens:(a,b)=>b.knownTokens-a.knownTokens||b.lastActivity-a.lastActivity,
-  work:(a,b)=>Number(b.workTimeCovered===b.agents)-Number(a.workTimeCovered===a.agents)||b.workTime-a.workTime||b.workTimeCovered-a.workTimeCovered||b.lastActivity-a.lastActivity,
-  name:(a,b)=>a.project.localeCompare(b.project)||a.rootSessionId.localeCompare(b.rootSessionId),
- };
- groups.sort(sorters[sort]||sorters.priority);
- return groups;
-}
-function buildSubagentRoleRows(rows){
- const grouped=new Map();
- (Array.isArray(rows)?rows:[]).forEach(row=>{
-  const role=String(row?.role||'').trim();
-  if(!role)return;
-  const runtime=String(row?.runtime||''),kind=String(row?.kind||'child'),key=`${runtime}\n${kind}\n${role}`;
-  const group=grouped.get(key)||{id:key,role,runtime,kind,agents:0,incomplete:0,attention:0,knownCost:0,costCovered:0,knownTokens:0,tokenCovered:0,costs:[],models:new Map()};
-  group.agents+=1;
-  if(row?.activity_state==='incomplete')group.incomplete+=1;
-  if(Array.isArray(row?.attention)&&row.attention.length)group.attention+=1;
-  if(row?.cost_available===true){const cost=Number(row.cost)||0;group.knownCost+=cost;group.costCovered+=1;group.costs.push(cost);}
-  if(row?.tokens_available===true){group.knownTokens+=Number(row.tokens)||0;group.tokenCovered+=1;}
-  const model=String(row?.model||'model unavailable');group.models.set(model,(group.models.get(model)||0)+1);
-  grouped.set(key,group);
- });
- return [...grouped.values()].map(group=>{
-  const costs=group.costs.slice().sort((a,b)=>a-b),middle=Math.floor(costs.length/2),medianCost=!costs.length?null:costs.length%2?costs[middle]:(costs[middle-1]+costs[middle])/2,p95Cost=!costs.length?null:costs[Math.max(0,Math.ceil(.95*costs.length)-1)];
-  const topModel=[...group.models].sort((a,b)=>b[1]-a[1]||a[0].localeCompare(b[0]))[0]?.[0]||'model unavailable';
-  return {id:group.id,role:group.role,runtime:group.runtime,kind:group.kind,agents:group.agents,incomplete:group.incomplete,attention:group.attention,incompleteRate:group.agents?group.incomplete/group.agents:0,attentionRate:group.agents?group.attention/group.agents:0,knownCost:group.knownCost,costCovered:group.costCovered,medianCost,p95Cost,knownTokens:group.knownTokens,tokenCovered:group.tokenCovered,topModel};
- }).sort((a,b)=>b.knownCost-a.knownCost||b.agents-a.agents||a.role.localeCompare(b.role)||a.runtime.localeCompare(b.runtime));
-}
-function subagentRoleKey(row){return `${String(row?.runtime||'')}\n${String(row?.kind||'')}\n${String(row?.role||'')}`;}
-function subagentRoleFineFilters(filters){
- return Boolean(filters?.model||(filters?.status&&filters.status!=='all')||(filters?.signal&&filters.signal!=='all'));
-}
-function subagentRoleDayRows(usage,filters,nowMs=Date.now()){
- let rows=(Array.isArray(usage?.role_days)?usage.role_days:[]).filter(row=>(!filters?.runtime||row?.runtime===filters.runtime)&&(!filters?.project||row?.project===filters.project));
- const query=String(filters?.query||'').trim().toLowerCase();
- if(query)rows=rows.filter(row=>String(row?.role||'').toLowerCase().includes(query));
- const dayCount={today:1,"7d":7,"30d":30,"90d":90}[filters?.window];
- if(['yesterday','month','last_month'].includes(filters?.window)){
-  const range=modelRangeWindow(filters.window,new Date(nowMs));
-  rows=rows.filter(row=>range.daySet.has(String(row?.day||'')));
- }else if(dayCount){
-  const cutoff=new Date(nowMs);cutoff.setHours(0,0,0,0);cutoff.setDate(cutoff.getDate()-(dayCount-1));
-  const year=cutoff.getFullYear(),month=String(cutoff.getMonth()+1).padStart(2,'0'),day=String(cutoff.getDate()).padStart(2,'0'),cutoffKey=`${year}-${month}-${day}`;
-  rows=rows.filter(row=>String(row?.day||'')>=cutoffKey);
- }
- return rows.sort((a,b)=>String(a?.day||'').localeCompare(String(b?.day||''))||subagentRoleKey(a).localeCompare(subagentRoleKey(b)));
-}
-function subagentModelKey(row){return `${String(row?.runtime||'')}\n${String(row?.model||'')}`;}
-function subagentModelDayRows(usage,filters,nowMs=Date.now()){
- let rows=(Array.isArray(usage?.model_days)?usage.model_days:[]).filter(row=>(!filters?.runtime||row?.runtime===filters.runtime)&&(!filters?.project||row?.project===filters.project));
- const query=String(filters?.query||'').trim().toLowerCase();
- if(query)rows=rows.filter(row=>String(row?.model||'').toLowerCase().includes(query));
- const dayCount={today:1,"7d":7,"30d":30,"90d":90}[filters?.window];
- if(['yesterday','month','last_month'].includes(filters?.window)){
-  const range=modelRangeWindow(filters.window,new Date(nowMs));
-  rows=rows.filter(row=>range.daySet.has(String(row?.day||'')));
- }else if(dayCount){
-  const cutoff=new Date(nowMs);cutoff.setHours(0,0,0,0);cutoff.setDate(cutoff.getDate()-(dayCount-1));
-  const cutoffKey=`${cutoff.getFullYear()}-${String(cutoff.getMonth()+1).padStart(2,'0')}-${String(cutoff.getDate()).padStart(2,'0')}`;
-  rows=rows.filter(row=>String(row?.day||'')>=cutoffKey);
- }
- return rows.sort((a,b)=>String(a?.day||'').localeCompare(String(b?.day||''))||subagentModelKey(a).localeCompare(subagentModelKey(b)));
-}
-function buildSubagentModelTrends(usage,filters,nowMs=Date.now()){
- const selected=selectSubagentUsageScope(usage,filters?.runtime,filters?.window,filters?.project,false);
- if(!selected.usage)return {models:[],days:[]};
- const query=String(filters?.query||'').trim().toLowerCase(),matches=row=>row?.model&&row.model!=='unknown'&&(!query||String(row.model).toLowerCase().includes(query));
- const cohort=usage=>Array.isArray(usage?.model_runtimes)?usage.model_runtimes:[];
- const previous=new Map(cohort(selected.usage.comparison).filter(matches).map(row=>[subagentModelKey(row),row]));
- const relative=(value,baseline)=>value!=null&&baseline!=null&&baseline>0?(value-baseline)/baseline:null;
- const models=cohort(selected.usage).filter(matches).map(row=>{
-  const prior=previous.get(subagentModelKey(row)),covered=Number(row?.cost_covered_agents||0),priorCovered=Number(prior?.cost_covered_agents||0);
-  const complete=row?.cost_available===true&&covered===Number(row?.agents||0),priorComplete=prior?.cost_available===true&&priorCovered===Number(prior?.agents||0);
-  return {...row,costChange:prior&&complete&&priorComplete?relative(Number(row.known_cost||0),Number(prior.known_cost||0)):null,
-   averageCostChange:complete&&priorComplete&&covered&&priorCovered?relative(Number(row.known_cost||0)/covered,Number(prior.known_cost||0)/priorCovered):null,
-   runChange:prior?Number(row.agents||0)-Number(prior.agents||0):null};
- }).sort((a,b)=>Number(b.known_cost||0)-Number(a.known_cost||0)||Number(b.agents||0)-Number(a.agents||0)||String(a.model).localeCompare(String(b.model)));
- return {models,days:subagentModelDayRows(usage,filters,nowMs),trendTruncated:usage?.model_days_truncated===true};
-}
-function renderSubagentModelTrends(trends){
- if(!trends?.models?.length)return '';
- const comparisonsAvailable=!trends.trendTruncated,change=value=>value==null?'--':`${value>0?'↑ ':value<0?'↓ ':''}${Math.abs(value*100).toFixed(0)}%`,changeClass=value=>value==null?'':value<0?' good':value>0?' warn':'';
- const rows=trends.models.map(row=>{
-  const runs=Number(row.agents||0),covered=Number(row.cost_covered_agents||0),total=covered?money(row.known_cost||0):'--',average=covered?money(Number(row.known_cost||0)/covered):'--';
-  const primary=subagentRoleChartMode==='runs'?f(runs):subagentRoleChartMode==='average'?average:total;
-  const delta=subagentRoleChartMode==='runs'?(!comparisonsAvailable||row.runChange==null?'':`${row.runChange>0?'+':''}${f(row.runChange)} vs prior`):change(comparisonsAvailable?(subagentRoleChartMode==='average'?row.averageCostChange:row.costChange):null);
-  const deltaClass=subagentRoleChartMode==='average'?changeClass(comparisonsAvailable?row.averageCostChange:null):'';
-  const label={spend:covered===runs?'Spend':'Covered spend',average:covered===runs?'Cost / run':'Cost / covered run',runs:'Runs'}[subagentRoleChartMode]||'Cost / run';
-  const distribution=row.median_cost==null||row.p95_cost==null?'--':`${money(row.median_cost)} / ${money(row.p95_cost)}`,incomplete=Number(row.incomplete_agents||0),app=appFilterLabel({provider:row.runtime});
-  return `<div class=subagentRoleTrendRow><div class=subagentRoleIdentity><strong title="${esc(row.model)}">${esc(row.model)}</strong><small>${esc(appFilterLabel({provider:row.runtime}))} · ${esc(`${f(runs)} ${runs===1?'run':'runs'}`)}<br>${esc(`${f(covered)}/${f(runs)} priced`)}</small></div><div class="subagentRolePrimary${deltaClass}"><span>${esc(label)}</span><b>${esc(primary)}</b>${delta&&delta!=='--'?`<small>${esc(delta)}</small>`:''}</div>${renderSubagentTrendSparkline(trends.days,trends.trendTruncated,subagentModelKey,row,row.model)}<div class=subagentRoleMeta><span>Median / P95</span><b>${esc(distribution)}</b>${incomplete?`<span class="subagentRoleSignal warn">${f(incomplete)} incomplete</span>`:''}</div><button class=subagentRoleInspect type=button data-subagent-inspect-model="${esc(row.model)}" data-subagent-inspect-runtime="${esc(row.runtime)}" aria-label="${esc(`View runs for ${row.model} in ${app}`)}">View runs</button></div>`;
- }).join('');
- return `<div class=subagentRoleTrendHead><div><h4>Model trends</h4><p>Child runs by the model they ran on · same metric as above</p></div></div><div class=subagentRoleTrendList>${rows}</div>`;
-}
-function buildSubagentRoleEconomics(usage,filters,nowMs=Date.now()){
- if(subagentRoleFineFilters(filters))return {reason:'filtered',roles:[],days:[]};
- const selected=selectSubagentUsageScope(usage,filters?.runtime,filters?.window,filters?.project,false);
- if(!selected.usage)return {reason:selected.reason||'unavailable',roles:[],days:[]};
- const query=String(filters?.query||'').trim().toLowerCase(),matchesRole=row=>!query||String(row?.role||'').toLowerCase().includes(query);
- const roles=(Array.isArray(selected.usage.roles)?selected.usage.roles:[]).filter(matchesRole),previousRoles=(Array.isArray(selected.usage.comparison?.roles)?selected.usage.comparison.roles:[]).filter(matchesRole),previousByKey=new Map(previousRoles.map(row=>[subagentRoleKey(row),row]));
- if(!roles.length)return {reason:'empty',roles:[],days:[]};
- const totals=items=>{
-  const runs=items.reduce((sum,row)=>sum+Number(row?.agents||0),0),costCovered=items.reduce((sum,row)=>sum+Number(row?.cost_covered_agents||0),0),costComplete=Boolean(runs)&&costCovered===runs&&items.every(row=>row?.cost_available===true),knownCost=items.reduce((sum,row)=>sum+Number(row?.known_cost||0),0);
-  return {runs,costCovered,costComplete,cost:costCovered?knownCost:null,averageCost:costCovered?knownCost/costCovered:null,incomplete:items.reduce((sum,row)=>sum+Number(row?.incomplete_agents||0),0),attention:items.reduce((sum,row)=>sum+Number(row?.attention_agents||0),0)};
- };
- const current=totals(roles),previous=totals(previousRoles),hasPrevious=previousRoles.length>0;
- const relative=(value,baseline)=>value!=null&&baseline!=null&&baseline>0?(value-baseline)/baseline:null;
- const comparedRoles=roles.map(row=>{
-  const prior=previousByKey.get(subagentRoleKey(row)),currentCovered=Number(row?.cost_covered_agents||0),priorCovered=Number(prior?.cost_covered_agents||0),currentComplete=row?.cost_available===true&&currentCovered===Number(row?.agents||0),priorComplete=prior?.cost_available===true&&priorCovered===Number(prior?.agents||0),currentAverage=currentCovered?Number(row.known_cost||0)/currentCovered:null,priorAverage=priorCovered?Number(prior.known_cost||0)/priorCovered:null;
-  return {...row,previousAgents:prior?Number(prior.agents||0):null,previousCost:priorComplete?Number(prior.known_cost||0):null,costChange:prior&&currentComplete&&priorComplete?relative(Number(row.known_cost||0),Number(prior.known_cost||0)):null,averageCostChange:currentComplete&&priorComplete?relative(currentAverage,priorAverage):null,runChange:prior?Number(row.agents||0)-Number(prior.agents||0):null};
- }).sort((a,b)=>Number(b.known_cost||0)-Number(a.known_cost||0)||Number(b.agents||0)-Number(a.agents||0)||String(a.role).localeCompare(String(b.role)));
- return {reason:null,window:String(filters?.window||'all'),...current,previousRuns:hasPrevious?previous.runs:null,previousCost:hasPrevious?previous.cost:null,previousAverageCost:hasPrevious?previous.averageCost:null,previousIncomplete:hasPrevious?previous.incomplete:null,costChange:hasPrevious&&current.costComplete&&previous.costComplete?relative(current.cost,previous.cost):null,averageCostChange:hasPrevious&&current.costComplete&&previous.costComplete?relative(current.averageCost,previous.averageCost):null,runChange:hasPrevious?current.runs-previous.runs:null,roles:comparedRoles,days:subagentRoleDayRows(usage,filters,nowMs),trendTruncated:usage?.role_days_truncated===true,roleDayCount:Number(usage?.role_day_count||0),modelTrends:buildSubagentModelTrends(usage,filters,nowMs)};
-}
-function renderSubagentRoleSparkline(economics,role){
- return renderSubagentTrendSparkline(economics?.days,economics?.trendTruncated,subagentRoleKey,role,role.role);
-}
-function renderSubagentTrendSparkline(dayRows,truncated,keyFn,role,name){
- if(truncated)return '<div class=subagentRoleSparkEmpty>Trend unavailable · daily history was truncated</div>';
- const allRows=Array.isArray(dayRows)?dayRows:[],key=keyFn(role),roleRows=allRows.filter(row=>keyFn(row)===key),days=[...new Set(roleRows.map(row=>String(row?.day||'')).filter(Boolean))].sort();
- if(!days.length)return '<div class=subagentRoleSparkEmpty>Trend unavailable</div>';
- const points=new Map();
- roleRows.forEach(row=>{const day=String(row?.day||''),point=points.get(day)||{cost:0,runs:0,complete:true};point.cost+=Number(row?.known_cost||0);point.runs+=Number(row?.agents||0);point.complete=point.complete&&row?.cost_available===true;points.set(day,point);});
- if(subagentRoleChartMode!=='runs'&&[...points.values()].some(point=>!point.complete))return '<div class=subagentRoleSparkEmpty>Spend trend hidden: some runs have no price. Switch to Runs to see the trend.</div>';
- const value=day=>{const point=points.get(day);if(subagentRoleChartMode==='runs')return point.runs;if(subagentRoleChartMode==='average')return point.runs?point.cost/point.runs:0;return point.cost;},values=days.map(value),maximum=Math.max(.000001,...values),width=220,height=62,pad=5;
- const x=index=>days.length===1?width/2:pad+index*(width-2*pad)/(days.length-1),y=item=>height-pad-(item/maximum)*(height-2*pad),line=values.map((item,index)=>`${x(index).toFixed(1)},${y(item).toFixed(1)}`).join(' '),area=days.length>1?`M ${x(0).toFixed(1)} ${height-pad} L ${line.replaceAll(' ',', ')} L ${x(days.length-1).toFixed(1)} ${height-pad} Z`:'';
- const modeLabel={spend:'spend',average:'cost per run',runs:'runs'}[subagentRoleChartMode]||'spend',mark=days.length===1?`<circle cx="${x(0)}" cy="${y(values[0])}" r=3 fill=var(--accent)/>`:`<path d="${area}" style="fill:rgb(var(--signal-rgb)/.08)"/><polyline points="${line}" fill=none stroke=var(--accent) stroke-width=2.2 vector-effect=non-scaling-stroke/>`;
- return `<div class=subagentRoleSpark><svg viewBox="0 0 ${width} ${height}" preserveAspectRatio=none role=img aria-label="${esc(name)} ${esc(modeLabel)} trend">${mark}</svg><div class=subagentRoleSparkDates><span>${esc(days[0])}</span><span>${esc(days[days.length-1])}</span></div></div>`;
-}
-function renderSubagentRoleEconomics(economics){
- if(economics?.reason==='filtered')return '<div class=subagentRoleAnalyticsEmpty><strong>Role trends unavailable for these row filters</strong><p>Clear Model, Status, and Signal to compare exact role periods. The filtered role table remains available below.</p></div>';
- if(!economics||economics.reason)return `<div class="subagentResultsEmpty emptyState"><div><strong>No provider-reported roles match</strong>${economics?.reason==='unavailable'?'Exact role aggregates are unavailable for this scope.':'Adjust the app, project, or time range, or inspect Sessions for anonymous child agents.'}</div></div>`;
- const change=value=>value==null?'--':`${value>0?'↑ ':value<0?'↓ ':''}${Math.abs(value*100).toFixed(0)}%`,changeClass=value=>value==null?'':value<0?' good':value>0?' warn':'';
- const comparisonsAvailable=!economics.trendTruncated,comparisonUnavailable='Comparison unavailable: daily series truncated';
- const coverage=`${f(economics.costCovered)} / ${f(economics.runs)} cost-covered`,costComplete=economics.costCovered===economics.runs,baseline=!comparisonsAvailable?comparisonUnavailable:economics.previousRuns==null?'':economics.costChange==null?'Comparison unavailable':`${change(economics.costChange)} vs prior`;
- const kpi=(label,value,note,kind='')=>`<div class="subagentRoleKpi metric ${kind}"><span>${esc(label)}</span><strong>${esc(value)}</strong>${note?`<small>${esc(note)}</small>`:''}</div>`;
- const rows=economics.roles.map(row=>{
-  const runs=Number(row.agents||0),covered=Number(row.cost_covered_agents||0),roleCoverage=`${f(covered)}/${f(runs)} priced`,total=covered?money(row.known_cost||0):'--',average=covered?money(Number(row.known_cost||0)/covered):'--',incomplete=Number(row.incomplete_agents||0);
-  const primary=subagentRoleChartMode==='runs'?f(runs):subagentRoleChartMode==='average'?average:total;
-  const delta=subagentRoleChartMode==='runs'?(!comparisonsAvailable||row.runChange==null?'':`${row.runChange>0?'+':''}${f(row.runChange)} vs prior`):change(comparisonsAvailable?(subagentRoleChartMode==='average'?row.averageCostChange:row.costChange):null);
-  const deltaClass=subagentRoleChartMode==='average'?changeClass(comparisonsAvailable?row.averageCostChange:null):'';
-  const label={spend:covered===runs?'Spend':'Covered spend',average:covered===runs?'Cost / run':'Cost / covered run',runs:'Runs'}[subagentRoleChartMode]||'Cost / run';
-  const distribution=row.median_cost==null||row.p95_cost==null?'--':`${money(row.median_cost)} / ${money(row.p95_cost)}`;
-  return `<div class=subagentRoleTrendRow><div class=subagentRoleIdentity><strong>${esc(row.role)}</strong><small>${esc(appFilterLabel({provider:row.runtime}))} · ${esc(row.kind||'child')} · ${esc(`${f(runs)} ${runs===1?'run':'runs'}`)}<br>${esc(roleCoverage)}</small></div><div class="subagentRolePrimary${deltaClass}"><span>${esc(label)}</span><b>${esc(primary)}</b>${delta&&delta!=='--'?`<small>${esc(delta)}</small>`:''}</div>${renderSubagentRoleSparkline(economics,row)}<div class=subagentRoleMeta><span>Median / P95</span><b>${esc(distribution)}</b>${incomplete?`<span class="subagentRoleSignal warn">${f(incomplete)} incomplete</span>`:''}</div><button class=subagentRoleInspect type=button data-subagent-inspect-role="${esc(row.role)}" data-subagent-inspect-runtime="${esc(row.runtime)}" data-subagent-inspect-kind="${esc(row.kind)}" aria-label="${esc(`View runs for ${row.role} in ${appFilterLabel({provider:row.runtime})}`)}">View runs</button></div>`;
- }).join('');
- const averageNote=!comparisonsAvailable?comparisonUnavailable:economics.previousRuns==null?'':economics.averageCostChange==null?'Comparison unavailable':`${change(economics.averageCostChange)} vs prior`,runsNote=!comparisonsAvailable?comparisonUnavailable:economics.runChange==null?'':`${economics.runChange>0?'+':''}${f(economics.runChange)} vs prior`;
- return `<div class=subagentRoleEconomics><div class=subagentRoleKpis>${kpi(costComplete?'Cost / run':'Cost / covered run',economics.averageCost==null?'--':money(economics.averageCost),costComplete?averageNote:coverage,changeClass(comparisonsAvailable?economics.averageCostChange:null))}${kpi(costComplete?'Role spend':'Covered role spend',economics.cost==null?'--':money(economics.cost),costComplete?baseline:coverage)}${kpi('Named runs',f(economics.runs),runsNote)}</div><div class=subagentRoleTrendHead><div><h4>Role trends</h4></div><div class="seg subagentRoleChartModes"><button class="${subagentRoleChartMode==='average'?'on':''}" type=button data-subagent-role-chart=average>Cost / run</button><button class="${subagentRoleChartMode==='spend'?'on':''}" type=button data-subagent-role-chart=spend>Spend</button><button class="${subagentRoleChartMode==='runs'?'on':''}" type=button data-subagent-role-chart=runs>Runs</button></div></div><div class=subagentRoleTrendList>${rows}</div>${renderSubagentModelTrends(economics.modelTrends)}<p class=subagentRoleEconomicsFoot>Local API-rate estimates · Cost per run is not a quality score.</p></div>`;
-}
-function subagentParentSessionMap(){
- const rows=[...(allSessionInventory||[]),...(LATEST?.xsession?.sessions||[]),...(LATEST?.xsession?.current_sessions||[])],result=new Map();
- rows.forEach(row=>{const id=String(row?.id||'');if(id&&!result.has(id))result.set(id,row);});
- return result;
-}
-function subagentParentPresentation(rootSessionId,project,parentSessions=subagentParentSessionMap()){
- const row=parentSessions.get(String(rootSessionId||'')),title=String(row?.title||row?.session_name||'').trim();
- return {title:title||'Parent session',project:projectFilterLabel(project||row?.project)||'No project',runtime:appFilterLabel(row||{})};
-}
-function subagentGroupHtml(group,index,parentSessions,issuesOnly=false){
- const parent=subagentParentPresentation(group.rootSessionId,group.project,parentSessions),selected=group.rows.some(row=>String(row?.id||'')===selectedSubagentId),open=selected||expandedSubagentRoot===group.rootSessionId||(expandedSubagentRoot===null&&index<1);
- const cost=group.costCovered?money(group.cost):'--',tokens=group.tokenCovered?compactNumber(group.knownTokens):'--',workTime=group.workTimeCovered===group.agents?durationShort(group.workTime):'--';
- const badges=[group.incomplete?`<span class="subagentSessionBadge chip tone-warn">${f(group.incomplete)} incomplete</span>`:'',group.working?`<span class="subagentSessionBadge chip">${f(group.working)} working</span>`:''].filter(Boolean).join('');
- const visibleRows=issuesOnly?group.rows.filter(row=>row?.activity_state==='incomplete'||Array.isArray(row?.attention)&&row.attention.length):group.rows;
- const maximumChildCost=Math.max(0,...group.rows.filter(row=>row?.cost_available===true).map(row=>Number(row.cost)||0));
- const children=visibleRows.map((row,rowIndex)=>{
-  const identity=agentIdentityPresentation(row,rowIndex),state=String(row?.activity_state||'unknown'),model=row?.model&&row.model!=='unknown'?row.model:'model unavailable',costValue=row?.cost_available===true?money(row.cost):'--',tokenValue=row?.tokens_available===true?compactNumber(row.tokens):'tokens --',workTimeValue=row?.work_time_s==null?'work time --':`work time ${durationShort(row.work_time_s)}`,id=String(row?.id||''),isSelected=id&&id===selectedSubagentId,heat=subagentCostHeat(row.cost,maximumChildCost,row.cost_available);
-  return `<button class="subagentChildRow${isSelected?' selected':''}" type=button data-subagent-id="${esc(id)}"${isSelected?' aria-current=true':''} aria-label="Inspect ${esc(identity.primary)}"><span class=subagentChildIdentity><strong><span>${esc(identity.primary)}</span></strong><small>${esc([identity.secondary,row.kind,tokenValue,workTimeValue].filter(Boolean).join(' · '))}</small></span><span class=subagentChildMetric>${esc(model)}</span><span class="agentState ${esc(state)}">${esc(state)}</span><span class="subagentChildMetric${heat?' subagentCostHeat':''}"${heat?` style="${heat}" title="Relative child cost in this session"`:''}>${esc(costValue)}</span></button>`;
- }).join('');
- const hiddenSiblings=group.agents-visibleRows.length,footer=issuesOnly&&hiddenSiblings?`<button class=subagentSiblingLink type=button data-subagent-show-session="${esc(group.rootSessionId)}">View ${f(hiddenSiblings)} other ${hiddenSiblings===1?'child':'children'} in Sessions</button>`:'',spawnedRunMetric=issuesOnly?'':`<span class=subagentSessionMetric><span>Spawned runs</span><b>${f(group.agents)}</b></span>`;
- return `<details class=subagentSessionGroup data-subagent-root="${esc(group.rootSessionId)}"${open?' open':''}><summary aria-label="${esc(`${parent.title}, ${group.agents} child agents, ${group.incomplete} incomplete`)}"><div class=subagentSessionIdentity><strong><span title="${esc(parent.title)}">${esc(parent.title)}</span>${badges}</strong><small title="${esc(parent.project)} · ${f(group.agents)} ${countWord(group.agents,'child agent')}">${esc(parent.project)} · ${f(group.agents)} ${countWord(group.agents,'child agent')}</small></div><div class=subagentSessionMetrics>${spawnedRunMetric}<span class=subagentSessionMetric><span>Child cost</span><b>${esc(cost)}</b></span><span class=subagentSessionMetric><span>Tokens</span><b>${esc(tokens)}</b></span><span class=subagentSessionMetric><span>Work time</span><b>${esc(workTime)}</b></span></div></summary><div class=subagentChildHeader><span>Agent</span><span>Model</span><span>Status</span><span>Est. cost</span></div>${children}${footer}</details>`;
-}
-function renderSubagentInspector(row,allRows,parentSessions=subagentParentSessionMap()){
- const inspector=$('subagent-inspector');
- if(!row){inspector.innerHTML='<div class="subagentInspectorEmpty emptyState"><div><svg viewBox="0 0 40 40" aria-hidden=true><circle cx="20" cy="11" r="5"/><circle cx="10" cy="29" r="4"/><circle cx="30" cy="29" r="4"/><path d="M20 16v6M10 25v-4h20v4"/></svg><strong>Select a child agent</strong><p>See its parent, cost, work time, and available retry evidence.</p></div></div>';return;}
- const identity=agentIdentityPresentation(row,0),parent=subagentParentPresentation(row.root_session_id,row.project,parentSessions),siblings=(allRows||[]).filter(item=>String(item?.root_session_id||'')===String(row.root_session_id||'')),siblingIndex=Math.max(0,siblings.findIndex(item=>String(item?.id||'')===String(row.id||'')))+1;
- const state=String(row.activity_state||'unknown'),model=row.model&&row.model!=='unknown'?row.model:'model unavailable',cost=row.cost_available===true?money(row.cost):'--',tokens=row.tokens_available===true?f(row.tokens):'--',workTime=row.work_time_s==null?'--':durationShort(row.work_time_s),attempts=Number(row.retries||0)+Number(row.failed_attempts||0),attention=Array.isArray(row.attention)&&row.attention.length;
- const peers=(allRows||[]).filter(item=>item?.cost_available===true&&item?.runtime===row.runtime&&item?.model===row.model&&item?.kind===row.kind&&Number(item?.depth||0)===Number(row.depth||0)).map(item=>Number(item.cost)||0).sort((a,b)=>a-b),middle=Math.floor(peers.length/2),peerMedian=!peers.length?null:peers.length%2?peers[middle]:(peers[middle-1]+peers[middle])/2,comparison=row.cost_available===true&&peerMedian>0&&peers.length>1?`${(Number(row.cost)/peerMedian).toFixed(1)}× cohort median · ${f(peers.length)} comparable agents`:'Comparable cost baseline unavailable';
- const reasons=attention?`<ul>${row.attention.map(reason=>`<li><strong>${esc(String(reason?.code||'').replaceAll('_',' '))}:</strong> ${esc(reason?.explanation||'Evidence threshold met.')}</li>`).join('')}</ul>`:'';
- const metric=(label,value)=>`<div class=subagentInspectorMetric><span>${esc(label)}</span><b>${esc(value)}</b></div>`;
- inspector.innerHTML=`<div class=subagentInspectorHead><div><h3>${esc(identity.primary)}</h3><p>${esc(identity.secondary?`Provider role · nickname ${identity.secondary}`:'Child-agent evidence')}</p></div><button class=subagentInspectorClose type=button data-subagent-close-detail aria-label="Close agent inspector">×</button></div><div class=subagentInspectorParent><span>Parent session</span><strong title="${esc(parent.title)}">${esc(parent.title)}</strong><small>${esc(parent.project)} · child ${f(siblingIndex)} of ${f(siblings.length)}</small></div><div class=subagentInspectorTags><span>${esc(appFilterLabel({provider:row.runtime}))}</span><span>${esc(model)}</span><span>${esc(row.kind||'child')}</span><span>${esc(state)}</span></div><div class=subagentInspectorGrid>${metric('Estimated cost',cost)}${metric('Tokens',tokens)}${metric('Work time',workTime)}${metric('Executions',f(row.executions||0))}${metric('Tool calls',f(row.tool_calls||0))}${metric('Retry evidence',f(attempts))}</div><div class=subagentInspectorSignals><strong>Cost and retry evidence</strong>${reasons}<p>${esc(comparison)}</p></div><button class="subagentOpenParent subagentInspectorAction" type=button data-subagent-open-parent="${esc(row.root_session_id)}">Open parent session</button>`;
-}
-function renderSubagentRoles(rows){
- const roles=buildSubagentRoleRows(rows);
- if(!roles.length)return '<div class="subagentResultsEmpty emptyState"><div><strong>No provider-reported roles match</strong>Adjust the filters or inspect Sessions for anonymous child agents.</div></div>';
- return `<div class=subagentRoleTable><div class=subagentRoleHeader><span>Role</span><span>Runs</span><span>Total spend</span><span>Incomplete</span><span>Median / P95</span><span>Tokens</span></div>${roles.map(row=>{const coverage=row.costCovered===row.agents?'complete':`${f(row.costCovered)} / ${f(row.agents)} covered`,tokenValue=row.tokenCovered?compactNumber(row.knownTokens):'--',totalSpend=row.costCovered?money(row.knownCost):'--';return `<div class=subagentRoleRow><div class=subagentRoleIdentity><strong>${esc(row.role)}</strong><small>${esc(appFilterLabel({provider:row.runtime}))} · ${esc(row.kind)} · ${esc(row.topModel)} · ${esc(coverage)}</small></div><div class=subagentRoleMetric><span>Runs</span><b>${f(row.agents)}</b></div><div class=subagentRoleMetric><span>Total spend</span><b>${esc(totalSpend)}</b></div><div class="subagentRoleMetric${row.incomplete?' warn':''}"><span>Incomplete</span><b>${pct(row.incompleteRate)}</b></div><div class=subagentRoleMetric><span>Median / P95</span><b>${row.medianCost==null?'--':`${money(row.medianCost)} / ${money(row.p95Cost)}`}</b></div><div class=subagentRoleMetric><span>Tokens</span><b>${esc(tokenValue)}</b></div></div>`;}).join('')}</div>`;
-}
-function renderSubagentExplorer(usage){
- const inventory=Array.isArray(usage?.inventory)?usage.inventory:[],filters=subagentFilters;
- if($('subagent-explorer').parentElement===$('subagent-page-home')){subagentView='roles';if(filters.role||filters.kind){filters.role='';filters.kind='';persistSubagentFilter('role');persistSubagentFilter('kind');}}
- else if(subagentView==='roles')subagentView='sessions';
- localStorage.setItem('tm_subagent_view',subagentView);
- const values=key=>[...new Set(inventory.map(row=>String(row?.[key]||'')).filter(Boolean))].sort((a,b)=>a.localeCompare(b,undefined,{sensitivity:'base'}));
- const runtimes=values('runtime'),projects=values('project'),models=values('model');
- if(filters.runtime&&!runtimes.includes(filters.runtime))filters.runtime='';
- if(filters.project&&!projects.includes(filters.project))filters.project='';
- if(filters.model&&!models.includes(filters.model))filters.model='';
- setLogSelectOptions($('subagent-filter-app'),'<option value="">All apps</option>'+runtimes.map(value=>`<option value="${esc(value)}">${esc(appFilterLabel({provider:value}))}</option>`).join(''),filters.runtime);
- setLogSelectOptions($('subagent-filter-project'),'<option value="">All projects</option>'+projects.map(value=>`<option value="${esc(value)}">${esc(projectFilterLabel(value))}</option>`).join(''),filters.project);
- setLogSelectOptions($('subagent-filter-model'),'<option value="">All models</option>'+models.map(value=>`<option value="${esc(value)}">${esc(value)}</option>`).join(''),filters.model);
- $('subagent-filter-search').value=filters.query;$('subagent-filter-status').value=filters.status;$('subagent-filter-signal').value=filters.signal;$('subagent-filter-time').value=filters.window;$('subagent-filter-sort').value=filters.sort;
- const advancedCount=[filters.model,filters.status!=='all',filters.signal!=='all',filters.sort!=='recent'].filter(Boolean).length;
- $('subagent-filter-advanced').hidden=!subagentAdvancedOpen;$('subagent-filter-more').setAttribute('aria-expanded',String(subagentAdvancedOpen));$('subagent-filter-more-count').textContent=advancedCount?String(advancedCount):'';
- const filterItems=subagentActiveFilterItems(filters);
- $('subagent-active-filters').innerHTML=filterItems.length?'<span>Filtered by</span>'+filterItems.map(item=>`<button class=subagentFilterChip type=button data-subagent-clear-filter="${esc(item.key)}" aria-label="Remove ${esc(item.label)} filter"><b>${esc(item.label)}: ${esc(item.value)}</b><i aria-hidden=true>×</i></button>`).join(''):'';
- $('subagent-filter-footer').hidden=!filterItems.length;
- $('subagent-filter-clear').disabled=!filterItems.length;
- const contextFilters={...filters,status:'all',signal:'all'},context=filterSubagentInventory(usage,contextFilters),result=filterSubagentInventory(usage,filters),summary=result.summary,exact=summary.complete,parentSessions=subagentParentSessionMap();
- const roleQuery=String(filters.query||'').trim().toLowerCase(),roleVisibleRows=context.rows.filter(row=>!roleQuery||String(row?.role||'').toLowerCase().includes(roleQuery));
- const issueGroups=groupSubagentSessions(context.rows,true,'priority'),sessionGroups=groupSubagentSessions(context.rows,false,filters.sort),roleRows=buildSubagentRoleRows(roleVisibleRows);
- $('subagent-view-issues-count').textContent=context.summary.complete?f(issueGroups.length):'--';$('subagent-view-sessions-count').textContent=context.summary.complete?f(sessionGroups.length):'--';$('subagent-view-roles-count').textContent=context.summary.complete?f(roleRows.length):'--';
- [...$('subagent-view-tabs').querySelectorAll('[data-subagent-view]')].forEach(button=>{const active=button.dataset.subagentView===subagentView;button.setAttribute('aria-selected',String(active));button.tabIndex=active?0:-1;if(active)$('subagent-results-panel').setAttribute('aria-labelledby',subagentView==='roles'?'subagent-results-title':button.id);});
- $('subagent-explorer-meta').hidden=false;$('subagent-explorer-meta').textContent=result.truncated?`${f(result.rows.length)} visible of ${f(result.inventoryCount)} child runs`:result.rows.length===result.inventoryCount?`${f(result.inventoryCount)} child runs`:`${f(result.rows.length)} of ${f(result.inventoryCount)} child runs`;
- const compact=(label,value,kind='',filter='')=>filter?`<button class="subagentCompactMetric actionable ${kind}" type=button data-subagent-summary-filter="${esc(filter)}" aria-pressed="${String(filter==='incomplete'?filters.status==='incomplete':filters.signal===filter)}"><span>${esc(label)}</span><b>${esc(value)}</b></button>`:`<span class="subagentCompactMetric ${kind}"><span>${esc(label)}</span><b>${esc(value)}</b></span>`;
- const signalLabels={peer_cost_outlier:'cost outliers',active_cost_concentration:'active concentrations',retry_pressure:'retry pressure'};
- const signalPills=Object.entries(context.signalCounts).filter(([,count])=>count>0).map(([code,count])=>compact(signalLabels[code]||code.replaceAll('_',' '),f(count),'warn',code));
- const incompletePill=compact('Incomplete',context.summary.complete?f(context.summary.incomplete):'--',context.summary.incomplete?'warn':'dim','incomplete');
-  $('subagent-compact-summary').innerHTML=(subagentView==='roles'?[incompletePill]:[incompletePill,compact('Matching child cost',exact&&summary.costCovered?money(summary.cost):'--'),compact('Cost evidence',exact?`${f(summary.costCovered)} / ${f(summary.agents)}`:'--'),...signalPills]).join('');
-  const warning=$('subagent-inventory-warning');warning.hidden=!result.truncated;warning.textContent=result.truncated?'Display limit reached — filtered totals withheld.':'';
-  const unresolved=Number(usage?.totals?.unresolved_agents)||0,unresolvedCost=Number(usage?.totals?.unresolved_known_cost)||0,coverageNote=$('subagent-coverage-note');
-  coverageNote.hidden=!unresolved;
-  const coverageDetail='The parent session record is missing from the local history. These child runs are counted in global totals, but the hierarchy and spend-share rollups leave them out.';
-  coverageNote.innerHTML=unresolved
-   ?`<span class=fieldtip tabindex=0 aria-description="${esc(coverageDetail)}" data-tip="${esc(coverageDetail)}"><b>${f(unresolved)}</b> ${countWord(unresolved,'child run')}${unresolvedCost?` (${money(unresolvedCost)})`:''} ${unresolved===1?'has':'have'} no parent session; left out of the rollups above.</span>`
-   :'';
- if(selectedSubagentId&&!result.rows.some(row=>String(row?.id||'')===selectedSubagentId))selectedSubagentId='';
- const copy={issues:['Issues','Incomplete runs and cost/retry signals.'],sessions:['Parent sessions','Child runs grouped by parent. Cost color is relative within each session.'],roles:['Roles','']}[subagentView];
- $('subagent-results-title').textContent=copy[0];$('subagent-results-description').textContent=copy[1];
- $('subagent-filter-search').placeholder=subagentView==='roles'?'Find a role or model':'Role, nickname, model, or project';
- const roleView=subagentView==='roles';$('subagent-workspace').classList.toggle('roleView',roleView);$('subagent-inspector').hidden=roleView;
- renderSubagentModelDistribution(result.rows,result.truncated);
- if(subagentView==='roles'){
-  const economics=buildSubagentRoleEconomics(usage,filters),filteredRoleRows=result.rows.filter(row=>!roleQuery||String(row?.role||'').toLowerCase().includes(roleQuery)),roles=economics.reason?buildSubagentRoleRows(filteredRoleRows):economics.roles;$('subagent-results-count').textContent=`${f(roles.length)} ${countWord(roles.length,'role')}`;$('subagent-results').innerHTML=economics.reason==='filtered'?renderSubagentRoleEconomics(economics)+renderSubagentRoles(filteredRoleRows):renderSubagentRoleEconomics(economics);
- }else{
-  const groups=groupSubagentSessions(result.rows,subagentView==='issues',subagentView==='issues'?'priority':filters.sort),agentCount=groups.reduce((total,group)=>total+group.agents,0);
-  const signalCount=groups.reduce((total,group)=>total+group.attention,0),incompleteCount=groups.reduce((total,group)=>total+group.incomplete,0);
-  $('subagent-results-count').textContent=subagentView==='issues'?`${f(groups.length)} ${countWord(groups.length,'session')} · ${f(incompleteCount)} incomplete · ${f(signalCount)} with cost/retry signals`:`${f(groups.length)} ${countWord(groups.length,'session')} · ${f(agentCount)} ${countWord(agentCount,'agent')}`;
-  $('subagent-results').innerHTML=groups.length?groups.map((group,index)=>subagentGroupHtml(group,index,parentSessions,subagentView==='issues')).join(''):`<div class="subagentResultsEmpty emptyState"><div><strong>${subagentView==='issues'?'No matching runs':'No parent sessions match'}</strong>${subagentView==='issues'?'No incomplete children or cost/retry signals match these filters.':'Adjust the filters to restore child-agent sessions.'}</div></div>`;
- }
- const selected=result.rows.find(row=>String(row?.id||'')===selectedSubagentId)||null;
- renderSubagentInspector(selected,result.rows,parentSessions);
-}
-function selectSubagentUsageScope(usage,runtime,window,project,hasTextFilter){
- if(hasTextFilter)return {usage:null,reason:'filtered'};
- if(!usage||typeof usage!=='object')return {usage:null,reason:'unavailable'};
- runtime=String(runtime||'');
- window=String(window||'all');
- project=String(project||'');
- const scopes=Array.isArray(usage.scopes)?usage.scopes:[];
- if(scopes.length){
-  const selected=scopes.find(item=>String(item?.runtime||'')===runtime&&String(item?.window||'all')===window&&String(item?.project||'')===project);
-  if(selected)return {usage:selected,reason:null};
-  return {usage:null,reason:usage.scope_truncated===true?'unavailable':'empty'};
- }
- return !runtime&&window==='all'&&!project?{usage,reason:null}:{usage:null,reason:'empty'};
-}
-function renderSubagentUsage(usage,filters=subagentFilters,hasRowFilters=false){
- const module=$('subagent-usage'),baseAgentCount=Number(usage?.totals?.agents)||0;
- if(!usage||baseAgentCount<1){module.hidden=true;return;}
- module.hidden=false;
- [...$('subagent-usage-dimension').querySelectorAll('[data-subagent-dimension]')].forEach(button=>{
-  const active=button.dataset.subagentDimension===subagentUsageDimension;
-  button.classList.toggle('on',active);
-  button.setAttribute('aria-pressed',String(active));
- });
- [...$('subagent-usage-sort').querySelectorAll('[data-subagent-sort]')].forEach(button=>{
-  const active=button.dataset.subagentSort===subagentUsageSort;
-  button.classList.toggle('on',active);
-  button.setAttribute('aria-pressed',String(active));
- });
- const selection=selectSubagentUsageScope(usage,filters.runtime,filters.window,filters.project,hasRowFilters);
- if(!selection.usage){
-  $('subagent-usage-summary').innerHTML='';
-  const message=selection.reason==='filtered'
-   ?'Usage patterns are shown when role, nickname, model, status, and signal filters are clear.'
-   :selection.reason==='empty'
-    ?'No child-agent usage matches the selected project, app, and activity window.'
-    :'Subagent statistics are unavailable for this filter.';
-  $('subagent-usage-rows').innerHTML=`<div class="subagentUsageEmpty emptyState">${message}</div>`;
-  return;
- }
- const scoped=selection.usage,totals=scoped.totals||{},agentCount=Number(totals.agents)||0;
- if(!agentCount){
-  $('subagent-usage-summary').innerHTML='';
-  $('subagent-usage-rows').innerHTML='<div class="subagentUsageEmpty emptyState">No child-agent usage matches the selected app and activity window.</div>';
-  return;
- }
- const costSummary=totals.cost_available===true
-  ? money(totals.cost)
-  : Number(totals.known_cost)>0?`${money(totals.known_cost)} known`:'--';
- const tokenSummary=totals.tokens_available===true
-  ? f(totals.tokens)
-  : Number(totals.known_tokens)>0?`${f(totals.known_tokens)} known`:'--';
- const metric=(label,value,note)=>`<div class="subagentUsageStat metric"><span>${esc(label)}</span><strong>${esc(value)}</strong><small>${esc(note)}</small></div>`;
- const share=totals.agent_spend_share==null?'--':pct(totals.agent_spend_share),coveredGroups=Number(totals.group_cost_covered_sessions)||0,totalGroups=Number(totals.parent_sessions)||0,shareNote=coveredGroups===totalGroups?'of covered group spend':`${f(coveredGroups)} of ${f(totalGroups)} parent sessions have complete group cost`;
- const median=totals.median_cost==null?'--':money(totals.median_cost),p95=totals.p95_cost==null?'cost distribution unavailable':`P95 ${money(totals.p95_cost)} API-rate estimate`;
- const outputPerDollar=totals.output_per_dollar==null?'--':compactNumber(totals.output_per_dollar);
- const input=totals.input_tokens==null?'--':f(totals.input_tokens),output=totals.output_tokens==null?'--':f(totals.output_tokens),cache=totals.cache_read_tokens==null?'--':f(Number(totals.cache_read_tokens||0)+Number(totals.cache_write_tokens||0));
- $('subagent-usage-summary').innerHTML=[
-  metric('Child agents',f(agentCount),`${f(totals.parent_sessions||0)} ${countWord(totals.parent_sessions||0,'parent session')}`),
-  metric('Estimated cost',costSummary,totals.cost_available===true?'complete cost coverage':`${f(totals.cost_covered_agents||0)} of ${f(agentCount)} cost-covered`),
-  metric('Tokens',tokenSummary,`${input} in · ${output} out · ${cache} cache`),
-  metric('Child spend share',share,shareNote),
-  metric('Median / agent',median,p95),
-  metric('Output / $',outputPerDollar,totals.output_per_dollar==null?'complete output and cost required':'covered output tokens per dollar'),
-  metric('Needs attention',f(totals.attention_agents||0),'server evidence signals'),
- ].join('');
- let rows=Array.isArray(scoped[subagentUsageDimension])?[...scoped[subagentUsageDimension]]:[];
- if(!rows.length){
-  $('subagent-usage-rows').innerHTML=`<div class="subagentUsageEmpty emptyState">${subagentUsageDimension==='roles'?'No provider-reported roles are available.':'No child-agent usage is available for this grouping.'}</div>`;
-  return;
- }
- const rowMetric=row=>({cost:Number(row?.known_cost)||0,tokens:Number(row?.known_tokens)||0,agents:Number(row?.agents)||0,output:Number(row?.output_per_dollar)||0}[subagentUsageSort]||0);
- rows.sort((left,right)=>rowMetric(right)-rowMetric(left)||String(left.id||'').localeCompare(String(right.id||'')));
- const maximum=Math.max(1,...rows.map(rowMetric));
- $('subagent-usage-rows').innerHTML=rows.map(row=>{
-  const identity=subagentUsageIdentity(row,subagentUsageDimension),agents=Number(row.agents)||0,width=100*rowMetric(row)/maximum;
-  const tokens=row.tokens_available===true?f(row.tokens):Number(row.known_tokens)>0?`${f(row.known_tokens)} known`:'--';
-  const cost=row.cost_available===true?money(row.cost):Number(row.known_cost)>0?`${money(row.known_cost)} known`:'--';
-  const efficiency=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar);
-  return `<div class=subagentUsageRow><div class=subagentUsageIdentity><strong>${esc(identity.label)}</strong><small>${esc(identity.detail)}</small></div><div class=subagentUsageBar aria-hidden=true><i style="width:${Math.max(0,Math.min(100,width))}%"></i></div><div class=subagentUsageValue><span>Agents</span><b>${f(agents)}</b></div><div class=subagentUsageValue><span>Tokens</span><b>${esc(tokens)}</b></div><div class=subagentUsageValue><span>Cost</span><b>${esc(cost)}</b></div><div class=subagentUsageValue><span>Output / $</span><b>${esc(efficiency)}</b></div></div>`;
- }).join('');
-}
-$('subagent-usage-dimension')?.addEventListener('click',event=>{
- const dimension=event.target.closest('[data-subagent-dimension]')?.dataset.subagentDimension;
- if(!['runtimes','models','depths','kinds','roles'].includes(dimension))return;
- subagentUsageDimension=dimension;
- localStorage.setItem('tm_subagent_usage_dimension',dimension);
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-});
-$('subagent-usage-sort')?.addEventListener('click',event=>{
- const sort=event.target.closest('[data-subagent-sort]')?.dataset.subagentSort;
- if(!['cost','tokens','agents','output'].includes(sort))return;
- subagentUsageSort=sort;
- localStorage.setItem('tm_subagent_usage_sort',sort);
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-});
-const subagentFilterBindings={
- 'subagent-filter-app':['runtime','tm_subagent_filter_app'],
- 'subagent-filter-project':['project','tm_subagent_filter_project'],
- 'subagent-filter-model':['model','tm_subagent_filter_model'],
- 'subagent-filter-status':['status','tm_subagent_filter_status'],
- 'subagent-filter-signal':['signal','tm_subagent_filter_signal'],
- 'subagent-filter-time':['window','tm_subagent_filter_time'],
- 'subagent-filter-sort':['sort','tm_subagent_filter_sort'],
-};
-const subagentFilterStorage={query:'tm_subagent_filter_search',role:'tm_subagent_filter_role',kind:'tm_subagent_filter_kind',runtime:'tm_subagent_filter_app',project:'tm_subagent_filter_project',model:'tm_subagent_filter_model',status:'tm_subagent_filter_status',signal:'tm_subagent_filter_signal',window:'tm_subagent_filter_time',sort:'tm_subagent_filter_sort'};
-const subagentFilterDefaults={query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'};
-function persistSubagentFilter(key){
- const storage=subagentFilterStorage[key],value=subagentFilters[key],fallback=subagentFilterDefaults[key];
- if(!storage)return;
- if(value===fallback)localStorage.removeItem(storage);else localStorage.setItem(storage,value);
-}
-function resetSubagentResultView(){subagentVisibleLimit=SUBAGENT_PAGE_SIZE;selectedSubagentId='';}
-function normalizedSubagentNavigationState(view,filters){
- const allowed={status:['all','working','complete','incomplete','waiting','recent','unknown'],signal:['all','attention','peer_cost_outlier','active_cost_concentration','retry_pressure'],window:['today','yesterday','7d','30d','90d','month','last_month','all'],sort:['recent','cost','tokens','work','name']},rawSource=filters&&typeof filters==='object'?(filters.window==='24h'?{...filters,window:'today'}:filters):{},source=rawSource.sort==='elapsed'?{...rawSource,sort:'work'}:rawSource;
- const normalized={...subagentFilterDefaults};
- ['query','role','kind','runtime','project','model'].forEach(key=>normalized[key]=String(source[key]??subagentFilterDefaults[key]??''));
- Object.entries(allowed).forEach(([key,values])=>normalized[key]=values.includes(source[key])?source[key]:subagentFilterDefaults[key]);
- return {view:['issues','sessions','roles'].includes(view)?view:'roles',filters:normalized};
-}
-function restoreSubagentNavigationState(state){
- if(!state||typeof state!=='object')return false;
- const snapshot=normalizedSubagentNavigationState(state.view,state.filters);
- subagentView=snapshot.view;subagentFilters=snapshot.filters;localStorage.setItem('tm_subagent_view',subagentView);
- Object.keys(subagentFilterDefaults).forEach(persistSubagentFilter);expandedSubagentRoot=null;resetSubagentResultView();
- return true;
-}
-function openSubagentModelRuns(model,runtime){
- const current=normalizedSubagentNavigationState(subagentView,subagentFilters),next=normalizedSubagentNavigationState('sessions',{...subagentFilters,query:'',role:'',kind:'',model:String(model||''),runtime:String(runtime||subagentFilters.runtime||'')});
- history.replaceState({...history.state,subagent:current},'',location.href);
- history.pushState({...history.state,subagent:next},'',`/#sessions-subagents`);
- restoreSubagentNavigationState(next);
-}
-function openSubagentRoleRuns(role,runtime,kind){
- const current=normalizedSubagentNavigationState(subagentView,subagentFilters),next=normalizedSubagentNavigationState('sessions',{...subagentFilters,query:'',role:String(role||''),kind:String(kind||''),runtime:String(runtime||subagentFilters.runtime||'')});
- history.replaceState({...history.state,subagent:current},'',location.href);
- history.pushState({...history.state,subagent:next},'',`/#sessions-subagents`);
- restoreSubagentNavigationState(next);
-}
-window.addEventListener('popstate',event=>{
- if(!['subagents','sessions-subagents'].includes((location.hash||'').replace(/^#/,''))||!restoreSubagentNavigationState(event.state?.subagent))return;
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-});
-$('subagent-filter-search').addEventListener('input',event=>{
- subagentFilters.query=event.target.value;persistSubagentFilter('query');resetSubagentResultView();renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-});
-Object.entries(subagentFilterBindings).forEach(([id,[key,storage]])=>$(id).addEventListener('change',event=>{
- subagentFilters[key]=event.target.value;persistSubagentFilter(key);resetSubagentResultView();renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-}));
-$('subagent-filter-more').onclick=()=>{
- subagentAdvancedOpen=!subagentAdvancedOpen;
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
- if(subagentAdvancedOpen)requestAnimationFrame(()=>$('subagent-filter-advanced').querySelector('select')?.focus());
-};
-$('subagent-view-tabs').onclick=event=>{
- const view=event.target.closest('[data-subagent-view]')?.dataset.subagentView;
- if(!['issues','sessions','roles'].includes(view))return;
- subagentView=view;localStorage.setItem('tm_subagent_view',view);selectedSubagentId='';expandedSubagentRoot=null;renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-};
-$('subagent-view-tabs').onkeydown=event=>{
- if(!['ArrowLeft','ArrowRight','Home','End'].includes(event.key))return;
- event.preventDefault();
- const buttons=[...$('subagent-view-tabs').querySelectorAll('[data-subagent-view]')].filter(button=>button.dataset.subagentView!=='roles'),index=buttons.indexOf(event.target.closest('[data-subagent-view]'));
- if(index<0)return;
- const next=event.key==='Home'?0:event.key==='End'?buttons.length-1:(index+(event.key==='ArrowRight'?1:-1)+buttons.length)%buttons.length;
- buttons[next].focus();buttons[next].click();
-};
-$('subagent-compact-summary').onclick=event=>{
- const filter=event.target.closest('[data-subagent-summary-filter]')?.dataset.subagentSummaryFilter;
- if(!filter)return;
- subagentFilters=toggleSubagentSummaryFilter(subagentFilters,filter);
- persistSubagentFilter('status');persistSubagentFilter('signal');resetSubagentResultView();
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-};
-$('subagent-active-filters').onclick=event=>{
- const key=event.target.closest('[data-subagent-clear-filter]')?.dataset.subagentClearFilter;
- if(!(key in subagentFilterDefaults))return;
- subagentFilters[key]=subagentFilterDefaults[key];persistSubagentFilter(key);resetSubagentResultView();
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-};
-$('subagent-filter-clear').onclick=()=>{
- subagentFilters={...subagentFilterDefaults};
- ['tm_subagent_filter_search','tm_subagent_filter_role','tm_subagent_filter_kind',...Object.values(subagentFilterBindings).map(([,storage])=>storage)].forEach(key=>localStorage.removeItem(key));
- subagentAdvancedOpen=false;
- resetSubagentResultView();
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-};
-$('subagent-results').onclick=event=>{
- const chart=event.target.closest('[data-subagent-role-chart]')?.dataset.subagentRoleChart;
- if(['spend','average','runs'].includes(chart)){subagentRoleChartMode=chart;localStorage.setItem('tm_subagent_role_chart',chart);renderSubagentExplorer(LATEST?.xsession?.agent_usage);return;}
- const roleButton=event.target.closest('[data-subagent-inspect-role]');
- if(roleButton){openSubagentRoleRuns(roleButton.dataset.subagentInspectRole,roleButton.dataset.subagentInspectRuntime,roleButton.dataset.subagentInspectKind);applyHashRoute();return;}
- const modelButton=event.target.closest('[data-subagent-inspect-model]');
- if(modelButton){openSubagentModelRuns(modelButton.dataset.subagentInspectModel,modelButton.dataset.subagentInspectRuntime);applyHashRoute();return;}
- const root=event.target.closest('[data-subagent-show-session]')?.dataset.subagentShowSession;
- if(root){
-  subagentView='sessions';localStorage.setItem('tm_subagent_view',subagentView);selectedSubagentId='';expandedSubagentRoot=root;renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-  const group=[...$('subagent-results').querySelectorAll('[data-subagent-root]')].find(item=>item.dataset.subagentRoot===root);group?.scrollIntoView({block:'start'});return;
- }
- const row=event.target.closest('[data-subagent-id]');
- if(!row)return;
- selectedSubagentId=selectedSubagentId===row.dataset.subagentId?'':row.dataset.subagentId;
- renderSubagentExplorer(LATEST?.xsession?.agent_usage);
-};
-$('subagent-results').addEventListener('toggle',event=>{
- const group=event.target;if(!(group instanceof HTMLDetailsElement)||!group.matches('[data-subagent-root]'))return;
- if(group.open)expandedSubagentRoot=group.dataset.subagentRoot;else if(expandedSubagentRoot===group.dataset.subagentRoot)expandedSubagentRoot='';
-},true);
-$('subagent-inspector').onclick=event=>{
- const root=event.target.closest('[data-subagent-open-parent]')?.dataset.subagentOpenParent;
- if(root){selectSession(root,{returnScope:'subagents'});return;}
- if(event.target.closest('[data-subagent-close-detail]')){selectedSubagentId='';renderSubagentExplorer(LATEST?.xsession?.agent_usage);}
-};
-function allSessionsView(all,{showChildren=false,app='',project='',rangeStart=0,rangeEnd=0,query=''}={}){
- const baseMatch=s=>{
-  if(app&&appFilterGroup(s)!==app)return false;
-  if(project&&projectFilterValue(s.project)!==project)return false;
-  if(rangeStart&&(s.mtime||0)<rangeStart)return false;
-  if(rangeEnd&&(s.mtime||0)>=rangeEnd)return false;
-  return true;
- };
- const textMatch=s=>!query||[s.title,s.project,s.provider,s.label,s.child_agent_role,(s.models||[]).join(' ')].join(' ').toLowerCase().includes(query);
- const matching=(all||[]).filter(s=>baseMatch(s)&&textMatch(s));
- const children=matching.filter(s=>s.is_child_session);
- let rows=matching;
- if(!showChildren){
-  // A matching child run surfaces its root card, so search still finds it.
-  const childRoots=new Set(children.map(childRootId).filter(Boolean));
-  rows=(all||[]).filter(s=>!s.is_child_session&&((baseMatch(s)&&textMatch(s))||childRoots.has(String(s.id))));
- }
- // Header figures cover exactly the matching sessions and child runs in both
- // modes; a root card surfaced only by a matching child adds no spend of its own.
- const statsRows=matching;
- const shownIds=new Set(rows.map(s=>String(s.id)));
- const underParent=children.filter(s=>shownIds.has(childRootId(s))).length;
- const matchedSessions=matching.length-children.length;
- return {
-  rows,statsRows,showChildren,
-  matchedSessions,
-  total:(all||[]).filter(s=>!s.is_child_session).length,
-  surfacedParents:showChildren?0:Math.max(0,rows.length-matchedSessions),
-  children:children.length,
-  childCost:children.filter(s=>metricAvailable(s,'cost')).reduce((a,b)=>a+(b.cost||0),0),
-  underParent,
-  unparented:children.length-underParent,
- };
-}
-function allSessionsCountText(view){
- const statsRows=view.statsRows;
- const cost=statsRows.reduce((a,b)=>a+(b.cost||0),0),localEstimates=statsRows.filter(row=>hasLocalEstimate(row)&&metricAvailable(row,'cost')).length,costCovered=statsRows.filter(row=>metricAvailable(row,'cost')).length;
- // Hidden subagent runs are still counted in totals, so report how many of the
- // matching runs sit under a shown parent card and how many have no parent.
- const parentNote=view.unparented
-  ?`${f(view.underParent)} shown under parent cards · ${f(view.unparented)} with no parent session`
-  :'listed under parents';
- const childNote=!view.showChildren&&view.children
-  ?` · includes ${f(view.children)} subagent ${countWord(view.children,'run')} (${money(view.childCost)}) counted, ${parentNote}`
-  :'';
- // Sessions and child runs are counted separately; spend and cost coverage
- // share one denominator: the matching sessions plus matching child runs.
- const runNote=view.showChildren&&view.children?` + ${f(view.children)} subagent ${countWord(view.children,'run')}`:'';
- const surfacedNote=view.surfacedParents?` · ${f(view.surfacedParents)} parent ${countWord(view.surfacedParents,'card')} shown for matching runs`:'';
- return `${f(view.matchedSessions)} of ${f(view.total)} sessions${runNote} · ${money(cost)} covered spend · ${f(costCovered)} of ${f(statsRows.length)} cost-covered${localEstimates?` · includes ${f(localEstimates)} Cursor local ${countWord(localEstimates,'estimate')}`:''}${childNote}${surfacedNote}`;
-}
-function renderAllSessions(xs){
- if(!xs)return;
- const generatedAt=Number(xs.generated_at||0);
- const liveSessionIds=new Set((xs.current_sessions||[]).map(sessionRowKey));
- setLogText($('g-hint'),generatedAt?`live · updated ${new Date(generatedAt*1000).toLocaleTimeString([], {hour:'2-digit',minute:'2-digit',second:'2-digit'})}`:'recent activity');
- const all=$('view-session').classList.contains('on')&&sessionScope==='all'&&allSessionInventory?mergeAllSessionInventory(allSessionInventory,xs.sessions):xs.sessions||[];
- renderedAllSessions=new Map(all.map(row=>[sessionRowKey(row),row]));
- // Index every discovered child run, including the ones kept out of the list,
- // so each parent card can render its own children inline.
- indexChildSessions(allSessionInventory&&allSessionInventory.length?allSessionInventory:all);
- renderedAllSessionActions=xs.session_actions||{};
- const apps=[...new Map(all.map(session=>[
-  appFilterGroup(session),
-  appFilterLabel(session),
- ])).entries()].map(([id,label])=>({id,label})).sort((a,b)=>a.label.localeCompare(b.label,undefined,{sensitivity:'base'}));
- if(globalApp&&!apps.some(app=>app.id===globalApp)){
-  globalApp='';
-  localStorage.removeItem('tm_global_app');
- }
- setLogSelectOptions($('g-app'),'<option value="">All apps</option>'+apps.map(app=>`<option value="${esc(app.id)}">${esc(app.label)}</option>`).join(''),globalApp);
- const projects=[...new Set(all.map(s=>projectFilterValue(s.project)))].sort((a,b)=>projectFilterLabel(a).localeCompare(projectFilterLabel(b),undefined,{sensitivity:'base'}));
- if(globalProject&&!projects.includes(globalProject)){
- globalProject='';
- localStorage.removeItem('tm_global_project');
- }
- setLogSelectOptions($('g-project'),'<option value="">All projects</option>'+projects.map(project=>`<option value="${esc(project)}">${esc(projectFilterLabel(project))}</option>`).join(''),globalProject);
- paintGlobalFilters();
- const timeLabels=TIME_FILTER_LABELS;
- const appLabel=apps.find(app=>app.id===globalApp)?.label||globalApp;
- const activeFilters=[
-  globalSearch.trim()&&['search',`Search: “${globalSearch.trim()}”`],
-  globalApp&&['app',`App: ${appLabel}`],
-  globalProject&&['project',`Project: ${projectFilterLabel(globalProject)}`],
-  globalTime!==DEFAULT_TIME_FILTER_WINDOW&&['time',timeLabels[globalTime]||globalTime],
-  workSessionFilter&&['work',`Work: ${workSessionFilter.label}${workSessionFilter.loading?' (loading)':''}`],
- ].filter(Boolean);
- const hideActiveFilters=!activeFilters.length;
- if($('g-active-filters').hidden!==hideActiveFilters)$('g-active-filters').hidden=hideActiveFilters;
- setLogHtml($('g-active-filters'),activeFilters.length
-  ? `<span>Filtered by</span>${activeFilters.map(([key,label])=>`<button type=button data-clear-log-filter="${key}" title="Remove ${esc(label)} filter">${esc(label)}<b aria-hidden=true>×</b></button>`).join('')}`
-  : '');
- const q=globalSearch.trim().toLowerCase();
- const {start:rangeStart,end:rangeEnd}=timeFilterBounds(globalTime);
- // A Work drill-down narrows the inventory to the trace files behind that Work cell.
- const workRows=workSessionFilter?all.filter(s=>workSessionFilter.keys.has(sessionRowKey(s))):all;
- const view=allSessionsView(workRows,{showChildren:globalShowChildren,app:globalApp,project:globalProject,rangeStart,rangeEnd,query:q});
- let sessions=view.rows;
- // Header stats count every matching run, so hiding subagent rows never removes
- // their spend from the figures that the Hidden control says are still counted.
- renderAllSessionStats(view.statsRows);
- const sorters={
-   recent:(a,b)=>(b.mtime||0)-(a.mtime||0),
-   cost:(a,b)=>(b.cost||0)-(a.cost||0)||(b.mtime||0)-(a.mtime||0),
-   tokens:(a,b)=>(b.tokens||0)-(a.tokens||0)||(b.mtime||0)-(a.mtime||0),
-	  executions:(a,b)=>(b.turns||0)-(a.turns||0)||(b.mtime||0)-(a.mtime||0),
-	  wait:(a,b)=>Number(b.wait_time?.total_s||0)-Number(a.wait_time?.total_s||0)||(b.mtime||0)-(a.mtime||0),
- };
- sessions=sessions.slice().sort(sorters[globalSort]||sorters.recent);
- if(workSessionFilter?.loading)setLogText($('g-count'),'Loading the sessions behind this Work filter…');
- else if(workSessionFilter?.failed)setLogText($('g-count'),'The sessions behind this Work filter could not be loaded. Clear the filter or try again.');
- else setLogText($('g-count'),allSessionsCountText(view));
- const maxCost=Math.max(.001,...sessions.map(s=>s.cost||0));
- reconcileLogRows(sessions,maxCost,liveSessionIds);
- if(compareIds.length)syncCompareSelectionUi();
-}
-$('slist').onclick=event=>{
- const compareButton=event.target.closest('[data-compare-toggle]');
- if(compareButton){
-  event.stopPropagation();
-  if(compareButton.dataset.compareTitle)compareTitles.set(compareButton.dataset.compareToggle,compareButton.dataset.compareTitle);
-  toggleCompareId(compareButton.dataset.compareToggle);
-  return;
- }
- const childButton=event.target.closest('[data-open-session]');
- if(childButton){
-  event.stopPropagation();
-  event.preventDefault();
- const childId=childButton.dataset.openSession;
- const childRow=renderedAllSessions.get(childId);
- if(childRow)selectSession(sessionRowKey(childRow));
- return;
- }
- const identityButton=event.target.closest('[data-session-model-identity]');
- if(identityButton){
-  event.stopPropagation();
-  const row=renderedAllSessions.get(identityButton.closest('[data-id]')?.dataset.id);
-  if(row)openSessionModelIdentityDialog(row);
-  return;
- }
- const button=event.target.closest('[data-delete-session]');
- if(button){
-  event.stopPropagation();
-  const row=renderedAllSessions.get(button.dataset.deleteSession);
-  if(row)openSessionDeleteDialog(row,renderedAllSessionActions,true,Boolean(LATEST&&sessionRowKey(row)===stateSessionKey(LATEST)));
-  return;
- }
- const row=event.target.closest('[data-id]');
- if(row)selectSession(row.dataset.id);
-};
-$('slist').onkeydown=event=>{
- const row=event.target.closest('[data-id]');
- if(!row||!['Enter',' '].includes(event.key)||event.target.closest('button'))return;
- event.preventDefault();
- selectSession(row.dataset.id);
-};
-function sessionCoverageCopy(totals,sessionCount,localEstimates){
- const costCovered=Number(totals?.costCovered)||0,tokenCovered=Number(totals?.tokenCovered)||0,estimateNote=localEstimates?` · includes ${f(localEstimates)} Cursor local ${countWord(localEstimates,'estimate')}`:'';
- return {
-  costNote:sessionCount?(costCovered?`${f(costCovered)} of ${f(sessionCount)} cost-covered sessions · ${money(Number(totals?.cost||0)/costCovered)}/covered session${estimateNote}`:'cost unavailable for matching sessions'):'no matching sessions',
-  tokenTitle:tokenCovered?`${f(tokenCovered)} of ${f(sessionCount)} token-covered sessions${estimateNote}`:'token evidence unavailable',
- };
-}
-function renderAllSessionStats(sessions){
-	 const localEstimates=sessions.filter(row=>hasLocalEstimate(row)&&metricAvailable(row,'cost')).length;
-	 const totals=sessions.reduce((sum,row)=>{
-	  sum.cost+=Number(row.cost||0);sum.input+=Number(row.input_tokens||0);sum.output+=Number(row.output_tokens||0);sum.executions+=Number(row.turns||0);sum.wait+=Number(row.wait_time?.total_s||0);sum.waitSamples+=Number(row.wait_time?.sample_count||0);sum.costCovered+=metricAvailable(row,'cost')?1:0;sum.tokenCovered+=metricAvailable(row,'tokens')?1:0;
-	  return sum;
-	 },{cost:0,input:0,output:0,executions:0,wait:0,waitSamples:0,costCovered:0,tokenCovered:0});
- const coverageCopy=sessionCoverageCopy(totals,sessions.length,localEstimates);
- setLogHtml($('lf-cost'),costValueHtml(money(totals.cost),Boolean(totals.costCovered)));
- setLogText($('lf-cost-note'),coverageCopy.costNote);
- setLogText($('lf-input'),totals.tokenCovered?compactNumber(totals.input):'--');setLogAttribute($('lf-input'),'title',totals.tokenCovered?`${f(totals.input)} reported or locally estimated input/context tokens · ${coverageCopy.tokenTitle}`:'input evidence unavailable');
- setLogText($('lf-output'),totals.tokenCovered?compactNumber(totals.output):'--');setLogAttribute($('lf-output'),'title',totals.tokenCovered?`${f(totals.output)} reported or locally estimated output tokens · ${coverageCopy.tokenTitle}`:'output evidence unavailable');
-	 setLogText($('lf-executions'),f(totals.executions));
-	 setLogText($('lf-executions-note'),sessions.length?`${(totals.executions/sessions.length).toFixed(1)} average / session`:'no matching executions');
-	 setLogText($('lf-wait'),totals.waitSamples?waitFmt(totals.wait):'--');
-	 setLogText($('lf-wait-note'),totals.waitSamples?`${waitFmt(totals.wait/totals.waitSamples)} average · ${f(totals.waitSamples)} timed ${countWord(totals.waitSamples,'request')}`:'no completed wait timing in filtered sessions');
- const models=new Map();
- sessions.forEach(session=>{
-  let rows=session.model_stats||[];
-  if(!rows.length&&(session.models||[]).length===1)rows=[{model:session.models[0],cost:session.cost,tokens:session.tokens,input_tokens:session.input_tokens,output_tokens:session.output_tokens,executions:session.turns,availability:session.availability}];
-  rows.forEach(item=>{
-   const model=item.model||'unknown',runtime=session.runtime||session.label||session.provider||'unknown',key=`${model}::${runtime}`,row=models.get(key)||{model,runtime,cost:0,tokens:0,input:0,output:0,executions:0,sessions:0,costCovered:0,tokenCovered:0,estimated:0};
-   row.cost+=Number(item.cost||0);row.tokens+=Number(item.tokens||0);row.input+=Number(item.input_tokens||0);row.output+=Number(item.output_tokens||0);row.executions+=Number(item.executions||0);row.sessions+=1;row.costCovered+=metricAvailable(item,'cost')?1:0;row.tokenCovered+=metricAvailable(item,'tokens')?1:0;row.estimated+=hasLocalEstimate(session)?1:0;models.set(key,row);
-  });
- });
- const ranked=[...models.values()].sort((a,b)=>b.cost-a.cost||b.tokens-a.tokens||a.model.localeCompare(b.model));
- setLogText($('lf-model-count'),`${f(ranked.length)} ${countWord(ranked.length,'model')}`);
- setLogHtml($('lf-models'),ranked.length?ranked.slice(0,4).map(row=>`<div class=logModelRow><div><div class=logModelName title="${esc(row.model)} · ${esc(row.runtime)}">${esc(row.model)} · ${esc(row.runtime)}</div><div class=logModelMeta>${f(row.sessions)} ${countWord(row.sessions,'session')} · ${f(row.executions)} execs · ${row.tokenCovered?compactNumber(row.input)+' in · '+compactNumber(row.output)+' out'+(row.estimated?' · includes local estimates':''):'token evidence unavailable'}</div></div><div class=logModelValue><b class=mono>${costValueHtml(money(row.cost),Boolean(row.costCovered))}</b><span>${row.costCovered?pct(totals.cost?row.cost/totals.cost:0)+' of covered cost'+(row.estimated?' · API-rate estimate':''):'billing unavailable'}</span></div></div>`).join('')+(ranked.length>4?`<div class=logModelEmpty>+${f(ranked.length-4)} more ${countWord(ranked.length-4,'model runtime')}</div>`:''):'<div class=logModelEmpty>No model data for these filters</div>');
-}
-
-const CACHE_RING_TICKS=30,CACHE_RING_SIZE=40;
-function cacheRingState(win,now=Date.now()/1000){
- const anchor=Number(win?.anchor_ts),windowS=Number(win?.window_s);
- if(!(anchor>0)||!(windowS>0))return null;
- const elapsed=Math.max(0,now-anchor),maxS=win.max_window_s==null?null:Number(win.max_window_s);
- const left=windowS-elapsed,maxLeft=maxS==null?Infinity:maxS-elapsed;
- const estimate=win.basis!=='recorded',fixed=maxS!=null&&maxS<=windowS;
- // A documented range or minimum is typical, not guaranteed, so past it the cache may still be warm.
- const tone=left>120?'good':left>30?'warn':left>0?'bad':(maxLeft>0||(estimate&&!fixed))?'maybe':'cold';
- return {left,maxLeft,tone,windowS,total:maxS&&maxS>windowS?maxS:windowS,estimate};
-}
-function cacheClock(seconds){
- const s=Math.max(0,Math.ceil(seconds));
- return s>=600?`${Math.round(s/60)}m`:`${Math.floor(s/60)}:${String(s%60).padStart(2,'0')}`;
-}
-function cacheWindowLabel(win){
- const s=Number(win.window_s),max=win.max_window_s==null?null:Number(win.max_window_s);
- const span=v=>v>=3600?`${v/3600} h`:`${Math.round(v/60)} min`;
- if(win.basis==='recorded')return `recorded ${span(s)} cache lifetime`;
- const who=win.source==='openai'?'OpenAI':win.source==='anthropic'?'Anthropic':'The provider';
- if(max==null)return `${who} documents at least ${span(s)}; estimate`;
- return max>s?`${who} documents about ${span(s)}–${span(max)}; estimate`:`${who} documents ${span(s)}; estimate`;
-}
-function cacheRingText(win,state){
- const head=state.left>0
-  ?`Cache ${state.tone==='good'?'warm':'cooling'} · ${state.estimate?'about ':''}${cacheClock(state.left)} left`
-  :state.tone==='maybe'?'Cache may have expired':state.estimate?'Cache likely expired':'Cache expired';
- const parts=[`${head} (${cacheWindowLabel(win)}).`];
- if(win.prefix_tokens>0&&win.cold_cost_delta!=null){
-  const cost=win.cold_cost_delta<.05?`under ${money(.1)}`:`about ${money(win.cold_cost_delta)}`;
-  const verb=win.cold_kind==='write'?'re-writes':'re-sends, uncached,';
-  parts.push(`${state.left>0?'After that, the next prompt':'The next prompt'} ${verb} ${compactNumber(win.prefix_tokens)} tokens: ${cost} more than a warm prompt (estimate).`);
- }else if(!win.cache_reported){
-  parts.push('This agent does not report per-request cache use, so the timer uses the provider’s documented lifetime.');
- }
- return parts.join(' ');
-}
-function cacheRingTicks(state,size=CACHE_RING_SIZE,count=CACHE_RING_TICKS){
- const center=size/2,outer=center-1,length=3;
- const lit=Math.ceil(Math.max(0,state.left)/state.total*count);
- const remainingMax=Number.isFinite(state.maxLeft)?state.maxLeft:(state.left>0?state.left:0);
- const maybe=Math.max(0,Math.ceil(Math.max(0,remainingMax)/state.total*count)-lit);
- let lines='';
- for(let i=0;i<count;i++){
-  const angle=i/count*2*Math.PI-Math.PI/2,fromEnd=count-i;
-  const cls=fromEnd<=lit?'':fromEnd<=lit+maybe?'maybe':'off';
-  const x1=center+Math.cos(angle)*(outer-length),y1=center+Math.sin(angle)*(outer-length);
-  const x2=center+Math.cos(angle)*outer,y2=center+Math.sin(angle)*outer;
-  lines+=`<line${cls?` class=${cls}`:''} x1="${x1.toFixed(2)}" y1="${y1.toFixed(2)}" x2="${x2.toFixed(2)}" y2="${y2.toFixed(2)}"/>`;
- }
- return `<svg viewBox="0 0 ${size} ${size}" aria-hidden=true>${lines}</svg>`;
-}
-function cacheRingFace(state){return state.left>0?cacheClock(state.left):state.tone==='maybe'?'?':'—';}
-function cacheRingAttrs(win){
- return `data-cache-window="${esc(JSON.stringify(win))}"`;
-}
-function cacheRingHtml(row){
- const win=row?.cache_window,state=cacheRingState(win);
- if(!state)return'';
- const text=cacheRingText(win,state);
- return `<span class="cacheRing ${state.tone}" role=img aria-label="${esc(text)}" title="${esc(text)}" ${cacheRingAttrs(win)}>${cacheRingTicks(state)}<b>${cacheRingFace(state)}</b></span>`;
-}
-function tickCacheRings(){
- document.querySelectorAll('.cacheRing[data-cache-window]').forEach(el=>{
-  let win;try{win=JSON.parse(el.dataset.cacheWindow);}catch(error){return;}
-  const state=cacheRingState(win);if(!state)return;
-  const text=cacheRingText(win,state);
-  el.className=`cacheRing ${state.tone}`;
-  el.setAttribute('aria-label',text);el.setAttribute('title',text);
-  el.innerHTML=`${cacheRingTicks(state)}<b>${cacheRingFace(state)}</b>`;
- });
-}
-function currentSessionAge(row){
- const seconds=Math.max(0,Math.round(Date.now()/1000-Number(row?.mtime||0)));
- if(seconds<60)return `${seconds}s ago`;
- const minutes=Math.floor(seconds/60);
- if(minutes<60)return `${minutes}m ago`;
- return `${Math.floor(minutes/60)}h ago`;
-}
-function currentSessionContext(row){
- const context=row?.context||{},latest=Number(context.latest||0),window=Number(context.window||0),ratio=Number(context.latest_pct);
- if(window&&Number.isFinite(ratio))return `${Math.round(Math.max(0,ratio)*100)}%`;
- if(latest)return `${compactNumber(latest)}${context.estimated?' est':''}`;
- return '--';
-}
-function currentSessionModelName(value){
- const raw=String(value||'').trim();
- if(!raw||raw.toLowerCase()==='unknown')return 'Unknown model';
- const claude=raw.match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)(?:-.+)?$/i);
- if(claude)return `Claude ${claude[1][0].toUpperCase()+claude[1].slice(1).toLowerCase()} ${claude[2]}.${claude[3]}`;
- return raw.split(/[-_]+/).filter(Boolean).map(part=>{
-  const lower=part.toLowerCase();
-  if(lower==='gpt')return 'GPT';
-  if(lower==='ai')return 'AI';
-  if(/^\d/.test(part))return part;
-  return part[0].toUpperCase()+part.slice(1);
- }).join(' ');
-}
-function loadCurrentSessionOrder(){
- try{
-  const value=JSON.parse(localStorage.getItem(CURRENT_SESSION_ORDER_KEY)||'[]');
-  return Array.isArray(value)?[...new Set(value.filter(id=>typeof id==='string'&&id).slice(0,CURRENT_SESSION_ORDER_LIMIT))]:[];
- }catch(error){return [];}
-}
-function saveCurrentSessionOrder(){
- try{localStorage.setItem(CURRENT_SESSION_ORDER_KEY,JSON.stringify(currentSessionOrder.slice(0,CURRENT_SESSION_ORDER_LIMIT)));}catch(error){}
-}
-function orderedCurrentSessionRows(rows){
- const source=Array.isArray(rows)?rows:[],byId=new Map(),sourceIds=[];
- source.forEach(row=>{
-  const id=String(row.id||'');
-  if(!id||byId.has(id))return;
-  byId.set(id,row);sourceIds.push(id);
- });
- const known=currentSessionOrder.filter(id=>byId.has(id)),seen=new Set(known);
- const unseen=sourceIds.filter(id=>!seen.has(id));
- let next=[...unseen,...known];
- if(currentSessionOrderNeedsNewestMigration&&sourceIds.length){
-  const newest=sourceIds[0];
-  next=[newest,...next.filter(id=>id!==newest)];
-  currentSessionOrderNeedsNewestMigration=false;
-  try{localStorage.setItem(CURRENT_SESSION_ORDER_MIGRATION_KEY,'1');}catch(error){}
- }
- if(next.length!==currentSessionOrder.length||next.some((id,index)=>id!==currentSessionOrder[index])){
-  currentSessionOrder=next;
-  saveCurrentSessionOrder();
- }
- return currentSessionOrder.map(id=>byId.get(id)).filter(Boolean);
-}
-function currentSessionPositionMessage(id,index,total){
- const row=(LATEST?.xsession?.current_sessions||[]).find(item=>String(item.id)===String(id));
- return `${row?.session_name||row?.project||'Session'} moved to position ${index+1} of ${total}.`;
-}
-function setCurrentSessionOrder(ids){
- currentSessionOrder=ids;
- saveCurrentSessionOrder();
-}
-function currentSessionKeyboardMove(allIds,visibleIds,sourceId,delta){
- const ids=[...allIds].map(String),visible=[...visibleIds].map(String),source=String(sourceId);
- const from=visible.indexOf(source);
- if(from<0)return null;
- const destination=Math.max(0,Math.min(visible.length-1,from+delta));
- if(destination===from)return null;
- const target=visible[destination],allFrom=ids.indexOf(source);
- if(allFrom<0)return null;
- ids.splice(allFrom,1);
- const allTarget=ids.indexOf(target);
- if(allTarget<0)return null;
- ids.splice(allTarget+(destination>from?1:0),0,source);
- return {ids,index:destination,total:visible.length};
-}
-function moveCurrentSessionCard(sourceId,targetId,after=false){
- const ids=orderedCurrentSessionRows(LATEST?.xsession?.current_sessions||[]).map(row=>String(row.id));
- const from=ids.indexOf(String(sourceId)),target=ids.indexOf(String(targetId));
- if(from<0||target<0||from===target)return null;
- const [moved]=ids.splice(from,1);
- let destination=ids.indexOf(String(targetId))+(after?1:0);
- destination=Math.max(0,Math.min(ids.length,destination));
- ids.splice(destination,0,moved);
- setCurrentSessionOrder(ids);
- return {index:destination,total:ids.length};
-}
-function moveCurrentSessionCardBy(sourceId,delta){
- const orderedRows=orderedCurrentSessionRows(LATEST?.xsession?.current_sessions||[]);
- const result=currentSessionKeyboardMove(
-  orderedRows.map(row=>String(row.id)),
-  currentSessionFilterView(orderedRows,currentSessionRuntimeFilter,currentSessionActivityFilter).rows.map(row=>String(row.id)),
-  sourceId,
-  delta,
- );
- if(!result)return null;
- setCurrentSessionOrder(result.ids);
- return {index:result.index,total:result.total};
-}
-function clearCurrentSessionDropMarkers(){
- $('current-session-grid').querySelectorAll('.dropBefore,.dropAfter').forEach(card=>card.classList.remove('dropBefore','dropAfter'));
- currentSessionDropId='';
- currentSessionDropAfter=false;
-}
-function currentSessionContextSparkline(row){
- const context=row?.context||{},windowSize=Math.max(0,Number(context.window)||0);
- const samples=(Array.isArray(context.samples)?context.samples:[])
-  .map(value=>Math.max(0,Number(value)||0)).filter(value=>Number.isFinite(value));
- const observed=Math.max(0,Number(context.latest)||0),hasObservedSamples=samples.some(value=>value>0);
- if(!observed&&!hasObservedSamples)return {html:'',summary:'Context evidence unavailable.'};
- if(!windowSize)return {
-  html:'<span class=currentSessionContextUnavailable aria-hidden=true>window --</span>',
-  summary:observed
-   ?`Context window unavailable; ${compactNumber(observed)} context tokens observed.`
-   :'Context window and latest token count unavailable.',
- };
- if(!samples.length)return {html:'',summary:'Context trajectory unavailable.'};
- const plotted=samples.slice(-24);
- const values=plotted.map(value=>value/windowSize);
- const peak=Math.max(...values),domain=Math.max(1,peak*1.05);
- const width=96,height=22,padX=2,padY=2,plotHeight=height-padY*2,bottom=height-padY,gap=1;
- const barWidth=Math.max(1.5,(width-padX*2-gap*(values.length-1))/values.length);
- const bars=values.map((value,index)=>{
-  const normalized=Math.min(domain,Math.max(0,value))/domain;
-  const barHeight=Math.max(1.5,normalized*plotHeight);
-  const x=padX+index*(barWidth+gap),y=bottom-barHeight;
-  const pressure=value>=.85?' high':value>=.7?' watch':'';
-  const latest=index===values.length-1?' latest':'';
-  return `<rect class="currentSessionContextBar${pressure}${latest}" x="${x.toFixed(2)}" y="${y.toFixed(2)}" width="${barWidth.toFixed(2)}" height="${barHeight.toFixed(2)}" rx=".8"/>`;
- }).join('');
- const latest=values[values.length-1];
- const latestText=pct(latest),peakText=pct(peak);
- const countText=`${plotted.length} recent ${countWord(plotted.length,'execution')}`;
- const summary=`Context across ${countText}: ${latestText} latest, ${peakText} peak.`;
- return {
-  summary,
-  html:`<svg class=currentSessionContextSpark viewBox="0 0 ${width} ${height}" preserveAspectRatio="none" aria-hidden=true><path class=currentSessionContextBaseline d="M${padX},${bottom} H${width-padX}"/>${bars}</svg>`,
- };
-}
-function focusCurrentSessionCard(id){
- const card=[...$('current-session-grid').querySelectorAll('[data-current-session-id]')]
-  .find(item=>item.dataset.currentSessionId===String(id));
- card?.focus();
-}
-function currentSessionActivity(row){
- const state=['working','waiting','recent'].includes(row?.activity_state)?row.activity_state:'recent';
- return {state,label:{working:'Working',waiting:'Waiting',recent:'Recent'}[state]};
-}
-function currentSessionIdsMatch(ids,rows){
- const mounted=[...ids].map(String),expected=(Array.isArray(rows)?rows:[]).map(row=>String(row.id||''));
- return mounted.length===expected.length&&mounted.every((id,index)=>id===expected[index]);
-}
-function sessionFlowSnapshot(rows,seenIds=[],seenReady=false){
- if(!Array.isArray(rows))return {evidence:'unavailable',mode:'idle',count:0,working:0,waiting:0,recent:0,ids:[],arriving:[]};
- const ids=[],states={working:0,waiting:0,recent:0},known=new Set();
- rows.forEach(row=>{
-  const id=String(row?.id||'');
-  if(!id||known.has(id))return;
-  known.add(id);ids.push(id);
-  const state=['working','waiting','recent'].includes(row?.activity_state)?row.activity_state:'recent';
-  states[state]++;
- });
- const previous=new Set((Array.isArray(seenIds)?seenIds:[]).map(String));
- return {
-  evidence:'available',
-  mode:states.working?'working':states.waiting?'waiting':states.recent?'recent':'idle',
-  count:ids.length,
-  working:states.working,
-  waiting:states.waiting,
-  recent:states.recent,
-  ids,
- arriving:seenReady?ids.filter(id=>!previous.has(id)):[],
- };
-}
-function pageSignalTiming(reducedMotion=false,now=performance.now()){
- const elapsed=Math.max(0,now-pageSignalClockStartedAt);
- return {heroSpeed:reducedMotion?0:.018,heroFrame:elapsed*.018,borderSpeed:reducedMotion?0:.016,borderFrame:9000+elapsed*.016};
-}
-function sessionSignalPresentation(snapshot,reducedMotion=false){
- const mode=snapshot?.evidence==='available'&&['working','waiting','recent','idle'].includes(snapshot.mode)?snapshot.mode:'unavailable';
- const strengths={working:1,waiting:.92,recent:.84,idle:.72,unavailable:.62};
- return {...pageSignalTiming(reducedMotion||mode==='unavailable'),mode,heroStrength:strengths[mode]};
-}
-function loadPageEffectsModule(){
- if(!pageEffectsModulePromise)pageEffectsModulePromise=import('/assets/session-effects.js');
- return pageEffectsModulePromise;
-}
-function ensurePageSignalHosts(head){
- let field=head.querySelector('.pageSignalField'),heroHost=head.querySelector('.pageDither');
- if(!field){
-  field=document.createElement('div');field.className='pageSignalField';field.setAttribute('aria-hidden','true');
-  heroHost=document.createElement('div');heroHost.className='pageDither';
-  const fallback=document.createElement('div');fallback.className='pageSignalFallback';
-  field.append(heroHost,fallback);head.appendChild(field);
- }
- let borderHost=head.querySelector('.pageHeroBorder');
- if(!borderHost){borderHost=document.createElement('div');borderHost.className='pageHeroBorder';borderHost.setAttribute('aria-hidden','true');head.appendChild(borderHost);}
- return {heroHost,borderHost};
-}
-function pageSignalPresentation(head){
- if(head?.dataset.pageSignal==='sessions'&&latestSessionSignalSnapshot){
-  return sessionSignalPresentation(latestSessionSignalSnapshot,pageSignalReducedMotionQuery.matches);
- }
- return {...pageSignalTiming(pageSignalReducedMotionQuery.matches),mode:'ambient',heroStrength:.76};
-}
-function pageSignalHandle(handle){
- let disposed=false;
- return {
-  update(presentation){if(!disposed)handle.update(presentation);},
-  dispose(){if(disposed)return;disposed=true;handle.dispose();},
- };
-}
-function disposeActivePageSignalEffects(){
- activePageSignalGeneration++;
- activePageHeroHandle?.dispose();activePageBorderHandle?.dispose();
- activePageHeroHandle=null;activePageBorderHandle=null;activePageSignalHead=null;activePageSignalMounting=false;
-}
-async function syncActivePageSignalEffects(){
- let head=document.querySelector('.view.on .spectrumPageHead[data-page-signal]');
- if(head?.closest('#view-session.sessionDetail'))head=null;
- if(!head){disposeActivePageSignalEffects();return;}
- const presentation=pageSignalPresentation(head);
- if(activePageSignalHead===head&&activePageHeroHandle&&activePageBorderHandle){
-  activePageHeroHandle.update(presentation);activePageBorderHandle.update(presentation);return;
- }
- if(activePageSignalHead===head&&activePageSignalMounting)return;
- disposeActivePageSignalEffects();activePageSignalHead=head;
- const generation=++activePageSignalGeneration,{heroHost,borderHost}=ensurePageSignalHosts(head);
- heroHost.dataset.pageEffect=pageEffectsDisabled?'fallback':'loading';borderHost.dataset.pageEffect=pageEffectsDisabled?'fallback':'loading';
- if(pageEffectsDisabled)return;
- activePageSignalMounting=true;
- let heroHandle=null,borderHandle=null;
- const mountIsCurrent=()=>generation===activePageSignalGeneration&&activePageSignalHead===head&&head.isConnected;
- try{
-  const module=await loadPageEffectsModule();
-  if(!mountIsCurrent())return;
-  heroHandle=pageSignalHandle(await module.mountDitherField(heroHost,presentation));
-  if(!mountIsCurrent()){heroHandle.dispose();return;}
-  activePageHeroHandle=heroHandle;
-  const mountedBorder=await module.mountPulsingBorder(borderHost,presentation,mountIsCurrent);
-  if(!mountedBorder)return;
-  borderHandle=pageSignalHandle(mountedBorder);
-  if(!mountIsCurrent()){heroHandle.dispose();borderHandle.dispose();return;}
-  activePageBorderHandle=borderHandle;
- }catch(error){
-  heroHandle?.dispose();borderHandle?.dispose();
-  if(activePageHeroHandle===heroHandle)activePageHeroHandle=null;
-  if(activePageBorderHandle===borderHandle)activePageBorderHandle=null;
-  if(mountIsCurrent()){
-   pageEffectsDisabled=true;
-   heroHost.replaceChildren();borderHost.replaceChildren();heroHost.dataset.pageEffect='fallback';borderHost.dataset.pageEffect='fallback';
-  }
- }finally{
-  if(generation===activePageSignalGeneration)activePageSignalMounting=false;
- }
-}
-function syncSessionSignal(snapshot){
- latestSessionSignalSnapshot=snapshot;
- if(activePageSignalHead?.dataset.pageSignal==='sessions')syncActivePageSignalEffects();
-}
-function syncSessionFlow(snapshot){
- const head=$('session-flow-head'),label=$('session-flow-label');
- if(!head||!label)return;
- const mode=snapshot.evidence==='available'?snapshot.mode:'unavailable';
- head.dataset.sessionFlow=mode;head.closest('.spectrumPageHeadFrame').dataset.sessionFlow=mode;
- const count=snapshot.count,activeLabel=`${count} active`;
- const nextLabel=snapshot.evidence!=='available'?'Waiting for evidence':!count?'Listening':snapshot.working?`${snapshot.working} working · ${activeLabel}`:activeLabel;
- if(label.textContent!==nextLabel)label.textContent=nextLabel;
- syncSessionSignal(snapshot);
-}
-pageSignalReducedMotionQuery.addEventListener?.('change',syncActivePageSignalEffects);
-function syncCurrentSessionActivity(root,rows){
- const byId=new Map();
- rows.forEach(row=>{const id=String(row.id||'');if(id&&!byId.has(id))byId.set(id,row);});
- root.querySelectorAll('.currentSessionCard[data-current-session-id]').forEach(card=>{
-  const row=byId.get(card.dataset.currentSessionId);
-  if(!row)return;
-  const {state,label}=currentSessionActivity(row),status=card.querySelector('.currentSessionStatus');
-  card.classList.remove('activity-working','activity-waiting','activity-recent');
-  card.classList.add(`activity-${state}`);
-  if(status){status.className=`currentSessionStatus ${state}`;status.textContent=label;}
- });
-}
-function renderCurrentDaySummary(xs){
- if(!Array.isArray(xs?.daily)){
-  // No cross-session payload yet means loading (no note); a payload without daily rows is unavailable.
-  const note=xs&&typeof xs==='object'?'Unavailable':'';
-  $('current-day-spend').textContent='--';$('current-day-spend-note').textContent=note;
-  $('current-day-sessions').textContent='--';$('current-day-sessions-note').textContent=note;
-  $('current-day-vs-yesterday').textContent='--';$('current-day-vs-yesterday-note').textContent=note;
-  return;
- }
- const days=xs.daily;
- const todayKey=localDayKey(),yesterdayDate=new Date();
- yesterdayDate.setHours(12,0,0,0);
- yesterdayDate.setDate(yesterdayDate.getDate()-1);
- const yesterdayKey=localDayKey(yesterdayDate);
- const today=days.find(row=>row.day===todayKey),yesterday=days.find(row=>row.day===yesterdayKey);
- const todayCostAvailable=Boolean(today)&&metricAvailable(today,'cost'),todayPartial=Boolean(today)&&metricPartial(today,'cost');
- const yesterdayCostAvailable=Boolean(yesterday)&&metricAvailable(yesterday,'cost'),yesterdayPartial=Boolean(yesterday)&&metricPartial(yesterday,'cost');
- setCostValue('current-day-spend',money(today?.cost),todayCostAvailable);
- // The value carries no estimate suffix, so the note always says when today includes local estimates.
- $('current-day-spend-note').textContent=!today?'No recorded activity today':!todayCostAvailable?'Cost unavailable':todayPartial?`Partial billing coverage${hasLocalEstimate(today)?' · includes estimates':''}`:`${Number(today.discount_usd||0)>0?`After discounts · list ${money(Number(today.cost||0)+Number(today.discount_usd||0))}`:'API-equivalent estimate'}${hasLocalEstimate(today)?' · includes local estimates':''}`;
- const todaySessions=Number(today?.sessions||0),yesterdaySessions=Number(yesterday?.sessions||0),sessionDelta=todaySessions-yesterdaySessions;
- $('current-day-sessions').textContent=f(todaySessions);
- $('current-day-sessions-note').textContent=!today?(yesterday?`${f(yesterdaySessions)} yesterday · none recorded today`:'No recorded sessions today'):yesterday?`${f(yesterdaySessions)} yesterday${sessionDelta?` · ${f(Math.abs(sessionDelta))} ${countWord(Math.abs(sessionDelta),'session')} ${sessionDelta>0?'more':'fewer'}`:' · unchanged'}`:'No recorded sessions yesterday';
- let comparison='--',comparisonNote='No recorded activity today';
- if(today&&todayCostAvailable){
-  // Partial billing coverage still compares the recorded spend; the note says which day is partial.
-  const partial=todayPartial&&yesterdayPartial?' · both days partial':todayPartial?' · today partial':yesterdayPartial?' · yesterday partial':'';
-  if(!yesterday){comparison=Number(today.cost||0)?'New':'0%';comparisonNote=`No recorded spend yesterday${todayPartial?' · today partial':''}`;}
-  else if(!yesterdayCostAvailable)comparisonNote='Yesterday cost unavailable';
-  else{comparison=dailyDeltaLabel(today.cost,yesterday.cost);comparisonNote=`vs ${money(yesterday.cost)}${hasLocalEstimate(yesterday)?' est':''} yesterday${partial}`;}
- }
- $('current-day-vs-yesterday').textContent=comparison;
- $('current-day-vs-yesterday-note').textContent=comparisonNote;
-}
-function currentSessionsIdleHistory(xs,todayKey=localDayKey()){
- const rows=Array.isArray(xs?.daily)?xs.daily:[];
- const end=new Date(`${todayKey}T12:00:00`);
- const byDay=new Map(rows.map(row=>[row.day,row]));
- const dayKey=date=>`${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;
- const days=Array.from({length:7},(_,index)=>{
-  const date=new Date(end);
-  date.setDate(end.getDate()-6+index);
-  const day=dayKey(date),row=byDay.get(day);
-  return {day,sessions:Math.max(0,Number(row?.sessions)||0)};
- });
- const activeRows=days.map(day=>byDay.get(day.day)).filter(row=>row&&Number(row.sessions)>0);
- const availableCostRows=activeRows.filter(row=>row.availability?.cost!==false);
- const runtimes=[...new Set(activeRows.flatMap(row=>(row.providers||[]).map(provider=>String(provider?.provider||'').trim()).filter(Boolean)))].sort();
- return {
-  days,
-  sessions:days.reduce((total,day)=>total+day.sessions,0),
-  cost:availableCostRows.reduce((total,row)=>total+(Number(row.cost)||0),0),
-  costAvailable:availableCostRows.length>0,
-  costPartial:activeRows.some(row=>row.availability?.cost===false||row.coverage?.cost?.complete===false),
-  costEstimated:availableCostRows.some(row=>['local_estimate','mixed'].includes(row.usage_basis)||Number(row.provenance?.estimated_sessions)>0),
-  runtimes,
- };
-}
-function currentSessionsEmptyHtml(xs,todayKey=localDayKey()){
- const history=currentSessionsIdleHistory(xs,todayKey),maxSessions=Math.max(1,...history.days.map(day=>day.sessions));
- const costText=history.costAvailable?`${history.costPartial?'At least ':''}${money(history.cost)}${history.costEstimated?' est':''} tracked`:'Spend unavailable';
- const runtimeText=`${f(history.runtimes.length)} ${countWord(history.runtimes.length,'runtime')}`;
- const historyTitle=history.sessions?`${f(history.sessions)} past ${countWord(history.sessions,'session')}`:'No past sessions yet';
- const historyDetail=history.sessions?`over 7 days · <b>${esc(costText)}</b> · <b>${esc(runtimeText)}</b>`:'Your seven-day activity will build here.';
- const horizonLabel=history.days.map(day=>`${new Date(`${day.day}T12:00:00`).toLocaleDateString([],{weekday:'short'})} ${day.sessions}`).join(', ');
- const horizon=history.days.map(day=>{
-  const weekday=new Date(`${day.day}T12:00:00`).toLocaleDateString([],{weekday:'short'});
-  const height=day.sessions?Math.max(7,Math.round(62*day.sessions/maxSessions)):0;
-  return `<div class=currentSessionsHistoryDay aria-hidden=true><span class=currentSessionsHistoryValue>${f(day.sessions)}</span><i class=currentSessionsHistoryBar style="--activity:${height}px"></i><small data-short="${esc(weekday.slice(0,1))}">${esc(weekday)}</small></div>`;
- }).join('');
- const historyAction=history.sessions?`<button class=currentSessionsEmptyAction type=button data-current-empty-history>Explore ${f(history.sessions)} past ${countWord(history.sessions,'session')}<svg viewBox="0 0 16 16" aria-hidden=true><path d="M3 8h9M9 4l4 4-4 4"/></svg></button>`:'';
- return `<section class="card currentSessionsEmpty"><div class=currentSessionsEmptyInner><h3>Your next live session appears here</h3><p class=currentSessionsEmptyCopy>Start a supported agent. Its live card appears here.</p><div class=currentSessionsArrival role=group aria-label="Placeholder for the next live session card"><div class=currentSessionsArrivalHead><strong>Next live session</strong><span>Listening</span></div><div class=currentSessionsArrivalMetrics><div class=currentSessionsArrivalMetric><span>Cost</span><strong>--</strong></div><div class=currentSessionsArrivalMetric><span>Output / $</span><strong>--</strong></div><div class=currentSessionsArrivalMetric><span>Context in use</span><strong>--</strong></div><div class=currentSessionsArrivalMetric><span>Speed</span><strong>--</strong></div></div></div><div class=currentSessionsHistorySummary><strong>${esc(historyTitle)}</strong><span>${historyDetail}</span></div><div class=currentSessionsHorizon role=img aria-label="Sessions over the last seven days: ${esc(horizonLabel)}">${horizon}</div><div class=currentSessionsEmptyActions>${historyAction}<a class="currentSessionsEmptyAction secondary" href="https://github.com/splunk/token-meter/issues" target=_blank rel="noopener noreferrer">Share feedback<svg viewBox="0 0 16 16" aria-hidden=true><path d="M6 3h7v7M13 3 6 10M11 9v4H3V5h4"/></svg></a></div></div></section>`;
-}
-function currentSessionsFilteredEmptyHtml(activitySelection){
- const activity=activitySelection==='recent'?'recent':'working';
- return `<section class="card currentSessionsEmpty currentSessionsFilteredEmpty"><div class=currentSessionsEmptyInner><h3>No ${activity} sessions right now</h3><p class=currentSessionsEmptyCopy>Filters are still active. Matching live sessions will appear here automatically.</p></div></section>`;
-}
-function currentSessionRuntimeView(rows,selection='all'){
- const source=Array.isArray(rows)?[...rows]:[],byId=new Map();
- source.forEach(row=>{
-  const id=String(appFilterGroup(row)||'unknown-runtime'),label=String(appFilterLabel(row)||'Unknown Runtime');
-  const option=byId.get(id)||{id,label,count:0};
-  option.count+=1;byId.set(id,option);
- });
- const options=[...byId.values()].sort((a,b)=>a.label.localeCompare(b.label)||a.id.localeCompare(b.id));
- const active=selection==='all'||options.some(option=>option.id===selection)?selection:'all';
- const visible=active==='all'?source:source.filter(row=>String(appFilterGroup(row)||'unknown-runtime')===active);
- return {options,selection:active,rows:visible,countLabel:active==='all'?`${source.length} active`:`${visible.length} of ${source.length} active`};
-}
-function currentSessionFilterView(rows,runtimeSelection='all',activitySelection='all'){
- const source=Array.isArray(rows)?[...rows]:[];
- const runtimeView=currentSessionRuntimeView(source,runtimeSelection);
- const activity=['all','working','recent'].includes(activitySelection)?activitySelection:'all';
- const visible=activity==='all'?runtimeView.rows:runtimeView.rows.filter(row=>currentSessionActivity(row).state===activity);
- const filtered=runtimeView.selection!=='all'||activity!=='all';
- return {...runtimeView,activitySelection:activity,rows:visible,countLabel:filtered?`${visible.length} of ${source.length} active`:`${source.length} active`};
-}
-function currentSessionFilterFocusTarget(view,focusedFilter){
- if(!focusedFilter)return '';
- const ids=['all',...view.options.map(option=>option.id)];
- return ids.includes(focusedFilter)?focusedFilter:view.selection;
-}
-function renderCurrentSessionRuntimeFilters(view){
- const root=$('current-session-runtime-filters'),signature=JSON.stringify(view.options.map(({id,label})=>[id,label]));
- const focusedFilter=root.contains(document.activeElement)?document.activeElement.dataset.currentRuntimeFilter||'':'';
- let optionsChanged=false;
- root.hidden=!view.options.length;
- $('current-session-runtime-filter-group').hidden=root.hidden;
- if(root.dataset.options!==signature){
-  optionsChanged=true;
-  root.dataset.options=signature;
-  root.innerHTML=`<button type=button data-current-runtime-filter=all>All</button>`+view.options.map(option=>`<button type=button data-current-runtime-filter="${esc(option.id)}">${esc(option.label)}</button>`).join('');
- }
- root.querySelectorAll('[data-current-runtime-filter]').forEach(button=>{
-  const selected=button.dataset.currentRuntimeFilter===view.selection;
-  button.classList.toggle('on',selected);button.setAttribute('aria-pressed',selected?'true':'false');
- });
- if(optionsChanged&&focusedFilter){
-  const target=currentSessionFilterFocusTarget(view,focusedFilter);
-  [...root.querySelectorAll('[data-current-runtime-filter]')].find(button=>button.dataset.currentRuntimeFilter===target)?.focus();
- }
-}
-function renderCurrentSessionActivityFilters(selection){
- const root=$('current-session-activity-filters');
- $('current-session-activity-filter-group').hidden=false;
- root.querySelectorAll('[data-current-activity-filter]').forEach(button=>{
-  const selected=button.dataset.currentActivityFilter===selection;
-  button.classList.toggle('on',selected);button.setAttribute('aria-pressed',selected?'true':'false');
- });
-}
-function renderCurrentSessions(state=LATEST){
- renderCurrentDaySummary(state?.xsession);
- const sourceRows=state?.xsession?.current_sessions;
- const flow=sessionFlowSnapshot(sourceRows,currentSessionSeenIds,currentSessionSeenReady);
- syncSessionFlow(flow);
- if(!Array.isArray(sourceRows)){
-  $('current-session-runtime-filters').hidden=true;
-  $('current-session-runtime-filter-group').hidden=true;
-  $('current-session-activity-filters').hidden=true;
-  $('current-session-activity-filter-group').hidden=true;
-  $('current-session-count-label').textContent='Waiting';
-  return;
- }
- const orderedRows=orderedCurrentSessionRows(sourceRows),filterView=currentSessionFilterView(orderedRows,currentSessionRuntimeFilter,currentSessionActivityFilter);
- currentSessionSeenIds=flow.ids;currentSessionSeenReady=true;
- currentSessionRuntimeFilter=filterView.selection;
- currentSessionActivityFilter=filterView.activitySelection;
- renderCurrentSessionRuntimeFilters(filterView);
- $('current-session-activity-filters').hidden=false;
- renderCurrentSessionActivityFilters(filterView.activitySelection);
- const rows=filterView.rows,count=rows.length;
- const arrivingIds=new Set(flow.arriving);
- const baseline=dailyBaseline(state?.xsession?.daily),sessionTypical=baseline.sessionCost;
- const sessionTypicalText=sessionTypical>0?money(sessionTypical)+(baseline.estimated?' est':''):'';
- const focusedId=document.activeElement?.closest?.('[data-current-session-id]')?.dataset.currentSessionId||'';
- $('current-session-count-label').textContent=filterView.countLabel;
- const currentGrid=$('current-session-grid'),interactingCurrentSessionCard=currentGrid.querySelector('.currentSessionSlot:hover,.currentSessionCard:focus,.currentSessionDesktop:focus');
- const mountedCurrentSessionIds=[...currentGrid.querySelectorAll('.currentSessionCard[data-current-session-id]')].map(card=>card.dataset.currentSessionId);
- if(currentSessionDragId||(interactingCurrentSessionCard&&currentSessionIdsMatch(mountedCurrentSessionIds,rows))){syncCurrentSessionActivity(currentGrid,rows);return;}
- currentGrid.innerHTML=count?rows.map(row=>{
-  const provider=runtimeId(row);
-  const {state:activity,label:activityLabel}=currentSessionActivity(row);
-  const costAvailable=row.availability?.cost!==false;
-  const estimate=row.cost_approx||['local_estimate','mixed'].includes(row.usage_basis);
-  // A folded family with an unmeasured member reports a lower bound.
-  const costPartial=costAvailable&&!!row.cost_partial;
-  const cost=costValueHtml(money(row.cost)+(estimate?' est':''),costAvailable,false),costLabel=costPartial?'Cost, at least':'Cost';
-  const costTipAttrs=costAvailable?'':costUnavailableAttrs();
-  const outputPerDollar=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar);
-  const context=currentSessionContext(row);
-  const runtime=runtimeLabel(row),model=currentSessionModelName(row.primary_model);
-  const effort=String(row.reasoning_effort||'').trim().replaceAll('_',' ');
-  const runtimeLine=`${runtime} / ${model}${effort?` ${effort}`:''}`;
-  const sessionName=row.session_name||row.project||'Untitled session';
-	  const throughput=sessionDisplayThroughput(row),speedAvailable=row.availability?.throughput!==false&&throughput.available;
-  const speed=speedAvailable?`${speedFmt(throughput.output_tps)} tok/s${row.token_estimate?' est':''}`:'--';
-  const contextSpark=currentSessionContextSparkline(row);
-  const outputDollarDescription=row.output_per_dollar==null?'Output per dollar unavailable.':`${compactNumber(row.output_per_dollar)} output tokens per covered dollar.`;
-  const costComparable=costAvailable&&!costPartial&&sessionTypical>0;
-  const heroCaption=costComparable?typicalCaption(Number(row.cost)||0,sessionTypical,'your typical session',sessionTypicalText):'';
-  const heroScale=costComparable?readoutScaleHtml({value:Number(row.cost)||0,typical:sessionTypical,label:`${money(row.cost)} against a typical session of ${sessionTypicalText}`}):'';
-  const hints=(row.hints||[]).slice(0,3);
-  const hintText=hints.map(hint=>`${hint.title}: ${hint.detail}`).join(' ');
-  const cardDescription=`${heroCaption?heroCaption+'. ':''}${contextSpark.summary} ${outputDollarDescription}${costPartial?' Cost is a lower bound: some runs in this session family have no cost evidence.':''}${hints.length?` Suggestion${hints.length===1?'':'s'}: ${hintText}`:''} Drag to reorder. Press ⌥ and an arrow key to move.`;
-  const hintsHtml=hints.length?`<div class=currentSessionHints>${hints.map(hint=>`<span class=currentSessionHint data-kind="${esc(hint.kind)}" title="${esc(hint.detail)}"><b>${esc(hint.title)}</b><small>${esc(hint.detail)}</small></span>`).join('')}</div>`:'';
-  const arriving=arrivingIds.has(String(row.id))?' is-arriving':'';
-  const desktop=desktopSessionTarget(row);
-  const desktopLink=desktop?`<a class=currentSessionDesktop href="${esc(desktop.href)}" draggable=false title="${esc(desktop.title)}" aria-label="${esc(`${desktop.label}: ${sessionName}`)}"><svg viewBox="0 0 16 16" aria-hidden=true><path d="M9.5 2.5h4v4M13.5 2.5 7.5 8.5M12 9.5v3a1 1 0 0 1-1 1H3.5a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h3"/></svg></a>`:'';
-  return `<div class=currentSessionSlot${desktop?' data-desktop':''}><button class="card currentSessionCard provider-${esc(provider)} activity-${activity}${arriving}${costAvailable?'':' fieldtip'}" style="--harness:${esc(runtimeHarness(row))}" type=button draggable=true data-current-session-id="${esc(row.id)}" aria-label="${esc(`Open ${sessionName}`)}" aria-description="${esc(cardDescription)}" aria-keyshortcuts="Alt+ArrowLeft Alt+ArrowRight Alt+ArrowUp Alt+ArrowDown" ${costTipAttrs}><div class=currentSessionTop><div class=currentSessionRuntime>${runtimeMarkSvg(row)}<span>${esc(runtimeLine)}</span><span class=currentSessionProject>${esc(row.project||'No project')}</span></div><div class=currentSessionTopMeta><span class=currentSessionMove><svg class=currentSessionGrip viewBox="0 0 12 16" aria-hidden=true><circle cx="3" cy="3" r="1.2"/><circle cx="9" cy="3" r="1.2"/><circle cx="3" cy="8" r="1.2"/><circle cx="9" cy="8" r="1.2"/><circle cx="3" cy="13" r="1.2"/><circle cx="9" cy="13" r="1.2"/></svg>${currentSessionAge(row)}</span>${cacheRingHtml(row)}<div class="currentSessionStatus ${activity}">${activityLabel}</div></div></div><div class=currentSessionIdentity><h3>${esc(sessionName)}</h3><span class="currentSessionCaps mono" title="${esc(CAPABILITY_SUMMARY_TIP)}">${esc(capabilitySummaryText(row.capabilities))}</span></div><div class=currentSessionHero><div class=currentSessionHeroCost><span class=currentSessionHeroLabel>${costLabel}</span><b class="currentSessionHeroValue mono">${cost}</b></div><div class=currentSessionHeroCompare>${heroScale}${heroCaption?`<span class=readoutCaption>${esc(heroCaption)}</span>`:''}</div></div><div class=currentSessionMetrics><div class="currentSessionMetric metric"><span>Output / $</span><b class=mono>${esc(outputPerDollar)}</b></div><div class="currentSessionMetric metric"><span>Context in use</span><div class=currentSessionContextValue><b class=mono>${esc(context)}</b>${contextSpark.html}</div></div><div class="currentSessionMetric metric"><span>Speed</span><b class=mono>${esc(speed)}</b></div></div>${hintsHtml}</button>${desktopLink}</div>`;
- }).join(''):(filterView.activitySelection==='all'?currentSessionsEmptyHtml(state?.xsession):currentSessionsFilteredEmptyHtml(filterView.activitySelection));
- if(focusedId)requestAnimationFrame(()=>focusCurrentSessionCard(focusedId));
-}
-function keepCurrentSessionFilterFocusVisible(event){
- const button=event.target.closest('button');
- if(button)button.scrollIntoView({block:'nearest',inline:'nearest'});
-}
-const currentSessionRuntimeFilters=$('current-session-runtime-filters');
-currentSessionRuntimeFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);
-currentSessionRuntimeFilters.onclick=event=>{
- const button=event.target.closest('[data-current-runtime-filter]');
- if(!button)return;
- currentSessionRuntimeFilter=button.dataset.currentRuntimeFilter||'all';
- renderCurrentSessions();
-};
-const currentSessionActivityFilters=$('current-session-activity-filters');
-currentSessionActivityFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);
-currentSessionActivityFilters.onclick=event=>{
- const button=event.target.closest('[data-current-activity-filter]');
- if(!button)return;
- currentSessionActivityFilter=button.dataset.currentActivityFilter||'all';
- renderCurrentSessions();
-};
-const currentSessionGrid=$('current-session-grid');
-currentSessionGrid.onclick=event=>{
- if(Date.now()<currentSessionSuppressClickUntil){event.preventDefault();return;}
- const historyAction=event.target.closest('[data-current-empty-history]');
- if(historyAction){openSessionScope('all');return;}
- const card=event.target.closest('[data-current-session-id]');
- if(card)selectSession(card.dataset.currentSessionId);
-};
-currentSessionGrid.addEventListener('dragstart',event=>{
- const card=event.target.closest('[data-current-session-id]');
- if(!card)return;
- currentSessionDragId=card.dataset.currentSessionId;
- card.classList.add('dragging');
- if(event.dataTransfer){
-  event.dataTransfer.effectAllowed='move';
-  event.dataTransfer.setData('text/plain',currentSessionDragId);
- }
-});
-currentSessionGrid.addEventListener('dragover',event=>{
- if(!currentSessionDragId)return;
- const card=event.target.closest('[data-current-session-id]');
- if(!card||card.dataset.currentSessionId===currentSessionDragId){clearCurrentSessionDropMarkers();return;}
- event.preventDefault();
- if(event.dataTransfer)event.dataTransfer.dropEffect='move';
- const rect=card.getBoundingClientRect();
- const columns=getComputedStyle(currentSessionGrid).gridTemplateColumns.trim().split(/\s+/).length;
- const after=columns===1?event.clientY>rect.top+rect.height/2:event.clientX>rect.left+rect.width/2;
- if(currentSessionDropId!==card.dataset.currentSessionId||currentSessionDropAfter!==after){
-  clearCurrentSessionDropMarkers();
-  currentSessionDropId=card.dataset.currentSessionId;
-  currentSessionDropAfter=after;
-  card.classList.add(after?'dropAfter':'dropBefore');
- }
-});
-currentSessionGrid.addEventListener('drop',event=>{
- const card=event.target.closest('[data-current-session-id]');
- if(!currentSessionDragId||!currentSessionDropId||!card||
-    card.dataset.currentSessionId!==currentSessionDropId)return;
- event.preventDefault();
- const result=moveCurrentSessionCard(currentSessionDragId,currentSessionDropId,currentSessionDropAfter);
- if(result)$('current-session-order-status').textContent=currentSessionPositionMessage(currentSessionDragId,result.index,result.total);
- currentSessionSuppressClickUntil=Date.now()+300;
-});
-currentSessionGrid.addEventListener('dragend',event=>{
- event.target.closest('[data-current-session-id]')?.classList.remove('dragging');
- clearCurrentSessionDropMarkers();
- currentSessionDragId='';
- currentSessionSuppressClickUntil=Date.now()+300;
- renderCurrentSessions();
-});
-currentSessionGrid.addEventListener('keydown',event=>{
- if(!event.altKey||event.ctrlKey||event.metaKey||event.shiftKey)return;
- const card=event.target.closest('[data-current-session-id]');
- if(!card)return;
- const columns=Math.max(1,getComputedStyle(currentSessionGrid).gridTemplateColumns.trim().split(/\s+/).length);
- const delta={ArrowLeft:-1,ArrowRight:1,ArrowUp:-columns,ArrowDown:columns}[event.key];
- if(!delta)return;
- event.preventDefault();
- const id=card.dataset.currentSessionId,result=moveCurrentSessionCardBy(id,delta);
- if(!result)return;
- $('current-session-order-status').textContent=currentSessionPositionMessage(id,result.index,result.total);
- renderCurrentSessions();
- requestAnimationFrame(()=>focusCurrentSessionCard(id));
-});
-
-function selectSession(id,{updateUrl=true,replace=false,show=true,returnScope=sessionScope}={}){
- id=String(id||'').trim();
- if(!id)return Promise.resolve();
- sessionReturnScope=normalizeSessionScope(returnScope);
- if(updateUrl&&history.pushState)history[replace?'replaceState':'pushState']({sessionScope:sessionReturnScope,sessionListBack:!replace&&sessionListBackAvailable(sessionReturnScope)},'',sessionRoute(id));
- sessionRequest++;
- pinned=id;
- if(show)applyHashRoute();
- return refreshSelectedSession({show,notifyOnError:true});
-}
-function adoptXsession(holder,state){
- if(state?.xsession_unchanged){
-  if(holder.snapshot&&state.xsession_revision===holder.revision){state.xsession=holder.snapshot;return state;}
-  holder.snapshot=null;holder.revision='';
-  return null;
- }
- holder.snapshot=state?.xsession||null;
- holder.revision=holder.snapshot?String(state?.xsession_revision||''):'';
- return state;
-}
-async function fetchLiveJson(url,holder,label){
- for(let attempt=0;attempt<2;attempt++){
-  const response=await fetch(url+(url.includes('?')?'&':'?')+'xsession='+encodeURIComponent(holder.revision),{cache:'no-store'});
-  if(!response.ok)throw new Error(`${label} request failed (${response.status}).`);
-  const state=adoptXsession(holder,await response.json());
-  if(state)return state;
- }
- throw new Error(`${label} request failed.`);
-}
-async function refreshSelectedSession({show=true,notifyOnError=false}={}){
- const id=pinned,request=sessionRequest;
- if(!id||selectedPollId===id)return null;
- selectedPollId=id;
- try{
-  const state=await fetchLiveJson('/session?id='+encodeURIComponent(id)+'&live=1',LIVE_XSESSION.session,'Session');
-  if(request!==sessionRequest||pinned!==id)return null;
-  if(!state||!stateSessionId(state))throw new Error('Session was not found.');
-  CURRENT=state;
-  if(show&&currentPanel!=='sessions'&&$('view-session').classList.contains('on')){
-   applyHashRoute();
-   renderSession(state);
-  }
-  return state;
- }catch(error){
-  if(request!==sessionRequest||pinned!==id)return null;
-  if(notifyOnError){
-   pinned=null;
-   CURRENT=LATEST;
-   if(routedSessionId()===id&&history.replaceState)history.replaceState(null,'',`/#${sessionScopeRoute(sessionReturnScope)}`);
-   if(show)applyHashRoute();
-   showAppToast({title:'Session could not be opened',body:error.message||String(error),kind:'warn',sticky:true});
-  }
-  return null;
- }finally{
-  if(selectedPollId===id)selectedPollId='';
- }
-}
-function openCurrentSessions({replace=false}={}){
- return openSessionScope('current',{replace});
-}
-function followLatestSession({updateUrl=true,replace=false,show=true,preservePanel=false}={}){
- sessionRequest++; pinned=null; CURRENT=LATEST;sessionReturnScope='current';
- if(updateUrl&&history.pushState){
-  const panel=preservePanel&&PANEL_KEYS.includes(sessionPanel)?sessionPanel:'summary';
-  history[replace?'replaceState':'pushState'](null,'',`/#${panel}`);
- }
- if(show){
-  applyHashRoute();
-  if(LATEST)renderSession(LATEST);
- }
- return LATEST;
-}
-function goToLatestSession(){followLatestSession();}
-
-let statePollBusy=false;
-const LIVE_STATE_POLL_MS=1000;
-const SELECTED_SESSION_POLL_MS=2000;
-// Deep links into Settings: a card can still be hidden (Work insights wait for the server to say they are
-// supported) or move down as cards above it fill in, so the scroll waits for it and settles once.
-function scrollToSettingsCard(id){
- pendingSettingsScroll={id,since:Date.now(),until:Date.now()+60000,top:null,stable:0,timer:0};
- requestAnimationFrame(trySettingsScroll);
-}
-function trySettingsScroll(){
- const pending=pendingSettingsScroll;
- if(!pending)return;
- pending.timer=0;
- if(Date.now()>pending.until||!$('view-settings').classList.contains('on')){pendingSettingsScroll=null;return;}
- const card=$(pending.id);
- if(!card||card.hidden||!card.getClientRects().length)return; // shown later: applyWorkSupport retries
- const top=card.getBoundingClientRect().top;
- if(pending.top!==null&&Math.abs(top-pending.top)<4){
-  if(++pending.stable>=2){pendingSettingsScroll=null;return;} // still for two checks in a row: settled
- }else{
-  pending.stable=0;card.scrollIntoView({block:'start'});
- }
- pending.top=card.getBoundingClientRect().top;
- pending.timer=setTimeout(trySettingsScroll,600);
-}
-// The reader takes over once they scroll or click themselves; the keypress or click that opened the link doesn't count.
-const SETTINGS_SCROLL_KEYS=['ArrowUp','ArrowDown','PageUp','PageDown','Home','End',' '];
-['wheel','touchstart','mousedown','keydown'].forEach(type=>window.addEventListener(type,event=>{
- const pending=pendingSettingsScroll;
- if(!pending||Date.now()-pending.since<300)return;
- if(type==='keydown'&&!SETTINGS_SCROLL_KEYS.includes(event.key))return;
- clearTimeout(pending.timer);pendingSettingsScroll=null;
-},{passive:true}));
-function applyWorkSupport(supported){
- if(typeof supported!=='boolean'||supported===workSupported)return;
- workSupported=supported;
- $('tab-work').hidden=!supported;$('work-insights-settings').hidden=!supported;
- if(supported&&pendingSettingsScroll&&!pendingSettingsScroll.timer)requestAnimationFrame(trySettingsScroll);
- if(!supported&&/^#?(work|sessions-all\?work=)/.test(location.hash.replace(/^#/,'')))location.hash='sessions';
-}
-function applyLiveState(state){
- RUNTIME_CATALOG=state?.runtime_catalog||RUNTIME_CATALOG;
- defaultSessionBudget=Number(state?.xsession?.budgets?.default_session_budget||10);
- adoptFreshDiscounts(state);LATEST=state;
- applyWorkSupport(state?.work_insights_supported);
- renderMenubarSettings(state?.menubar_settings);
- renderCurrentSessions(LATEST);
- const sessionSurfaceActive=$('view-session').classList.contains('on');
- if(!pinned&&sessionSurfaceActive&&currentPanel!=='sessions')renderSession(LATEST);
- if(sessionSurfaceActive&&currentPanel==='sessions'&&sessionScope==='all'){
-  const inventoryStale=!allSessionInventory||allSessionInventoryAt!==Number(LATEST.xsession?.generated_at||0);
-  if(inventoryStale)loadAllSessions();
-  else renderAllSessions(LATEST.xsession);
- }
- if(sessionSurfaceActive&&currentPanel==='sessions'&&sessionScope==='compare'&&compareIds.length&&!compareLoading&&Date.now()-compareLoadedAt>15000)loadComparison({force:true});
- if(sessionSurfaceActive&&currentPanel==='sessions'&&sessionScope==='subagents'){
-  const inventoryStale=!allSessionInventory||allSessionInventoryAt!==Number(LATEST.xsession?.generated_at||0);
-  renderSubagentExplorer(LATEST.xsession?.agent_usage);
-  if(inventoryStale)loadAllSessions();
- }
- if($('view-subagents').classList.contains('on')){
-  const inventoryStale=!allSessionInventory||allSessionInventoryAt!==Number(LATEST.xsession?.generated_at||0);
-  renderSubagentExplorer(LATEST.xsession?.agent_usage);
-  if(inventoryStale)loadAllSessions();
- }
-	 if($('view-models').classList.contains('on'))renderActiveModelStats();
-	 if($('view-daily').classList.contains('on'))renderSpendView(LATEST.xsession);
- if($('view-capabilities').classList.contains('on'))renderCapabilities(LATEST.xsession?.capabilities);
-	 if($('view-efficiency').classList.contains('on'))renderActiveEfficiency();
-	 if(['view-daily','view-efficiency','view-git','view-work'].some(id=>$(id).classList.contains('on'))&&Date.now()-goalsLoadedAt>30000)loadGoals(true);
-	 if($('view-git').classList.contains('on')&&Date.now()-deliveryLastLoadedAt>60000)loadDelivery();
-	 if($('view-work').classList.contains('on')&&Date.now()-workLastLoadedAt>15000)loadWork();
-	 if($('view-settings').classList.contains('on'))renderSettings(LATEST.xsession);
- if($('view-learn').classList.contains('on'))renderLearn(LATEST);
- if($('welcome-dialog').open)renderWelcome(LATEST);
- maybeAutoShowWelcome();
-}
-async function refreshLiveState(){
- if(statePollBusy)return;
- statePollBusy=true;
- try{
-  applyLiveState(await fetchLiveJson('/state',LIVE_XSESSION.state,'State'));
- }catch(error){
-  if($('view-capabilities').classList.contains('on')){
-   if(capabilityLastGoodAt)setCapabilityAvailability('stale');
-   else setCapabilityAvailability('unavailable');
-  }
- }
- finally{statePollBusy=false;}
-}
-setInterval(refreshLiveState,LIVE_STATE_POLL_MS);
-setInterval(()=>refreshSelectedSession({show:true}),SELECTED_SESSION_POLL_MS);
-setInterval(refreshSoftwareUpdateStatus,60000);
-setInterval(tickCacheRings,1000);
-document.addEventListener('visibilitychange',()=>{if(!document.hidden){refreshLiveState();refreshSelectedSession({show:true});}});
-refreshLiveState();
-refreshSoftwareUpdateStatus();
-</script></body></html>
diff --git a/runtime-manifest.txt b/runtime-manifest.txt
index 07b7084c..d42bf020 100644
--- a/runtime-manifest.txt
+++ b/runtime-manifest.txt
@@ -1,7 +1,7 @@
 # Token Meter staged runtime. Paths are relative to the repository root.
 required runtime-manifest.txt
 required meter.py
-required page.html
+required dashboard/page.manifest
 required performance.html
 required token_meter_mcp.py
 required menubar/TokenMeterMenuBar.swift
@@ -25,4 +25,5 @@ python-tree token_meter
 tree menubar
 tree scripts
 tree assets
+tree dashboard
 tree agent-skills
diff --git a/scripts/check-page b/scripts/check-page
new file mode 100755
index 00000000..a033ddf5
--- /dev/null
+++ b/scripts/check-page
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Assemble the dashboard from dashboard/ parts and parse its inline JavaScript.
+# Prints one line on success; on failure prints Node's parse error.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+page="$(mktemp "${TMPDIR:-/tmp}/token-meter-page.XXXXXX")"
+trap 'rm -f "$page"' EXIT
+
+PYTHONPATH="$ROOT" python3 -m token_meter.dashboard_page "$page"
+node -e "const fs=require('fs');const h=fs.readFileSync(process.argv[1],'utf8');const m=h.match(/<script>([\s\S]*)<\/script>/);new Function(m[1]);console.log('js ok')" "$page"
diff --git a/scripts/install-windows.ps1 b/scripts/install-windows.ps1
index 7c0cdd62..ec395ffe 100644
--- a/scripts/install-windows.ps1
+++ b/scripts/install-windows.ps1
@@ -327,7 +327,8 @@ if (Test-Path -LiteralPath $InstallRoot -PathType Container) {
     $ExistingEntries = @(Get-ChildItem -LiteralPath $InstallRoot -Force)
     $RecognizedRuntime = (
         (Test-Path -LiteralPath (Join-Path $InstallRoot "meter.py") -PathType Leaf) -and
-        (Test-Path -LiteralPath (Join-Path $InstallRoot "page.html") -PathType Leaf) -and
+        ((Test-Path -LiteralPath (Join-Path $InstallRoot "dashboard\page.manifest") -PathType Leaf) -or
+         (Test-Path -LiteralPath (Join-Path $InstallRoot "page.html") -PathType Leaf)) -and
         (Test-Path -LiteralPath (Join-Path $InstallRoot "scripts\start-token-meter.ps1") -PathType Leaf)
     )
     if ($ExistingEntries.Count -gt 0 -and -not $RecognizedRuntime) {
diff --git a/scripts/split-dashboard b/scripts/split-dashboard
new file mode 100755
index 00000000..a8edc45b
--- /dev/null
+++ b/scripts/split-dashboard
@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Split a single-file page.html into dashboard/ parts.
+
+One-off migration tool. Branches that still edit the old single-file
+page.html can run it on their own copy, then port their change into the
+matching part:
+
+    python3 scripts/split-dashboard path/to/page.html path/to/dashboard
+
+Each part starts at a unique anchor line. Comment lines directly above an
+anchor move with it. The tool writes dashboard/page.manifest and refuses to
+finish unless the parts concatenate back to the input byte for byte.
+"""
+
+import os
+import sys
+
+# (part, (anchor line prefix, line offset)); the first part starts at line 1.
+PARTS = [
+    ("head.html", None),
+    ("styles/base.css", ("<style>", 1)),
+    ("styles/themes.css", ("/* == Themes:", 0)),
+    ("styles/components.css", ("/* == Components:", 0)),
+    ("styles/shell.css", ("/* shared-spectrum-system-v1 */", 0)),
+    ("styles/motion-sessions.css", ("/* spectrum-motion-v1:", 0)),
+    ("styles/tools.css", ("/* tools-review-workflow-v3 */", 0)),
+    ("styles/git.css", ("/* git-delivery-economics-v1 */", 0)),
+    ("styles/sessions-subagents.css", ("/* sessions-agent-observability-v1 */", 0)),
+    ("styles/models-learn.css", ("/* models-leaderboard-v1 */", 0)),
+    ("markup/shell.html", ("</style></head>", 0)),
+    ("markup/subagents-models.html", ("\t <div class=view id=view-subagents>", 0)),
+    ("markup/spend.html", ("\t <div class=view id=view-daily>", 0)),
+    ("markup/efficiency-work.html", ("\t <div class=view id=view-efficiency>", 0)),
+    ("markup/git-learn-tools.html", ("\t <div class=view id=view-git>", 0)),
+    ("markup/settings.html", ("\t <div class=view id=view-settings>", 0)),
+    ("js/core.js", ("<script>", 1)),
+    ("js/deck.js", ("// deck-pure-start", 0)),
+    ("js/theme-navigation.js", ("const THEMES=[", 0)),
+    ("js/goals.js", ("let GOALS=null", 0)),
+    ("js/router.js", ("function applyHashRoute(){", 0)),
+    ("js/notifications-settings.js", ("const canNotify=('Notification' in window);", 0)),
+    ("js/budgets-discounts.js", ("const DEFAULT_RUNTIME_BUDGET=", 0)),
+    ("js/agent-access.js", ("function budgetAllocationsFromInputs(){", 0)),
+    ("js/session-budgets-filters.js", ("// A subagent run spends against its root session's cap", 0)),
+    ("js/charts.js", ("const cssVar=name=>", 0)),
+    ("js/session-detail.js", ("function setCapabilityStatBar(", 0)),
+    ("js/capabilities.js", ("const CAPABILITY_SORT_KEYS=", 0)),
+    ("js/spend.js", ("function localDayKey(", 0)),
+    ("js/motion-readouts.js", ("// Pixel-viewBox charts redraw", 0)),
+    ("js/git.js", ("function deliveryProjectName(", 0)),
+    ("js/work-status.js", ("function renderWorkTags(", 0)),
+    ("js/work-insights.js", ("function workFlagReason(", 0)),
+    ("js/efficiency.js", ("const MODEL_COUNTER_KEYS=", 0)),
+    ("js/models.js", ("function filledModelDays(", 0)),
+    ("js/session-logs-compare.js", ("function capabilityCounts(", 0)),
+    ("js/subagents.js", ("function mergeAllSessionInventory(", 0)),
+    ("js/subagents-explorer.js", ("function subagentGroupHtml(", 0)),
+    ("js/all-sessions.js", ("function allSessionsView(", 0)),
+    ("js/current-sessions.js", ("const CACHE_RING_TICKS=", 0)),
+    ("js/live.js", ("function selectSession(", 0)),
+    ("tail.html", ("</script></body></html>", 0)),
+]
+
+MANIFEST_HEADER = """\
+# Dashboard page parts, in serving order. The server concatenates these files
+# byte for byte into the single page it serves; see token_meter/dashboard_page.py.
+# Paths are relative to this directory.
+"""
+
+
+def cut_points(lines):
+    starts = []
+    for name, anchor in PARTS:
+        if anchor is None:
+            starts.append(0)
+            continue
+        prefix, offset = anchor
+        matches = [index for index, line in enumerate(lines) if line.startswith(prefix)]
+        if len(matches) != 1:
+            raise SystemExit(f"{name}: anchor {prefix!r} matched {len(matches)} lines; expected 1")
+        start = matches[0] + offset
+        if offset == 0:
+            while start > 0 and lines[start - 1].lstrip().startswith("//"):
+                start -= 1
+        if start <= starts[-1]:
+            raise SystemExit(f"{name}: anchor is not after the previous part")
+        starts.append(start)
+    return starts
+
+
+def split(page_path, out_dir):
+    with open(page_path, encoding="utf-8", newline="") as handle:
+        original = handle.read()
+    lines = original.splitlines(keepends=True)
+    starts = cut_points(lines)
+    ends = starts[1:] + [len(lines)]
+    for (name, _), start, end in zip(PARTS, starts, ends):
+        path = os.path.join(out_dir, *name.split("/"))
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8", newline="") as handle:
+            handle.write("".join(lines[start:end]))
+    with open(os.path.join(out_dir, "page.manifest"), "w", encoding="utf-8") as handle:
+        handle.write(MANIFEST_HEADER + "".join(f"{name}\n" for name, _ in PARTS))
+    rebuilt = "".join(
+        open(os.path.join(out_dir, *name.split("/")), encoding="utf-8", newline="").read()
+        for name, _ in PARTS
+    )
+    if rebuilt != original:
+        raise SystemExit("parts do not reassemble to the input page")
+    for (name, _), start, end in zip(PARTS, starts, ends):
+        size = len("".join(lines[start:end]).encode("utf-8"))
+        print(f"{size:>8}  {name}")
+
+
+def main(argv):
+    if len(argv) != 3:
+        raise SystemExit(__doc__)
+    split(argv[1], argv[2])
+
+
+if __name__ == "__main__":
+    main(sys.argv)
diff --git a/scripts/start-token-meter b/scripts/start-token-meter
index 92c10e30..a556987c 100755
--- a/scripts/start-token-meter
+++ b/scripts/start-token-meter
@@ -7,9 +7,9 @@ HEALTH_URL="http://127.0.0.1:8722/health"
 LOG="$ROOT/meter.log"
 READINESS_TIMEOUT_SECONDS="${TOKEN_METER_READINESS_TIMEOUT_SECONDS:-600}"
 
-if [[ ! -f "$ROOT/page.html" ]]; then
-  echo "Missing dashboard UI: $ROOT/page.html" >&2
-  echo "Run from a full token-meter clone, or copy page.html next to meter.py." >&2
+if [[ ! -f "$ROOT/dashboard/page.manifest" ]]; then
+  echo "Missing dashboard UI: $ROOT/dashboard/page.manifest" >&2
+  echo "Run from a full token-meter clone that includes the dashboard folder." >&2
   exit 1
 fi
 
@@ -19,8 +19,8 @@ if [[ ! "$READINESS_TIMEOUT_SECONDS" =~ ^[0-9]+$ || "$READINESS_TIMEOUT_SECONDS"
 fi
 
 page_body="$(curl -s --max-time 2 "$ROOT_URL" 2>/dev/null || true)"
-if [[ "$page_body" == *"page.html not found next to meter.py"* || "$page_body" == *"page.html is missing"* ]]; then
-  echo "A stale Token Meter server is already running without page.html." >&2
+if [[ "$page_body" == *"page.html not found next to meter.py"* || "$page_body" == *"page.html is missing"* || "$page_body" == *"The dashboard files are missing"* ]]; then
+  echo "A stale Token Meter server is already running without its dashboard files." >&2
   echo "Stop the listener on port 8722, then rerun: $ROOT/scripts/start-token-meter" >&2
   echo "Find it with: lsof -nP -iTCP:8722 -sTCP:LISTEN" >&2
   echo "Then stop that PID with: kill <PID>" >&2
diff --git a/scripts/style-snapshot.js b/scripts/style-snapshot.js
index a30bd017..6aa74b87 100644
--- a/scripts/style-snapshot.js
+++ b/scripts/style-snapshot.js
@@ -1,4 +1,4 @@
-// Computed-style regression harness for page.html. Paste into the browser
+// Computed-style regression harness for the dashboard page. Paste into the browser
 // console (or a preview eval) on a running dashboard:
 //   await __tmStyle.capture('base')        -> stores a snapshot in localStorage
 //   await __tmStyle.diff('base')           -> compares the current page to it
diff --git a/specs/AGENTS.md b/specs/AGENTS.md
index 0268cd30..a643e3b0 100644
--- a/specs/AGENTS.md
+++ b/specs/AGENTS.md
@@ -22,7 +22,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `token_meter/domain/` | Runtime-neutral usage, timing, tools, insights, and aggregates |
 | `token_meter/domain/compare.py` | Content-free session comparison, cheapest/fastest picks, and same-title matching |
 | `token_meter/projections.py` | Explicit allowlisted public compatibility projections |
-| `page.html` | Entire browser dashboard: markup, styles, routing, and JavaScript |
+| `dashboard/` | Browser dashboard source, one file per view: `styles/*.css`, `markup/*.html`, `js/*.js`. `page.manifest` lists the serving order; the server concatenates the parts into one page. Read the one part you need, not the assembled page |
 | `specs/DESIGN.md` | Visual system: tokens, provider identity, components, readability floor, contract |
 | `tests/contracts/test_design_system.py` | Design-system contract: tokens, scales, contrast, components, dead CSS, provider colors |
 | `scripts/style-snapshot.js` | Browser computed-style before/after diff for stylesheet-wide changes |
@@ -55,7 +55,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `python3 scripts/run-tests` | Run the same suite across one worker per CPU (`-j N` to limit, `-v` for per-test times) |
 | `python3 -m unittest tests.contracts.test_design_system -v` | Check dashboard styling against the design-system contract |
 | `PYTHONPYCACHEPREFIX=/private/tmp/token-meter-pycache python3 -m py_compile meter.py token_meter_mcp.py $(find token_meter -type f -name '*.py' -print)` | Compile Python without polluting the repo |
-| `node -e "const fs=require('fs');const h=fs.readFileSync('page.html','utf8');const m=h.match(/<script>([\\s\\S]*)<\\/script>/);new Function(m[1]);console.log('js ok')"` | Parse embedded dashboard JavaScript |
+| `scripts/check-page` | Assemble the dashboard and parse its JavaScript |
 | `bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux scripts/setup-work-classifier` | Check shell syntax |
 | `swiftc menubar/TokenMeterMenuBar.swift -o /private/tmp/token-meter-menubar` | Compile the native companion |
 | `TOKEN_METER_MENUBAR_SMOKE=1 /private/tmp/token-meter-menubar` | Run deterministic native smoke output |
diff --git a/specs/ARCHITECTURE.md b/specs/ARCHITECTURE.md
index cc6fd5a3..8c0e1a34 100644
--- a/specs/ARCHITECTURE.md
+++ b/specs/ARCHITECTURE.md
@@ -50,7 +50,7 @@ executable and import-compatibility facade; current composition lives in
 | Goals | `token_meter/services/goals.py`, `token_meter/models/tiers.py` | Validate local metric goals and measure them deterministically from complete scoped rows and explicit Git windows; the browser and menu bar render these results and never recompute them. See [Goals](GOALS.md). |
 | Public projections | `token_meter/projections.py` | Allowlist fields for session, state, model, browser-only agent, menu-bar, and MCP consumers. |
 | MCP query layer | `token_meter/mcp/` | Validate filters, bind opaque cursors to query revisions, positively allowlist standardized and native-structure fields, aggregate metrics, and publish schema metadata. |
-| HTTP transport | `token_meter/web/`, `page.html` | Serve the loopback API, routes, actions, and the single-file dashboard. |
+| HTTP transport | `token_meter/web/`, `token_meter/dashboard_page.py`, `dashboard/` | Serve the loopback API, routes, actions, and the dashboard page assembled in order from `dashboard/page.manifest`. |
 | Native clients | `menubar/`, Windows scripts | Render the compact `/menubar` payload and delegate deep review to the browser. |
 | Local MCP | `token_meter_mcp.py` | Return bounded current-run or aggregate evidence over stdio, plus explicitly confirmed session-budget updates. |
 | Packaging | `runtime-manifest.txt`, `token_meter/packaging.py`, `scripts/` | Stage one manifest-owned runtime and install platform-native lifecycle components. |
@@ -338,7 +338,7 @@ place would serve stale cached JSON; rebuild a new snapshot instead.
 `token_meter/domain/compare.py`: an allowlisted, content-free record per trace
 (no paths, prompts, or per-execution text), best-per-metric markers, rule-based
 insights, and other sessions whose public title matches. Selection uses an
-opaque per-trace key (a hash of the trace path, mirrored in `page.html`,
+opaque per-trace key (a hash of the trace path, mirrored in the dashboard script,
 falling back to the session id) because forked and spawned threads can share a
 session id and some runtimes reuse one file name per session directory; All
 sessions rows use the same key for DOM identity. Each compared trace also
@@ -456,7 +456,7 @@ allowlisted fields or discovered canonical identifiers.
 ## Client Interfaces
 
 The browser polls live state and renders all top-level review surfaces from
-`page.html`. Dashboard order is `Sessions → Spend → Models → Subagents → Efficiency → Work → Git →
+`dashboard/`. Dashboard order is `Sessions → Spend → Models → Subagents → Efficiency → Work → Git →
 Learn → Tools → Settings`; the top-level Subagents page owns Roles, while Sessions owns
 Current, All, and Subagents investigation (child-run Sessions and Issues). Efficiency derives
 mechanical token-efficiency ratios and daily trends from the same runtime-scoped
@@ -820,7 +820,7 @@ separately approved.
 
 ### Add or restyle a dashboard surface
 
-Expected changes are confined to `page.html`:
+Expected changes are confined to `dashboard/`:
 
 - markup and rules that reference the stylesheet's opening `:root` tokens
 - chart series in the script's `THEME` constant
diff --git a/specs/CONTRIBUTING.md b/specs/CONTRIBUTING.md
index 0e95e25c..734864a6 100644
--- a/specs/CONTRIBUTING.md
+++ b/specs/CONTRIBUTING.md
@@ -132,7 +132,7 @@ The authoritative ownership and data-flow explanation is
 | `token_meter/platforms/` | Host paths, processes, updates, launchers, and trash policy |
 | `token_meter/services/` | Application orchestration and public client services |
 | `token_meter/telemetry/` | Pure privacy projection and OTel-shaped mapping only |
-| `page.html` | Browser dashboard |
+| `dashboard/` | Browser dashboard source parts, assembled in `page.manifest` order |
 | `menubar/TokenMeterMenuBar.swift` | Native macOS menu bar companion |
 | `menubar/token_meter_tray.py` | Native Linux AppIndicator companion |
 | `scripts/run-tray.ps1` | Native Windows NotifyIcon companion |
@@ -273,7 +273,7 @@ Run these checks from the repository root before opening a pull request:
 PYTHONPYCACHEPREFIX=/tmp/token-meter-pycache python3 -m py_compile meter.py token_meter_mcp.py $(find token_meter -type f -name '*.py' -print | LC_ALL=C sort)
 python3 scripts/run-tests   # parallel; python3 -m unittest discover -s tests -v runs it serially
 bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux
-node -e "const fs=require('fs'); const html=fs.readFileSync('page.html','utf8'); const m=html.match(/<script>([\\s\\S]*)<\\/script>/); new Function(m[1]); console.log('js ok')"
+scripts/check-page
 git diff --check
 ```
 
diff --git a/specs/DESIGN.md b/specs/DESIGN.md
index da37e564..5dd7abee 100644
--- a/specs/DESIGN.md
+++ b/specs/DESIGN.md
@@ -386,7 +386,7 @@ The detail-side instrument pairs live state and estimated cost with context pres
 ## Tokens and Contract
 
 Every value above is a token in the single `:root` block that opens the
-`page.html` stylesheet. Rules reference tokens for color, type, weight,
+dashboard stylesheet (`dashboard/styles/`). Rules reference tokens for color, type, weight,
 radius, and focus. Spacing uses literal values from the documented scale.
 A ratcheted count of legacy translucent literals may only shrink.
 `tests/contracts/test_design_system.py` enforces this contract, so drift fails CI.
diff --git a/tests/contracts/test_design_system.py b/tests/contracts/test_design_system.py
index 71695300..bfdc5ffd 100644
--- a/tests/contracts/test_design_system.py
+++ b/tests/contracts/test_design_system.py
@@ -1,4 +1,4 @@
-"""Design-system contract for the dashboard stylesheet in page.html."""
+"""Design-system contract for the dashboard stylesheet (dashboard/ parts, assembled)."""
 
 import itertools
 import json
@@ -12,8 +12,9 @@
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
 from token_meter.domain.usage import format_usd  # noqa: E402
+from tests.dashboard_page import DASHBOARD_PAGE
 
-PAGE = (Path(__file__).resolve().parents[2] / "page.html").read_text()
+PAGE = (Path(DASHBOARD_PAGE)).read_text()
 CSS = PAGE[PAGE.index("<style>") + len("<style>"):PAGE.index("</style>")]
 JS = PAGE[PAGE.index("<script>") + len("<script>"):PAGE.rindex("</script>")]
 EFFECTS = (Path(__file__).resolve().parents[2] / "assets" / "session-effects.js").read_text()
diff --git a/tests/contracts/test_kiro_extension_budget.py b/tests/contracts/test_kiro_extension_budget.py
index f983c5f0..b9e65988 100644
--- a/tests/contracts/test_kiro_extension_budget.py
+++ b/tests/contracts/test_kiro_extension_budget.py
@@ -3,6 +3,7 @@
 from pathlib import Path
 
 import meter
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 ROOT = Path(__file__).resolve().parents[2]
@@ -14,7 +15,7 @@ def test_shared_domain_platform_http_and_generic_clients_need_no_kiro_branch(sel
             *(ROOT / "token_meter" / "domain").glob("*.py"),
             *(ROOT / "token_meter" / "platforms").glob("*.py"),
             ROOT / "token_meter" / "web" / "server.py",
-            ROOT / "page.html",
+            Path(DASHBOARD_PAGE),
             ROOT / "menubar" / "TokenMeterMenuBar.swift",
             ROOT / "menubar" / "token_meter_tray.py",
         ]
diff --git a/tests/contracts/test_runtime_catalog.py b/tests/contracts/test_runtime_catalog.py
index 170dc035..9193b15b 100644
--- a/tests/contracts/test_runtime_catalog.py
+++ b/tests/contracts/test_runtime_catalog.py
@@ -8,6 +8,7 @@
 from token_meter.services.runtime_catalog import runtime_catalog
 from token_meter.runtimes.registry import RuntimeRegistry
 from tests.integration.test_application_composition import SyntheticAdapter
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 def descriptor(runtime_id="synthetic", label="Synthetic",
@@ -71,7 +72,7 @@ class CatalogAwareClientSourceTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.root = Path(__file__).resolve().parents[2]
-        cls.page = (cls.root / "page.html").read_text()
+        cls.page = (Path(DASHBOARD_PAGE)).read_text()
         cls.swift = (cls.root / "menubar" / "TokenMeterMenuBar.swift").read_text()
         cls.tray = (cls.root / "menubar" / "token_meter_tray.py").read_text()
 
diff --git a/tests/contracts/test_source_size_budget.py b/tests/contracts/test_source_size_budget.py
index dfbc99a4..46705b7f 100644
--- a/tests/contracts/test_source_size_budget.py
+++ b/tests/contracts/test_source_size_budget.py
@@ -21,7 +21,6 @@
 # so normal maintenance still fits. This dict may only shrink.
 LEGACY_CEILINGS = {
     "tests/test_meter.py": 1_500_000,
-    "page.html": 1_325_000,
     "token_meter/app.py": 663_000,
     "tests/test_work_insights.py": 236_000,
     "menubar/TokenMeterMenuBar.swift": 148_000,
diff --git a/tests/dashboard_page.py b/tests/dashboard_page.py
new file mode 100644
index 00000000..56dde2f8
--- /dev/null
+++ b/tests/dashboard_page.py
@@ -0,0 +1,37 @@
+"""The assembled dashboard page, for tests that read or execute page source.
+
+The dashboard source lives in ``dashboard/`` parts. Tests that assert on the
+served page, or extract functions from it in Node, read this one assembled
+copy, so they see exactly what the server sends.
+"""
+
+import atexit
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from token_meter import dashboard_page  # noqa: E402
+
+DASHBOARD_MANIFEST = dashboard_page.manifest_path(str(ROOT))
+
+
+def page_text():
+    return dashboard_page.assemble(DASHBOARD_MANIFEST)
+
+
+def _write_assembled_page():
+    directory = tempfile.mkdtemp(prefix="token-meter-page-")
+    atexit.register(shutil.rmtree, directory, True)
+    path = os.path.join(directory, "page.html")
+    with open(path, "w", encoding="utf-8", newline="") as handle:
+        handle.write(page_text())
+    return path
+
+
+DASHBOARD_PAGE = _write_assembled_page()
diff --git a/tests/integration/test_model_pricing_compat.py b/tests/integration/test_model_pricing_compat.py
index 6c5dbe1e..8a289875 100644
--- a/tests/integration/test_model_pricing_compat.py
+++ b/tests/integration/test_model_pricing_compat.py
@@ -11,6 +11,7 @@
     GPT_56_SOL_PRICE_UPDATE_AT,
     settings_provider_for_model_provider,
 )
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 class ModelPricingCacheTests(unittest.TestCase):
@@ -92,7 +93,7 @@ def test_google_prices_are_listed_and_editable_in_settings(self):
         self.assertIn("gemini-2.5-pro", stored["model_pricing"]["google"])
         self.assertEqual(quote.input_per_million, 3.0)
         self.assertEqual(quote.output_per_million, 11.0)
-        page = (Path(meter.__file__).resolve().parent / "page.html").read_text()
+        page = (Path(DASHBOARD_PAGE)).read_text()
         self.assertIn("<option value=google>Google Gemini</option>", page)
 
     def _quote(self, path, provider, model, at):
diff --git a/tests/test_agent_skills.py b/tests/test_agent_skills.py
index 6aba580f..cd7aebc9 100644
--- a/tests/test_agent_skills.py
+++ b/tests/test_agent_skills.py
@@ -11,6 +11,7 @@
 import meter
 from token_meter import packaging
 from token_meter.services import agent_skills
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 REPO = Path(__file__).resolve().parents[1]
@@ -297,7 +298,7 @@ def test_package_ships_in_the_staged_runtime(self):
         self.assertIn(f"agent-skills/{SKILL}/SKILL.md", files)
 
     def test_dashboard_has_a_separate_skills_button(self):
-        page = (REPO / "page.html").read_text(encoding="utf-8")
+        page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
         for marker in ("data-agent-skills", "/agent-skills/toggle", "Token Meter skills",
                        "function openAgentSkillsDialog", "agentClientActions",
                        "https://github.com/splunk/token-meter/blob/main/agent-skills/README.md"):
diff --git a/tests/test_cache_countdown.py b/tests/test_cache_countdown.py
index c72bada0..5a487823 100644
--- a/tests/test_cache_countdown.py
+++ b/tests/test_cache_countdown.py
@@ -6,6 +6,7 @@
 from unittest import mock
 
 import meter
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 def source(provider, model=None):
@@ -291,7 +292,7 @@ def test_post_route_is_allowlisted_and_action_token_guarded(self):
 class SurfaceContractTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = (ROOT / "page.html").read_text()
+        cls.page = (Path(DASHBOARD_PAGE)).read_text()
         cls.swift = (ROOT / "menubar" / "TokenMeterMenuBar.swift").read_text()
 
     def test_session_card_renders_the_ring_before_status_and_ticks_locally(self):
diff --git a/tests/test_claude_cost_correctness.py b/tests/test_claude_cost_correctness.py
index 4cd001c2..307bcd10 100644
--- a/tests/test_claude_cost_correctness.py
+++ b/tests/test_claude_cost_correctness.py
@@ -26,6 +26,7 @@
 from token_meter.mcp.schema import METRICS
 from token_meter.projections import projection_bundle
 from token_meter.runtimes.claude import ClaudeRuntimeAdapter, _normalized_usage
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 def claude_usage(
@@ -318,7 +319,7 @@ def test_unsupported_model_billing_dimension_is_unavailable_in_summary(self):
         self.assertTrue(summary["cost_approx"])
 
     def test_dashboard_cost_breakdown_displays_server_tool_charge(self):
-        dashboard = Path(meter.__file__).with_name("page.html").read_text()
+        dashboard = Path(DASHBOARD_PAGE).read_text()
 
         self.assertIn("cost.server_tools", dashboard)
         self.assertIn("$0.01 / request", dashboard)
diff --git a/tests/test_codex_model_identity.py b/tests/test_codex_model_identity.py
index e728bc2d..d2502761 100644
--- a/tests/test_codex_model_identity.py
+++ b/tests/test_codex_model_identity.py
@@ -7,6 +7,7 @@
 from unittest import mock
 
 import meter
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 class CodexModelIdentityTests(unittest.TestCase):
@@ -418,7 +419,7 @@ def test_public_projection_drops_untrusted_hint_fields(self):
 class CodexModelIdentityDashboardContractTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = (Path(__file__).resolve().parents[1] / "page.html").read_text(
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(
             encoding="utf-8"
         )
 
diff --git a/tests/test_dashboard_page.py b/tests/test_dashboard_page.py
new file mode 100644
index 00000000..33a99bd5
--- /dev/null
+++ b/tests/test_dashboard_page.py
@@ -0,0 +1,108 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+import meter
+from token_meter import dashboard_page
+from tests.dashboard_page import DASHBOARD_MANIFEST, ROOT
+
+
+def write_parts(root, parts, manifest_lines=None):
+    base = Path(root, "dashboard")
+    for name, text in parts.items():
+        path = base / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+    lines = manifest_lines if manifest_lines is not None else list(parts)
+    (base / "page.manifest").write_text("# comment\n\n" + "\n".join(lines) + "\n", encoding="utf-8")
+    return str(base / "page.manifest")
+
+
+class DashboardAssemblyTests(unittest.TestCase):
+    def test_parts_concatenate_in_manifest_order_byte_for_byte(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = write_parts(tmp, {"b.html": "<b>\r\n", "a/one.js": "x=1;\n"},
+                                   ["b.html", "a/one.js"])
+            self.assertEqual(dashboard_page.assemble(manifest), "<b>\r\nx=1;\n")
+
+    def test_assembly_refreshes_when_a_part_changes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = write_parts(tmp, {"a.html": "one"})
+            self.assertEqual(dashboard_page.assemble(manifest), "one")
+            part = Path(tmp, "dashboard", "a.html")
+            part.write_text("two!", encoding="utf-8")
+            os.utime(part, ns=(1, 1))
+            self.assertEqual(dashboard_page.assemble(manifest), "two!")
+
+    def test_manifest_rejects_paths_outside_the_dashboard_folder(self):
+        for entry in ("../meter.py", "/etc/passwd", "a/../../x", "a\\b.js", "./a.js"):
+            with self.subTest(entry=entry), tempfile.TemporaryDirectory() as tmp:
+                manifest = write_parts(tmp, {"a.html": "x"}, [entry])
+                with self.assertRaises(ValueError):
+                    dashboard_page.assemble(manifest)
+
+    def test_manifest_rejects_duplicate_and_empty_part_lists(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(ValueError):
+                dashboard_page.assemble(write_parts(tmp, {"a.html": "x"}, ["a.html", "a.html"]))
+            with self.assertRaises(ValueError):
+                dashboard_page.assemble(write_parts(tmp, {"a.html": "x"}, []))
+
+    def test_repository_manifest_lists_every_dashboard_part_exactly_once(self):
+        base = Path(ROOT, "dashboard")
+        listed = dashboard_page.part_names(DASHBOARD_MANIFEST)
+        on_disk = sorted(
+            path.relative_to(base).as_posix()
+            for path in base.rglob("*")
+            if path.is_file() and path.name != "page.manifest"
+        )
+        self.assertEqual(sorted(listed), on_disk)
+
+    def test_assembled_page_is_one_document_with_one_inline_script(self):
+        page = dashboard_page.assemble(DASHBOARD_MANIFEST)
+        self.assertTrue(page.startswith("<!doctype html>"))
+        self.assertTrue(page.endswith("</script></body></html>\n"))
+        self.assertEqual(page.count("\n<script>\n"), 1)
+        self.assertEqual(page.count("<style>\n"), 1)
+
+
+class DashboardServingTests(unittest.TestCase):
+    def test_server_looks_for_the_dashboard_manifest_beside_the_source(self):
+        with mock.patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("TOKEN_METER_PAGE", None)
+            candidates = meter.page_candidates()
+        self.assertEqual(candidates[0], dashboard_page.manifest_path(meter._SOURCE_ROOT))
+        self.assertNotIn("page.html", " ".join(candidates))
+
+    def test_page_bytes_assemble_a_manifest_and_read_an_explicit_page(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = write_parts(tmp, {"a.html": "<p>", "b.js": "1"})
+            self.assertEqual(meter.page_bytes(manifest), b"<p>1")
+            self.assertEqual(meter.page_root(manifest), os.path.abspath(tmp))
+            single = Path(tmp, "page.html")
+            single.write_text("single", encoding="utf-8")
+            self.assertEqual(meter.page_bytes(str(single)), b"single")
+            self.assertEqual(meter.page_root(str(single)), tmp)
+
+    def test_missing_part_serves_the_setup_error_instead_of_a_partial_page(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = write_parts(tmp, {"a.html": "x"}, ["a.html", "gone.js"])
+            self.assertIsNone(meter.page_bytes(manifest))
+
+    def test_bundled_assets_resolve_beside_the_dashboard_folder(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = write_parts(tmp, {"a.html": "x"})
+            font = Path(tmp, "assets", "fonts", "Tektur-Variable.ttf")
+            font.parent.mkdir(parents=True)
+            font.write_bytes(b"font")
+            with mock.patch.object(meter, "page_path", return_value=manifest):
+                self.assertEqual(
+                    meter.dashboard_asset_path("/assets/fonts/Tektur-Variable.ttf"),
+                    str(font),
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_git_delivery.py b/tests/test_git_delivery.py
index 13f7d500..87fa3434 100644
--- a/tests/test_git_delivery.py
+++ b/tests/test_git_delivery.py
@@ -15,6 +15,7 @@
 
 import meter
 from token_meter.services import git_delivery
+from tests.dashboard_page import DASHBOARD_PAGE
 
 _DASHBOARD_HELPERS = (
     r"^const f=n=>.*$",
@@ -1766,7 +1767,7 @@ def test_clear_requires_action_token_and_explicit_confirmation(self):
 class GitDashboardContractTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = Path(meter._SOURCE_ROOT, "page.html").read_text(encoding="utf-8")
+        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
 
     def test_git_is_a_dedicated_answer_first_page(self):
         git_page = self.page.split("id=view-git", 1)[1].split("id=view-learn", 1)[0]
@@ -1800,7 +1801,7 @@ def test_git_is_a_dedicated_answer_first_page(self):
         self.assertIn('<div class="modelControls deliveryControls">', git_page)
         self.assertIn(
             ".modelControls.deliveryControls{grid-template-columns:minmax(150px,210px) minmax(130px,160px)}",
-            Path(meter.__file__).with_name("page.html").read_text(encoding="utf-8"),
+            Path(DASHBOARD_PAGE).read_text(encoding="utf-8"),
         )
         git_range = git_page.split('id=d-range aria-label="Git history range">', 1)[1].split("</select>", 1)[0]
         self.assertNotIn("<option value=all>", git_range)
@@ -2032,7 +2033,7 @@ def test_git_is_the_canonical_name_and_delivery_hash_is_compatible(self):
 class GitDeliveryEconomicsContractTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = Path(meter._SOURCE_ROOT, "page.html").read_text(encoding="utf-8")
+        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
 
     def git_view(self):
         return self.page.split("id=view-git", 1)[1].split("id=view-learn", 1)[0]
diff --git a/tests/test_goals.py b/tests/test_goals.py
index 2c59a4b8..55f756ce 100644
--- a/tests/test_goals.py
+++ b/tests/test_goals.py
@@ -11,6 +11,7 @@
 import meter
 from token_meter.services import goal_coaching, goals
 from token_meter.services.git_delivery import GitDeliveryService
+from tests.dashboard_page import DASHBOARD_PAGE
 
 AGENTS = {"claude": "Claude", "codex": "Codex"}
 TODAY = datetime.date(2026, 10, 15)
@@ -837,7 +838,7 @@ def test_goals_route_forwards_preview_fields_and_requires_action_token(self):
 
     def test_dashboard_native_and_tray_sources_expose_goals(self):
         root = Path(meter.__file__).parent
-        page = (root / "page.html").read_text()
+        page = Path(DASHBOARD_PAGE).read_text()
         swift = (root / "menubar" / "TokenMeterMenuBar.swift").read_text()
         tray = (root / "menubar" / "token_meter_tray.py").read_text()
         for marker in ("id=efficiency-goals", "if(h==='goals')setHashRoute('efficiency-goals'",
diff --git a/tests/test_meter.py b/tests/test_meter.py
index 619ceecd..a842d6ed 100644
--- a/tests/test_meter.py
+++ b/tests/test_meter.py
@@ -23,6 +23,7 @@
 from token_meter.runtimes.codex import CodexRuntimeAdapter
 from token_meter.runtimes import pi as pi_runtime
 from token_meter.services import git_delivery as git_delivery_service_module
+from tests.dashboard_page import DASHBOARD_PAGE
 
 
 class _TrackingSqliteConnection:
@@ -7478,7 +7479,7 @@ def summary(source):
 class DashboardLayoutTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = Path(meter.__file__).with_name("page.html").read_text()
+        cls.page = Path(DASHBOARD_PAGE).read_text()
         cls.session_effects = (
             Path(meter.__file__).with_name("assets") / "session-effects.js"
         ).read_text()
@@ -7535,7 +7536,7 @@ def test_agent_activity_work_time_header_aligns_with_right_aligned_values(self):
     def test_subagent_explorer_prefers_roles_and_filters_status_and_signals(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('agentIdentityPresentation'));
 eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
@@ -7580,7 +7581,7 @@ def test_subagent_explorer_prefers_roles_and_filters_status_and_signals(self):
     def test_last_month_time_filter_bounds_sessions_subagents_and_role_days(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'';
 eval(['timeFilterBounds','agentIdentityPresentation','filterSubagentInventory','childRootId','localDateKey','dateKeyAgo','calendarMonthWindow','monthToDateWindow','modelRangeWindow','subagentRoleKey','subagentRoleDayRows','subagentModelKey','subagentModelDayRows','normalizedSubagentNavigationState'].map(extract).join('\\n'));
@@ -7629,7 +7630,7 @@ def test_last_month_time_filter_bounds_sessions_subagents_and_role_days(self):
     def test_calendar_time_filters_bound_sessions_subagents_and_role_days(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'';
 eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('const DELIVERY_EVIDENCE_FILTERS=')).replace(/^const /gm,'var '));
@@ -7679,7 +7680,7 @@ def test_calendar_time_filters_bound_sessions_subagents_and_role_days(self):
     def test_subagent_explorer_withholds_filtered_totals_when_inventory_is_truncated(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
 const result=filterSubagentInventory({{inventory_count:1001,inventory_truncated:true,inventory:[{{id:'a',root_session_id:'root',runtime:'codex',label:'Agent A',activity_state:'complete',last_activity_at:100,attention:[]}}]}},{{query:'agent',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'recent'}},200);
@@ -7697,7 +7698,7 @@ def test_subagent_explorer_withholds_filtered_totals_when_inventory_is_truncated
     def test_subagent_triage_preserves_context_and_pages_large_results(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('applySubagentPreset'));
 eval(extract('subagentPresetForFilters'));
@@ -7789,7 +7790,7 @@ def test_subagent_workspace_orders_roles_sessions_issues_and_defaults_to_roles(s
     def test_subagent_work_sort_uses_user_facing_label_and_migrates_elapsed_preference(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const stored=new Map([['tm_subagent_filter_sort','elapsed']]),writes=[];
 const localStorage={{getItem:key=>stored.get(key)??null,setItem:(key,value)=>{{stored.set(key,String(value));writes.push([key,String(value)]);}}}};
@@ -7821,7 +7822,7 @@ def test_subagent_work_sort_uses_user_facing_label_and_migrates_elapsed_preferen
     def test_subagent_time_filter_defaults_to_thirty_days_and_labels_all_history(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('function normalizeTimeFilterWindow(')).replace(/^const /gm,'var '));
 const initStart=page.indexOf('let subagentFilters={{'),initEnd=page.indexOf('const SUBAGENT_PAGE_SIZE',initStart);
@@ -7866,7 +7867,7 @@ def test_subagent_time_filter_defaults_to_thirty_days_and_labels_all_history(sel
     def test_subagent_summary_tags_toggle_incomplete_and_attention_filters(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)return null;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}return null;}}
 const source=extract('toggleSubagentSummaryFilter');
 if(!source)process.stdout.write(JSON.stringify({{missing:true}}));
@@ -7899,7 +7900,7 @@ def test_subagent_summary_tags_toggle_incomplete_and_attention_filters(self):
     def test_subagent_role_drilldown_adds_restorable_browser_history(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const calls=[];
 const history={{state:{{sessionScope:'all'}},replaceState(state,title,url){{this.state=state;calls.push(['replace',state.subagent,url]);}},pushState(state,title,url){{this.state=state;location.href=String(url);location.hash='#'+String(url).split('#')[1];calls.push(['push',state.subagent,url]);}}}};
@@ -7952,7 +7953,7 @@ def test_session_detail_back_control_markup_names_origin_list(self):
     def test_session_detail_back_returns_to_origin_list(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',start)+1,depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const SESSION_SCOPES=['current','all','compare','subagents'];
 const calls=[];
@@ -8024,7 +8025,7 @@ def test_session_compare_keys_forked_traces_and_routes_compare_scope(self):
         self.assertIn("{id:'compare-sessions',label:'Compare sessions'", self.page)
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const SESSION_SCOPES=['current','all','compare','subagents'];
 eval(extract('normalizeSessionScope'));eval(extract('sessionScopeRoute'));eval(extract('compareKeyFor'));
@@ -8065,7 +8066,7 @@ def test_session_compare_keys_forked_traces_and_routes_compare_scope(self):
     def test_compare_clears_stale_missing_notice_when_selection_empties(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`async function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',start)+1,depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 let compareIds=[],compareData={{sessions:[]}},compareError='',compareNotice='1 selected session could not be loaded right now.',compareMissing=['tgone'],compareLoadedKey='tgone',compareLoading=false,compareRequestSeq=0,rendered=0;
 function renderComparison(){{rendered++;}}
@@ -8084,7 +8085,7 @@ def test_subagents_have_a_primary_page_and_canonical_return_route(self):
         self.assertIn("id=session-scope-subagents", self.page)
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const SESSION_SCOPES=['current','all','subagents'];
 eval(extract('normalizeSessionScope'));
@@ -8102,7 +8103,7 @@ def test_subagents_have_a_primary_page_and_canonical_return_route(self):
     def test_subagent_role_runs_model_distribution_is_exact_and_runtime_scoped(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
 eval(extract('subagentModelDistribution'));
@@ -8130,7 +8131,7 @@ def test_subagent_role_runs_model_distribution_is_exact_and_runtime_scoped(self)
     def test_subagent_session_rows_keep_spawned_run_count(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const selectedSubagentId='',expandedSubagentRoot='not-this-root';
 const esc=value=>String(value),f=value=>String(value),countWord=(value,word)=>value===1?word:`${{word}}s`,money=value=>`$${{Number(value).toFixed(2)}}`,compactNumber=value=>String(value),currentSessionAge=()=> 'now',durationShort=value=>`${{value}}s`;
@@ -8163,7 +8164,7 @@ def test_subagent_session_rows_keep_spawned_run_count(self):
     def test_subagent_cost_color_is_relative_and_unavailable_cost_is_neutral(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('subagentCostHeat'));
 process.stdout.write(JSON.stringify({{low:subagentCostHeat(1,10,true),high:subagentCostHeat(10,10,true),missing:subagentCostHeat(null,10,false)}}));
@@ -8180,7 +8181,7 @@ def test_subagent_cost_color_is_relative_and_unavailable_cost_is_neutral(self):
     def test_role_name_search_keeps_exact_cost_trend_and_comparison(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(['selectSubagentUsageScope','subagentRoleKey','subagentRoleFineFilters','subagentRoleDayRows','buildSubagentRoleEconomics','buildSubagentModelTrends','subagentModelDayRows','subagentModelKey'].map(extract).join('\\n'));
 const reviewer={{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',agents:2,known_cost:4,cost_available:true,cost_covered_agents:2}};
@@ -8203,7 +8204,7 @@ def test_role_name_search_keeps_exact_cost_trend_and_comparison(self):
     def test_subagent_role_table_reports_total_covered_spend(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,compactNumber=value=>String(value),appFilterLabel=({{provider}})=>provider;
 eval(extract('buildSubagentRoleRows'));
@@ -8227,7 +8228,7 @@ def test_subagent_role_table_reports_total_covered_spend(self):
     def test_subagent_role_economics_compares_spend_volume_and_cost_per_run(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(['selectSubagentUsageScope','subagentRoleKey','subagentRoleFineFilters','subagentRoleDayRows','buildSubagentRoleEconomics','buildSubagentModelTrends','subagentModelDayRows','subagentModelKey'].map(extract).join('\\n'));
 const current=[
@@ -8278,7 +8279,7 @@ def test_subagent_role_economics_compares_spend_volume_and_cost_per_run(self):
     def test_subagent_role_economics_renders_a_clear_chart_for_each_role(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,appFilterLabel=({{provider}})=>provider;
 let subagentRoleChartMode='average';
@@ -8331,7 +8332,7 @@ def test_subagent_role_economics_renders_a_clear_chart_for_each_role(self):
     def test_subagent_role_economics_withholds_truncated_period_insights(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,appFilterLabel=({{provider}})=>provider;
 let subagentRoleChartMode='spend';
@@ -8360,7 +8361,7 @@ def test_subagent_role_economics_withholds_truncated_period_insights(self):
     def test_subagent_role_charts_do_not_hide_lower_spend_roles(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const esc=value=>String(value);
 let subagentRoleChartMode='spend';
@@ -8382,7 +8383,7 @@ def test_subagent_role_charts_do_not_hide_lower_spend_roles(self):
     def test_subagent_workspace_groups_parent_sessions_and_prioritizes_issues(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('groupSubagentSessions'));
 const rows=[
@@ -8417,7 +8418,7 @@ def test_subagent_workspace_groups_parent_sessions_and_prioritizes_issues(self):
     def test_subagent_roles_preserve_runtime_kind_and_calculate_review_metrics(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('buildSubagentRoleRows'));
 const rows=[
@@ -8465,7 +8466,7 @@ def test_sessions_all_uses_exact_coverage_copy_without_ambiguous_suffixes(self):
     def test_browser_agent_attention_adds_cap_and_live_growth_only_with_cost_evidence(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(page.match(/^const money=.*$/m)[0].replace('const money','globalThis.money'));
 eval(extract('deriveAgentAttention'));
@@ -8501,7 +8502,7 @@ def test_browser_agent_attention_adds_cap_and_live_growth_only_with_cost_evidenc
     def test_subagent_usage_scope_supports_project_filters_and_blocks_text_search(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 eval(extract('selectSubagentUsageScope'));
 const usage={{totals:{{agents:9}},scope_truncated:false,scopes:[
@@ -9024,7 +9025,7 @@ def test_models_page_is_a_ranked_spend_leaderboard(self):
     def test_models_leaderboard_groups_variants_and_never_counts_missing_cost_as_zero(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 function constLine(name){{const start=page.indexOf(`const ${{name}}=`);if(start<0)throw Error(`missing ${{name}}`);return page.slice(start,page.indexOf('\\n',start));}}
 ['MODEL_COUNTER_KEYS','MODEL_ARRAY_KEYS','metricAvailable','metricPartial','usageProvenance','usageBasis','hasLocalEstimate'].forEach(name=>eval(constLine(name).replace(/^const /,'globalThis.')));
@@ -9075,7 +9076,7 @@ def test_models_leaderboard_groups_variants_and_never_counts_missing_cost_as_zer
     def test_models_speed_series_is_time_weighted_smoothed_and_defaults_to_timed_top_five(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 ['localDateKey','modelCalendarDays','modelSpeedBasis','modelSpeedSeries','modelSpeedDefaultKeys','modelSmoothPath'].forEach(name=>eval(`globalThis.${{name}}=${{extract(name)}}`));
 const days=['d1','d2','d3','d4','d5'];
@@ -9130,7 +9131,7 @@ def test_models_speed_series_is_time_weighted_smoothed_and_defaults_to_timed_top
 
     def run_chart_gap_harness(self, body):
         script = self.CHART_GAP_HARNESS.replace(
-            "__PAGE__", json.dumps(str(Path(meter.__file__).with_name("page.html"))),
+            "__PAGE__", json.dumps(str(Path(DASHBOARD_PAGE))),
         ) + body
         result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
         self.assertEqual(result.returncode, 0, result.stderr)
@@ -9248,7 +9249,7 @@ def test_model_speed_and_trend_charts_bridge_gaps_instead_of_smoothing_through_t
     def test_models_focus_restore_keeps_the_focused_control_and_scopes_to_its_container(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const start=page.indexOf('const MODEL_FOCUS_KEYS=');eval('globalThis.MODEL_FOCUS_KEYS='+page.slice(start+'const MODEL_FOCUS_KEYS='.length,page.indexOf(';',start)));
 eval('globalThis.modelFocusKey='+extract('modelFocusKey'));eval('globalThis.restoreModelFocus='+extract('restoreModelFocus'));
@@ -12130,7 +12131,7 @@ def test_onboarding_checklist_and_lesson_dialog_are_retired(self):
 
     def _tour_script(self, body):
         """Runs the tour's DOM-free block (storage, slide copy, frame markup) in Node with the page's own formatters."""
-        page_path = json.dumps(str(Path(meter.__file__).with_name('page.html')))
+        page_path = json.dumps(str(Path(DASHBOARD_PAGE)))
         return f"""
 const fs=require('fs');
 const page=fs.readFileSync({page_path},'utf8');
@@ -12715,7 +12716,7 @@ def test_selected_candidate_action_has_confirmation_and_exact_control_ids(self):
     def test_capability_review_queue_renders_one_expandable_row_per_pack(self):
         script = f"""
 const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const f=n=>Math.round(n||0).toLocaleString('en-US');
 const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
@@ -13420,7 +13421,7 @@ def test_page_signal_presentations_share_one_animation_timeline(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
     def test_page_signal_route_change_disposes_a_partially_mounted_effect(self):
-        page_path = Path(meter.__file__).with_name("page.html")
+        page_path = Path(DASHBOARD_PAGE)
         script = f"""
 const fs=require('fs');
 const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
@@ -13498,7 +13499,7 @@ class El{{
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
     def test_stale_same_header_mount_cannot_clear_the_new_ready_marker(self):
-        page_path = Path(meter.__file__).with_name("page.html")
+        page_path = Path(DASHBOARD_PAGE)
         script = f"""
 const fs=require('fs');
 const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
@@ -13589,7 +13590,7 @@ class El{{
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
     def test_shared_border_readiness_cancels_stale_mounts_before_construction(self):
-        page_path = Path(meter.__file__).with_name("page.html")
+        page_path = Path(DASHBOARD_PAGE)
         script = f"""
 const fs=require('fs');
 const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
@@ -13819,7 +13820,7 @@ def test_collapsed_navigation_keeps_session_scope_labels_visible(self):
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
     def test_model_board_pushback_reads_work_labels_for_the_same_window(self):
         script = f"""
-const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const constLine=name=>page.slice(page.indexOf(`const ${{name}}=`),page.indexOf(';',page.indexOf(`const ${{name}}=`))+1);
 const esc=s=>String(s),f=v=>String(v),pct=v=>Math.round(v*100)+'%';
@@ -13877,7 +13878,7 @@ def test_model_board_pushback_reads_work_labels_for_the_same_window(self):
 
     def test_current_day_summary_compares_partial_days_without_estimate_suffix(self):
         script = f"""
-const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(meter.__file__).with_name('page.html')))},'utf8');
+const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const nodes={{}};const $=id=>nodes[id]||(nodes[id]={{textContent:'',classList:{{toggle(){{}},add(){{}},remove(){{}}}},setAttribute(){{}},removeAttribute(){{}},dataset:{{}}}});
 const money=v=>'$'+Number(v||0).toFixed(2),f=v=>String(v),countWord=(n,w)=>n===1?w:w+'s';
@@ -16724,7 +16725,7 @@ def get(path):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for live polling verification")
     def test_live_polling_reuses_only_the_snapshot_matching_its_revision(self):
-        page_path = Path(meter.__file__).with_name("page.html")
+        page_path = Path(DASHBOARD_PAGE)
         script = f"""
 const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start-(page.slice(start-6,start)==='async '?6:0),i+1);}}throw Error(`unclosed ${{name}}`);}}
@@ -19503,7 +19504,7 @@ def test_unreadable_config_wins_over_a_conflict_in_another_config(self):
         self.assertEqual(saved["mcpServers"]["tokenmeter"]["command"], "/tmp/different")
 
     def test_settings_row_shows_unreadable_claude_app_config_instead_of_launcher_error(self):
-        page = Path(meter.__file__).with_name("page.html").read_text()
+        page = Path(DASHBOARD_PAGE).read_text()
         self.assertIn("const disabled=!row.connected&&!row.available;", page)
         self.assertIn("try{refreshed=await loadAgentAccess();}finally{agentAccessRechecking=false;}", page)
         self.assertIn("if(!button||button.disabled)return;", page)
@@ -23284,7 +23285,7 @@ class OpenCodeSubagentDashboardContractTests(unittest.TestCase):
     """The All sessions view keeps child runs out of the list but shows them."""
 
     def setUp(self):
-        self.page = Path(__file__).resolve().parents[1].joinpath("page.html").read_text(
+        self.page = Path(DASHBOARD_PAGE).read_text(
             encoding="utf-8"
         )
 
@@ -23325,7 +23326,7 @@ def test_current_session_card_marks_partial_family_cost_as_lower_bound(self):
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
     def test_session_cap_display_and_alert_use_family_spend(self):
         """An OpenCode family cap reports and alerts on root plus child spend."""
-        page_path = Path(__file__).resolve().parents[1].joinpath("page.html")
+        page_path = Path(DASHBOARD_PAGE)
         script = f"""
 const fs=require('fs');
 const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
@@ -23372,7 +23373,7 @@ def test_session_cap_display_and_alert_use_family_spend(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
     def test_all_sessions_view_counts_children_and_respects_filters(self):
-        page_path = Path(__file__).resolve().parents[1].joinpath("page.html")
+        page_path = Path(DASHBOARD_PAGE)
         script = f"""
 const fs=require('fs');
 const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
@@ -23744,7 +23745,7 @@ def test_advertised_only_mcp_has_runtime_and_no_call_claim(self):
         }])
         row = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
         self.assertEqual((row["name"], row["runtime"], row["calls"]), ("jira", "Codex", 0))
-        script = Path(meter.__file__).with_name("page.html").read_text()
+        script = Path(DASHBOARD_PAGE).read_text()
         self.assertIn("Advertised in traces; not in Codex or Claude config", script)
 
     def test_nested_calls_are_daily_and_labelled_as_call_sites(self):
@@ -23761,7 +23762,7 @@ def test_nested_calls_are_daily_and_labelled_as_call_sites(self):
         }])
         mcp = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
         self.assertEqual(mcp["nested_calls"], 1)
-        script = Path(meter.__file__).with_name("page.html").read_text()
+        script = Path(DASHBOARD_PAGE).read_text()
         self.assertIn("code-mode call site", script)
 
     def test_host_tools_keep_non_disable_advice(self):
@@ -23819,7 +23820,7 @@ def test_codex_multi_part_mcp_namespace_keeps_server(self):
         self.assertEqual(codex_mcp_tool_name("x", "foo__bar"), "x")
 
     def test_tools_page_renders_unconfigured_mcp_without_off_claims(self):
-        script = Path(meter.__file__).with_name("page.html").read_text()
+        script = Path(DASHBOARD_PAGE).read_text()
         start = script.index("function capabilityConfigurationText(row){")
         body = script[start:script.index("\n}", start)]
         self.assertNotIn("row.enabled?'Enabled':'Disabled'", body.replace(" ", ""))
@@ -23847,7 +23848,7 @@ class DashboardThemeTests(unittest.TestCase):
     """Theme choice is a browser preference applied before first paint and offered in Settings and ⌘K."""
 
     def setUp(self):
-        self.page = Path(__file__).resolve().parents[1].joinpath("page.html").read_text(encoding="utf-8")
+        self.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
 
     def run_boot(self, stored, throws=False):
         boot = re.search(r"<script id=theme-boot>(.*?)</script>", self.page, re.S).group(1)
@@ -25645,7 +25646,7 @@ class ReviewRound4PageTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         root = Path(meter.__file__).resolve().parent
-        cls.page = (root / "page.html").read_text(encoding="utf-8")
+        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
         cls.design = (root / "specs" / "2026-10-29-cost-discounts-design.md").read_text(encoding="utf-8")
 
     def test_5_card_names_the_read_only_reason(self):
@@ -25672,7 +25673,7 @@ def test_7_design_doc_states_what_a_save_keeps(self):
 class ReviewRound3PageTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = (Path(meter.__file__).resolve().parent / "page.html").read_text(encoding="utf-8")
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
 
     def test_q3_first_render_happens_even_when_the_percent_field_has_focus(self):
         self.assertIn("if(xs?.cost_discounts&&!discountEditInProgress())renderDiscounts(xs.cost_discounts);", self.page)
@@ -25693,7 +25694,7 @@ class ReviewRound2PageAndDocsTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         root = Path(meter.__file__).resolve().parent
-        cls.page = (root / "page.html").read_text(encoding="utf-8")
+        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
         cls.docs = {name: (root / "specs" / name).read_text(encoding="utf-8")
                     for name in ("ARCHITECTURE.md", "LOCAL-API.md", "2026-10-29-cost-discounts-design.md")}
 
@@ -25721,7 +25722,7 @@ def test_r6_docs_describe_the_server_wide_host_check_and_vertex_ids(self):
 class ReviewFixPageTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.page = (Path(meter.__file__).resolve().parent / "page.html").read_text(encoding="utf-8")
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
 
     def test_s6_live_refresh_keeps_the_notice_and_card_stable_and_accessible(self):
         # Round two moved role=status back to the stable container (see R5).
@@ -25749,9 +25750,9 @@ class CostDiscountPageTests(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.page = (Path(meter.__file__).resolve().parent / "page.html").read_text(encoding="utf-8")
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
         if "id=spend-discounts" not in cls.page:
-            cls.page = (Path(__file__).resolve().parents[1] / "page.html").read_text(encoding="utf-8")
+            cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
 
     def section(self, start, end):
         begin = self.page.index(start)
@@ -25839,7 +25840,7 @@ class DeclutterCopyContractTests(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.page = Path(meter.__file__).with_name("page.html").read_text()
+        cls.page = Path(DASHBOARD_PAGE).read_text()
 
     def run_node(self, script):
         result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
@@ -25916,7 +25917,7 @@ class Node{constructor(){this.textContent='';this.innerHTML='';this.hidden=false
 """
 
     def run_page_node(self, script):
-        page = str(Path(meter.__file__).with_name("page.html"))
+        page = str(Path(DASHBOARD_PAGE))
         result = subprocess.run(["node", "-e", self.NODE_EXTRACT + script, page],
                                 capture_output=True, text=True)
         if result.returncode:
diff --git a/tests/test_work_insights.py b/tests/test_work_insights.py
index 2fb58fa1..1881abd4 100644
--- a/tests/test_work_insights.py
+++ b/tests/test_work_insights.py
@@ -15,6 +15,7 @@
 import meter
 from token_meter.domain import work as domain
 from token_meter.services import work_insights as W
+from tests.dashboard_page import DASHBOARD_PAGE
 
 REAL_MEMORY_PROBE = W._default_memory_probe
 _memory_patch = mock.patch.object(W, "_default_memory_probe", lambda: None)
@@ -1751,7 +1752,7 @@ def test_platform_gate_follows_the_platform_service(self):
         self.assertEqual(meter.work_insights_supported(), meter._PLATFORM_SERVICES.platform_id == "macos")
 
     def test_page_hides_work_off_macos(self):
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         for marker in ('id=tab-work data-label=Work aria-label=Work title=Work hidden>',
@@ -1771,7 +1772,7 @@ def test_setup_script_refuses_other_platforms(self):
         self.assertLess(script.index('uname -s'), script.index("command -v python3"))
 
     def test_right_sizing_explains_each_flag(self):
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         self.assertNotIn("ooks mismatched", page)
@@ -1790,7 +1791,7 @@ def test_pace_choice_round_trips_and_a_chosen_five_survives(self):
             self.assertFalse(meter.set_work_insights_settings({"rate_per_minute": bad}, self.settings)["ok"])
         self.assertIn("auto", meter.work_insights_public_settings(meter.work_insights_settings(self.settings))
                       ["choices"]["rate_per_minute"])
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         self.assertIn("<option value=auto>Automatic (default)</option>", page)
@@ -1938,7 +1939,7 @@ class SurfaceContractTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        with open(os.path.join(root, "page.html"), encoding="utf-8") as handle:
+        with open(DASHBOARD_PAGE, encoding="utf-8") as handle:
             cls.page = handle.read()
         with open(os.path.join(root, "menubar", "TokenMeterMenuBar.swift"), encoding="utf-8") as handle:
             cls.swift = handle.read()
@@ -2011,7 +2012,7 @@ def test_work_page_hosts_work_goals_with_kind_of_work_and_range_targets(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required")
     def test_goal_targets_read_as_a_range_or_a_bound(self):
-        page = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2026,7 +2027,7 @@ def test_goal_targets_read_as_a_range_or_a_bound(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required")
     def test_work_breakdown_sorts_by_any_column_with_unavailable_values_last(self):
-        page = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2051,7 +2052,7 @@ def test_work_breakdown_sorts_by_any_column_with_unavailable_values_last(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required")
     def test_a_settings_deep_link_waits_for_a_hidden_card_and_settles(self):
-        page = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2090,7 +2091,7 @@ def test_a_settings_deep_link_waits_for_a_hidden_card_and_settles(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required")
     def test_work_page_says_results_fill_in_as_labeling_finishes(self):
-        page_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page_path = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 let start=page.indexOf('function workProgressNote(');let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)break;}
@@ -2125,7 +2126,7 @@ def test_work_page_says_results_fill_in_as_labeling_finishes(self):
         self.assertIn("$('w-progress-title').hidden=!note[0];", page)
 
     def test_work_settings_save_is_live_only_with_unsaved_changes(self):
-        page_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page_path = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2154,7 +2155,7 @@ def test_work_settings_save_is_live_only_with_unsaved_changes(self):
         self.assertIn('<div class="workActionGroup workSettingsManage">', page)
 
     def test_a_toggle_save_keeps_unsaved_model_and_area_edits(self):
-        page_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page_path = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`async function ${name}(`);if(start<0)start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2193,7 +2194,7 @@ def test_a_toggle_save_keeps_unsaved_model_and_area_edits(self):
                                         "line": "Default areas restored. Other changes are not saved yet."})
 
     def test_effort_by_model_renders_one_model_with_verdicts_and_thin_cells(self):
-        page = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2287,7 +2288,7 @@ def test_setup_shows_steps_progress_speed_and_the_next_retry(self):
 
     @unittest.skipUnless(shutil.which("node"), "Node.js is required")
     def test_setup_copy_reads_speed_failures_and_steps(self):
-        page = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html")
+        page = DASHBOARD_PAGE
         script = """
 const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
 function extract(name){let start=page.indexOf(`function ${name}(`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
@@ -2687,7 +2688,7 @@ def test_right_sizing_cards_show_models_reasoning_and_pushback(self):
                                   {"model": "", "runtime": "Codex", "rate": 0.0, "samples": 40}]},
         }
         script = f"""
-const fs=require('fs');const page=fs.readFileSync({json.dumps(os.path.join(root, 'page.html'))},'utf8');
+const fs=require('fs');const page=fs.readFileSync({json.dumps(DASHBOARD_PAGE)},'utf8');
 function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
 const nodes={{}};const $=id=>nodes[id]||(nodes[id]={{innerHTML:''}});
 const esc=v=>String(v??'').replace(/[&<>"]/g,c=>({{'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}})[c]);
@@ -2728,7 +2729,7 @@ def test_right_sizing_cards_show_models_reasoning_and_pushback(self):
         self.assertNotIn("unknown-model", pushback)
 
     def test_page_work_filter_ignores_stale_responses(self):
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         apply = page[page.index("async function applyWorkSessionFilter("):page.index("async function loadDelivery(")]
@@ -2885,7 +2886,7 @@ def test_labeled_session_with_never_labeled_follow_ups_is_unclear_not_single_sho
         self.assertEqual(snapshot[service.session_key("s2")]["follow_ups"], 1)
 
     def test_page_drill_cells_keep_table_semantics_with_inner_buttons(self):
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         work = page[page.index("function renderWorkSizing("):page.index("function renderWork(payload)")]
@@ -3224,7 +3225,7 @@ def test_developer_work_types(self):
         self.assertEqual(list(W.WORK_TYPES), ["feature", "debug", "refactor", "test", "review", "plan", "explore",
                                               "ops", "docs", "other"])
         self.assertEqual(set(domain.WORK_TYPE_ORDER), set(W.WORK_TYPES) | {"unclear"})
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         for key in W.WORK_TYPES:
@@ -3568,7 +3569,7 @@ def test_live_notification_setting_is_validated_and_public(self):
 
     def test_surfaces_render_hints_completion_and_notifications(self):
         root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        with open(os.path.join(root, "page.html"), encoding="utf-8") as handle:
+        with open(DASHBOARD_PAGE, encoding="utf-8") as handle:
             page = handle.read()
         with open(os.path.join(root, "menubar", "TokenMeterMenuBar.swift"), encoding="utf-8") as handle:
             swift = handle.read()
@@ -3605,7 +3606,7 @@ def test_model_days_are_aggregated_projected_and_rendered(self):
         projected = projections.agent_usage_projection(usage)
         self.assertEqual(projected["model_days"][0]["model"], "gpt-5.6-terra")
         self.assertFalse(projected["model_days_truncated"])
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         for marker in ("<h4>Model trends</h4>", "data-subagent-inspect-model", "function openSubagentModelRuns(",
@@ -3626,7 +3627,7 @@ def test_low_confidence_area_guesses_count_in_their_area_and_are_tracked(self):
 
 class RightSizingColourTests(unittest.TestCase):
     def test_effort_is_folded_into_three_bands_and_drills_accept_a_level_list(self):
-        with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "page.html"),
+        with open(DASHBOARD_PAGE,
                   encoding="utf-8") as handle:
             page = handle.read()
         self.assertIn("{key:'extra',label:'Extra high+',levels:['xhigh','max','ultra']}", page)
diff --git a/token_meter/app.py b/token_meter/app.py
index f4c98291..af59cbf4 100644
--- a/token_meter/app.py
+++ b/token_meter/app.py
@@ -53,6 +53,7 @@
 IMPLEMENTATION_FILE = os.path.abspath(__file__)
 _SOURCE_ROOT = os.path.dirname(os.path.dirname(IMPLEMENTATION_FILE))
 
+from token_meter import dashboard_page
 from token_meter.compat import envelope_to_legacy_source, legacy_source_to_envelope
 from token_meter.contracts import (
     AdapterFailure,
@@ -14194,8 +14195,8 @@ def page_candidates():
     if explicit:
         paths.append(os.path.abspath(os.path.expanduser(explicit)))
     paths.extend([
-        os.path.join(_SOURCE_ROOT, "page.html"),
-        os.path.join(os.getcwd(), "page.html"),
+        dashboard_page.manifest_path(_SOURCE_ROOT),
+        dashboard_page.manifest_path(os.getcwd()),
     ])
 
     out, seen = [], set()
@@ -14210,12 +14211,28 @@ def page_candidates():
 
 
 def page_path():
+    """The file that identifies the dashboard: its parts manifest, or an explicit page."""
     for path in PAGE_CANDIDATES:
         if os.path.isfile(path):
             return path
     return None
 
 
+def page_root(path):
+    """Directory that holds the dashboard and its bundled assets."""
+    if dashboard_page.is_manifest(path):
+        return dashboard_page.dashboard_root(path)
+    return os.path.dirname(path)
+
+
+def page_bytes(path):
+    """Assembled dashboard bytes, or None when a part is missing or unreadable."""
+    try:
+        return dashboard_page.read_page(path).encode("utf-8")
+    except (OSError, UnicodeDecodeError, ValueError):
+        return None
+
+
 def performance_page_candidates():
     return [
         os.path.join(_SOURCE_ROOT, "performance.html"),
@@ -14267,7 +14284,7 @@ def dashboard_asset_path(req_path):
     dashboard = page_path()
     if not dashboard:
         return None
-    path = os.path.join(os.path.dirname(dashboard), *spec[0].split("/"))
+    path = os.path.join(page_root(dashboard), *spec[0].split("/"))
     return path if os.path.isfile(path) else None
 
 
@@ -14291,9 +14308,9 @@ def missing_page_html():
   </style>
 </head>
 <body>
-  <h1>page.html is missing</h1>
-  <p>Token Meter needs the dashboard file <code>page.html</code> alongside <code>meter.py</code>, or in the directory where you start the server.</p>
-  <p>Run from a full repository clone with <code>./scripts/start-token-meter</code>, or copy <code>page.html</code> from the repo into the same folder as <code>meter.py</code>.</p>
+  <h1>The dashboard files are missing</h1>
+  <p>Token Meter needs the <code>dashboard</code> folder, including <code>dashboard/page.manifest</code> and every file it lists, alongside <code>meter.py</code>, or in the directory where you start the server.</p>
+  <p>Run from a full repository clone with <code>./scripts/start-token-meter</code>, or reinstall Token Meter from a complete source checkout.</p>
   <p>Looked in:</p>
   <ul>{candidates}</ul>
 </body>
@@ -14386,10 +14403,11 @@ def do_HEAD(self):
             self.end_headers()
         elif is_dashboard_page_path(req_path):
             path = page_path()
-            body = b"" if path else missing_page_html().encode()
-            self.send_response(200 if path else 503)
+            page = page_bytes(path) if path else None
+            body = page if page is not None else missing_page_html().encode()
+            self.send_response(200 if page is not None else 503)
             self.send_header("Content-Type", "text/html; charset=utf-8")
-            self.send_header("Content-Length", str(os.path.getsize(path) if path else len(body)))
+            self.send_header("Content-Length", str(len(body)))
             self.end_headers()
         elif (path := dashboard_asset_path(req_path)):
             self.send_response(200)
@@ -14802,8 +14820,9 @@ def do_GET(self):
                 self._send(missing_performance_html(), status=503)
         elif is_dashboard_page_path(req_path):
             path = page_path()
-            if path:
-                self._send(open(path, encoding="utf-8").read())
+            page = page_bytes(path) if path else None
+            if page is not None:
+                self._send(page)
             else:
                 self._send(missing_page_html(), status=503)
         elif (asset_path := dashboard_asset_path(req_path)):
diff --git a/token_meter/dashboard_page.py b/token_meter/dashboard_page.py
new file mode 100644
index 00000000..75a3be94
--- /dev/null
+++ b/token_meter/dashboard_page.py
@@ -0,0 +1,112 @@
+"""Assemble the browser dashboard from its ordered source parts.
+
+The dashboard ships as one HTML page, but its source lives in ``dashboard/``
+as small files so each view can be read and edited on its own. The order is
+``dashboard/page.manifest``; the served page is the exact concatenation of the
+listed parts, so no build step or third-party tool is involved.
+"""
+
+import os
+import threading
+
+MANIFEST_RELATIVE = os.path.join("dashboard", "page.manifest")
+_MAX_PARTS = 200
+
+_cache_lock = threading.Lock()
+_cache = {"signature": None, "text": None}
+
+
+def manifest_path(root):
+    return os.path.join(root, MANIFEST_RELATIVE)
+
+
+def dashboard_root(manifest):
+    """Return the repository/runtime root that owns ``manifest``."""
+    return os.path.dirname(os.path.dirname(os.path.abspath(manifest)))
+
+
+def part_names(manifest):
+    """Read the ordered part list; reject anything that could leave dashboard/."""
+    with open(manifest, encoding="utf-8") as handle:
+        lines = handle.read().splitlines()
+    names = []
+    for raw in lines:
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        parts = line.split("/")
+        if (
+            os.path.isabs(line)
+            or "\\" in line
+            or any(part in ("", ".", "..") for part in parts)
+        ):
+            raise ValueError("dashboard manifest entries must be relative paths inside dashboard/")
+        names.append(line)
+    if not names or len(names) > _MAX_PARTS:
+        raise ValueError("dashboard manifest must list between 1 and %d parts" % _MAX_PARTS)
+    if len(set(names)) != len(names):
+        raise ValueError("dashboard manifest lists a part twice")
+    return names
+
+
+def part_paths(manifest):
+    base = os.path.dirname(os.path.abspath(manifest))
+    return [os.path.join(base, *name.split("/")) for name in part_names(manifest)]
+
+
+def _signature(manifest, paths):
+    stamp = []
+    for path in [manifest, *paths]:
+        info = os.stat(path)
+        stamp.append((path, info.st_mtime_ns, info.st_size))
+    return tuple(stamp)
+
+
+def assemble(manifest):
+    """Return the full page text; cached until the manifest or any part changes."""
+    paths = part_paths(manifest)
+    signature = _signature(manifest, paths)
+    with _cache_lock:
+        if _cache["signature"] == signature:
+            return _cache["text"]
+    chunks = []
+    for path in paths:
+        with open(path, encoding="utf-8", newline="") as handle:
+            chunks.append(handle.read())
+    text = "".join(chunks)
+    with _cache_lock:
+        _cache["signature"] = signature
+        _cache["text"] = text
+    return text
+
+
+def is_manifest(path):
+    return bool(path) and os.path.basename(path) == os.path.basename(MANIFEST_RELATIVE)
+
+
+def read_page(path):
+    """Serve either an assembled manifest or an explicit single-file page."""
+    if is_manifest(path):
+        return assemble(path)
+    with open(path, encoding="utf-8", newline="") as handle:
+        return handle.read()
+
+
+def main(argv):
+    """Write the assembled page to a file, or to stdout when no path is given."""
+    import sys
+
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    text = assemble(manifest_path(root))
+    if len(argv) > 1:
+        with open(argv[1], "w", encoding="utf-8", newline="") as handle:
+            handle.write(text)
+    else:
+        sys.stdout.write(text)
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+
+    raise SystemExit(main(sys.argv))

From fa507a32d3d6ea8d580a01b3c44a49e1b8643481 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 08:39:02 +0530
Subject: [PATCH 3/9] fix(work): count dashboard/ scripts as frontend files

The dashboard now lives in dashboard/js/*.js. Work evidence classified
.js outside a recognized frontend folder as backend, so dashboard edits
would have read as backend work. Add dashboard(s)/ to the frontend folders.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 tests/test_work_requests.py         | 1 +
 token_meter/domain/work_evidence.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_work_requests.py b/tests/test_work_requests.py
index 2c879d2f..2fad753a 100644
--- a/tests/test_work_requests.py
+++ b/tests/test_work_requests.py
@@ -39,6 +39,7 @@ def test_file_kinds(self):
                            ("tests/test_meter.py", "tests"), ("specs/WORK_INSIGHTS.md", "docs"),
                            ("AGENTS.md", "tooling"), ("scripts/install", "tooling"),
                            (".github/workflows/ci.yml", "infra"), ("src/components/Button.ts", "frontend"),
+                           ("dashboard/js/spend.js", "frontend"),
                            ("notebooks/x.ipynb", "data"), ("Dockerfile", "infra"), ("config.yaml", "config")):
             self.assertEqual(E.file_kind(path), kind, path)
 
diff --git a/token_meter/domain/work_evidence.py b/token_meter/domain/work_evidence.py
index f53a4969..f4a5c73c 100644
--- a/token_meter/domain/work_evidence.py
+++ b/token_meter/domain/work_evidence.py
@@ -82,7 +82,7 @@
     **dict.fromkeys((".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico", ".mp4", ".mov", ".pptx", ".key"),
                     "media"),
 }
-_FRONTEND_DIR_RE = re.compile(r"(^|/)(components?|pages?|views?|ui|frontend|client|web|public|static|styles?|app/)"
+_FRONTEND_DIR_RE = re.compile(r"(^|/)(components?|pages?|views?|ui|frontend|client|web|public|static|styles?|dashboards?|app/)"
                               r"|\.(component|page|view)\.")
 _TEST_PATH_RE = re.compile(r"(^|/)(tests?|__tests__|spec)/|(^|/)test_[^/]+$|[._-](test|spec)\.[a-z]+$")
 _INFRA_PATH_RE = re.compile(r"(^|/)(\.github/workflows|\.circleci|k8s|kubernetes|helm|terraform|infra|deploy|ansible)"

From 63eb35d4c92a2de558b7a4473733d68384c16cd4 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 08:52:02 +0530
Subject: [PATCH 4/9] test: split test_meter.py into one module per surface

tests/test_meter.py was 1.43 MB with 97 classes, so agents grepped it
instead of opening the tests for the surface they changed. Its classes now
live in 29 modules under 80 KB each (test_dashboard_*.py, test_pricing.py,
test_menubar_tray.py, ...). The 230-method DashboardLayoutTests and the
OpenCode tests are split by topic onto shared bases that hold their
original setup and helpers (dashboard_layout_support.py,
opencode_test_support.py); module-level fixtures move to meter_support.py.

Coverage is unchanged: the same 1,034 test methods, byte-identical bodies,
and the full suite passes serially and in parallel.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 AGENTS.md                                  |     2 +-
 specs/AGENTS.md                            |     2 +-
 tests/contracts/test_source_size_budget.py |     1 -
 tests/dashboard_layout_support.py          |    83 +
 tests/meter_support.py                     |   146 +
 tests/opencode_test_support.py             |   156 +
 tests/runtimes/test_pi_adapter.py          |     2 +-
 tests/test_agent_access.py                 |  1111 +
 tests/test_agent_data_contract.py          |  1404 +
 tests/test_builder_recap.py                |   992 +
 tests/test_builder_recap_page.py           |   868 +
 tests/test_cost_discount_flows.py          |   811 +
 tests/test_daily_budgets.py                |   620 +
 tests/test_dashboard_contracts.py          |   705 +
 tests/test_dashboard_efficiency.py         |  1063 +
 tests/test_dashboard_models.py             |   877 +
 tests/test_dashboard_sessions_1.py         |  1195 +
 tests/test_dashboard_sessions_2.py         |   296 +
 tests/test_dashboard_settings.py           |   401 +
 tests/test_dashboard_shell.py              |   876 +
 tests/test_dashboard_spend.py              |   849 +
 tests/test_dashboard_subagents.py          |   818 +
 tests/test_dashboard_tools.py              |   210 +
 tests/test_dashboard_tour.py               |   430 +
 tests/test_health_quota.py                 |   841 +
 tests/test_menubar_tray.py                 |  1036 +
 tests/test_meter.py                        | 26005 -------------------
 tests/test_model_performance.py            |  1417 +
 tests/test_opencode_sessions.py            |   647 +
 tests/test_opencode_subagents.py           |   889 +
 tests/test_pi_sessions.py                  |  1286 +
 tests/test_pricing.py                      |  1153 +
 tests/test_review_fixes.py                 |   928 +
 tests/test_session_live.py                 |   781 +
 tests/test_session_summaries.py            |  1297 +
 tests/test_trace_parsing.py                |   999 +
 tests/test_updates_install.py              |  1230 +
 37 files changed, 26418 insertions(+), 26009 deletions(-)
 create mode 100644 tests/dashboard_layout_support.py
 create mode 100644 tests/meter_support.py
 create mode 100644 tests/opencode_test_support.py
 create mode 100644 tests/test_agent_access.py
 create mode 100644 tests/test_agent_data_contract.py
 create mode 100644 tests/test_builder_recap.py
 create mode 100644 tests/test_builder_recap_page.py
 create mode 100644 tests/test_cost_discount_flows.py
 create mode 100644 tests/test_daily_budgets.py
 create mode 100644 tests/test_dashboard_contracts.py
 create mode 100644 tests/test_dashboard_efficiency.py
 create mode 100644 tests/test_dashboard_models.py
 create mode 100644 tests/test_dashboard_sessions_1.py
 create mode 100644 tests/test_dashboard_sessions_2.py
 create mode 100644 tests/test_dashboard_settings.py
 create mode 100644 tests/test_dashboard_shell.py
 create mode 100644 tests/test_dashboard_spend.py
 create mode 100644 tests/test_dashboard_subagents.py
 create mode 100644 tests/test_dashboard_tools.py
 create mode 100644 tests/test_dashboard_tour.py
 create mode 100644 tests/test_health_quota.py
 create mode 100644 tests/test_menubar_tray.py
 delete mode 100644 tests/test_meter.py
 create mode 100644 tests/test_model_performance.py
 create mode 100644 tests/test_opencode_sessions.py
 create mode 100644 tests/test_opencode_subagents.py
 create mode 100644 tests/test_pi_sessions.py
 create mode 100644 tests/test_pricing.py
 create mode 100644 tests/test_review_fixes.py
 create mode 100644 tests/test_session_live.py
 create mode 100644 tests/test_session_summaries.py
 create mode 100644 tests/test_trace_parsing.py
 create mode 100644 tests/test_updates_install.py

diff --git a/AGENTS.md b/AGENTS.md
index 3734aa70..5a8edf9f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -33,7 +33,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `token_meter/domain/work.py` | Work page aggregation over cached summaries and content-free labels |
 | `token_meter/domain/work_evidence.py` | Per-request cost slices and action evidence for Work insights |
 | `token_meter_mcp.py` | Bounded MCP interface; evidence is read-only except explicit confirmed session-budget changes |
-| `tests/test_meter.py` | Server, parser, UI-contract, installer, and Swift-source tests |
+| `tests/test_*.py` | One module per surface (for example `test_dashboard_spend.py`, `test_menubar_tray.py`, `test_pricing.py`); shared fixtures live in `tests/*_support.py` and `tests/dashboard_page.py`. Run the one module you changed first |
 | `tests/test_mcp_server.py` | MCP contract and privacy tests |
 | `runtime-manifest.txt` | Shared source-to-runtime packaging contract |
 | `scripts/install` | Stage user runtime and install both macOS LaunchAgents |
diff --git a/specs/AGENTS.md b/specs/AGENTS.md
index a643e3b0..63861834 100644
--- a/specs/AGENTS.md
+++ b/specs/AGENTS.md
@@ -31,7 +31,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `token_meter/domain/work.py` | Work page aggregation over cached summaries and content-free labels |
 | `token_meter/domain/work_evidence.py` | Per-request cost slices and action evidence for Work insights |
 | `token_meter_mcp.py` | Bounded MCP interface; evidence is read-only except explicit confirmed session-budget changes |
-| `tests/test_meter.py` | Server, parser, UI-contract, installer, and Swift-source tests |
+| `tests/test_*.py` | One module per surface (for example `test_dashboard_spend.py`, `test_menubar_tray.py`, `test_pricing.py`); shared fixtures live in `tests/*_support.py` and `tests/dashboard_page.py`. Run the one module you changed first |
 | `tests/test_mcp_server.py` | MCP contract and privacy tests |
 | `runtime-manifest.txt` | Shared source-to-runtime packaging contract |
 | `scripts/install` | Stage user runtime and install both macOS LaunchAgents |
diff --git a/tests/contracts/test_source_size_budget.py b/tests/contracts/test_source_size_budget.py
index 46705b7f..1f876897 100644
--- a/tests/contracts/test_source_size_budget.py
+++ b/tests/contracts/test_source_size_budget.py
@@ -20,7 +20,6 @@
 # Ceilings are about 5% above each file's size when the budget was introduced,
 # so normal maintenance still fits. This dict may only shrink.
 LEGACY_CEILINGS = {
-    "tests/test_meter.py": 1_500_000,
     "token_meter/app.py": 663_000,
     "tests/test_work_insights.py": 236_000,
     "menubar/TokenMeterMenuBar.swift": 148_000,
diff --git a/tests/dashboard_layout_support.py b/tests/dashboard_layout_support.py
new file mode 100644
index 00000000..4763c1b4
--- /dev/null
+++ b/tests/dashboard_layout_support.py
@@ -0,0 +1,83 @@
+"""Shared setup and helpers for the DashboardLayoutTests split."""
+
+import unittest
+import json
+import subprocess
+from pathlib import Path
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+
+
+class DashboardLayoutCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.page = Path(DASHBOARD_PAGE).read_text()
+        cls.session_effects = (
+            Path(meter.__file__).with_name("assets") / "session-effects.js"
+        ).read_text()
+
+    CHART_GAP_HARNESS = r"""
+const fs=require('fs');
+const page=fs.readFileSync(__PAGE__,'utf8');
+function extract(name){let start=page.indexOf(`function ${name}(`);if(start<0)throw Error(`missing ${name}`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}throw Error(`unclosed ${name}`);}
+function load(names){names.forEach(name=>eval(`globalThis.${name}=${extract(name)}`));}
+function attrs(html,tag,cls){return [...html.matchAll(new RegExp(`<${tag} class=${cls} ([^>]*)/?>`,'g'))].map(match=>Object.fromEntries([...match[1].matchAll(/([\w-]+)="([^"]*)"/g)].map(pair=>[pair[1],pair[2]])));}
+"""
+
+    def run_chart_gap_harness(self, body):
+        script = self.CHART_GAP_HARNESS.replace(
+            "__PAGE__", json.dumps(str(Path(DASHBOARD_PAGE))),
+        ) + body
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        return json.loads(result.stdout)
+
+    def _tour_script(self, body):
+        """Runs the tour's DOM-free block (storage, slide copy, frame markup) in Node with the page's own formatters."""
+        page_path = json.dumps(str(Path(DASHBOARD_PAGE)))
+        return f"""
+const fs=require('fs');
+const page=fs.readFileSync({page_path},'utf8');
+const helpers=page.match(/^const (f|compactNumber|money|wholeMoney|pct|countWord|esc)=.*$/gm).join('\\n').replace(/^const /gm,'var ');
+eval(helpers);
+var LATEST=null;Object.defineProperty(globalThis,'navigator',{{value:{{platform:'',userAgent:''}},configurable:true,writable:true}});
+var providerColor=id=>`var(--provider-${{id}})`,runtimeMarkSvg=()=>'<svg class=runtimeMark></svg>',compareColor=i=>['var(--c-a)','var(--c-b)'][i%2];
+var modelRankedColors=groups=>new Map(groups.map((group,index)=>[group.key,`shade-${{index}}`]));
+var stored=new Map(),blocked={{read:false,write:false}};
+var localStorage={{getItem:key=>{{if(blocked.read)throw Error('blocked');return stored.get(key)??null;}},setItem:(key,value)=>{{if(blocked.write)throw Error('quota');stored.set(key,String(value));}}}};
+const start=page.indexOf('// deck-pure-start'),end=page.indexOf('// deck-pure-end');
+if(start<0||end<0)throw Error('missing deck-pure block');
+eval(page.slice(start,end).replace(/^const /gm,'var '));
+const richState={{
+ total_tokens:82702828,total_cost:38.59,turns:703,provider:'claude',primary_model:'claude-opus-5-5',
+ context:{{latest:112214,peak:325998,window:200000,latest_pct:.56}},
+ xsession:{{
+  total_sessions:2179,model_mix:[{{model:'gpt-5.6-sol',runtime:'Codex',providers:['codex'],cost:4278}}],
+  capabilities:{{summary:{{definitions:{{definition_tokens:120000,unused_eager_definition_tokens:83907}}}}}},
+  agent_usage:{{totals:{{agents:646,cost_covered_agents:640,known_cost:1001.45}}}},
+  budget:{{month:'2026-10',configured:true,budget:8940,spend:1792.7,percent:.2,projection_ready:true,projected_spend:3704.9,state:'on_track'}},
+ }},
+}};
+const frameSlides=DECK_SLIDES.map((slide,index)=>({{slide,index}})).filter(row=>row.slide.frame);
+{body}
+"""
+
+    def _run_tour(self, body):
+        completed = subprocess.run(
+            ["node", "-e", self._tour_script(body)], capture_output=True, text=True,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        return json.loads(completed.stdout)
+
+    @staticmethod
+    def page_function(page, name):
+        start = page.index("function {}(".format(name))
+        depth = 0
+        for index in range(start, len(page)):
+            if page[index] == "{":
+                depth += 1
+            elif page[index] == "}":
+                depth -= 1
+                if depth == 0:
+                    return page[start:index + 1]
+        raise AssertionError(name)
diff --git a/tests/meter_support.py b/tests/meter_support.py
new file mode 100644
index 00000000..e8189f3c
--- /dev/null
+++ b/tests/meter_support.py
@@ -0,0 +1,146 @@
+"""Shared fixtures for the server, dashboard, and runtime test modules."""
+
+import unittest
+import contextlib
+import http.client
+import json
+import sqlite3
+import tempfile
+import threading
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class _TrackingSqliteConnection:
+    """Wrap a real sqlite3 connection and record whether close() ever ran."""
+
+    def __init__(self, connection):
+        object.__setattr__(self, "_connection", connection)
+        object.__setattr__(self, "closed", False)
+
+    def __getattr__(self, name):
+        return getattr(self._connection, name)
+
+    def __setattr__(self, name, value):
+        setattr(self._connection, name, value)
+
+    def close(self):
+        object.__setattr__(self, "closed", True)
+        return self._connection.close()
+
+    def __enter__(self):
+        self._connection.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return self._connection.__exit__(exc_type, exc, tb)
+
+
+def isolated_pricing_state():
+    """Isolate module-level repricing state for tests that run the watcher.
+
+    Another test can leave a stale pricing revision or a running recalculation;
+    the watcher would then start a real background reprice or skip its
+    cross-session refresh. Use as a context manager around ``meter.watcher()``.
+    """
+    stack = contextlib.ExitStack()
+    stack.enter_context(mock.patch.dict(
+        meter._pricing_state, {"cache_revision": None, "fingerprint_key": None, "fingerprint": None}))
+    stack.enter_context(mock.patch.dict(
+        meter._pricing_recalc, {"running": False, "pending": False, "thread": None}))
+    stack.enter_context(mock.patch.object(meter, "pricing_watch_tick", return_value=False))
+    return stack
+
+
+class LocalApiHttpBase(unittest.TestCase):
+    """A loopback server with temp settings and API token for the local API tests."""
+
+    def setUp(self):
+        meter._reset_cost_discount_cache()
+        self.addCleanup(meter._reset_cost_discount_cache)
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.tmp = Path(self._tmp.name)
+        self.settings = self.tmp / "settings.json"
+        self.token_path = self.tmp / "api-token"
+        self.server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
+        self.port = self.server.server_port
+        thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        thread.start()
+
+        def stop():
+            self.server.shutdown()
+            self.server.server_close()
+            thread.join(timeout=5)
+        self.addCleanup(stop)
+        self.scheduled = mock.Mock(return_value="scheduled")
+        for patcher in (
+            mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(self.settings)),
+            mock.patch.object(meter, "TOKEN_METER_API_TOKEN", str(self.token_path)),
+            mock.patch.object(meter, "PORT", self.port),
+            mock.patch.object(meter, "schedule_pricing_recalculation", self.scheduled),
+            mock.patch.object(meter, "STATE", {"ok": True, "xsession": {"pricing_revision": "p_old"}}),
+            mock.patch.dict(meter._pricing_recalc, {"running": False, "pending": False}),
+        ):
+            patcher.start()
+            self.addCleanup(patcher.stop)
+        self.token = meter.ensure_api_token()
+
+    def request(self, method, path, body=None, *, bearer=True, action=False, host=None,
+                origin=None, client=None, raw=None, content_type="application/json"):
+        conn = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
+        data = raw if raw is not None else (json.dumps(body).encode() if body is not None else b"")
+        headers = {"Host": host or "127.0.0.1:{}".format(self.port)}
+        if data or method == "POST":
+            headers.update({"Content-Type": content_type, "Content-Length": str(len(data))})
+        if bearer:
+            headers["Authorization"] = "Bearer " + (bearer if isinstance(bearer, str) else self.token)
+        if action:
+            headers["X-Token-Meter-Action"] = meter._ACTION_TOKEN
+        if origin:
+            headers["Origin"] = origin
+        if client is not None:
+            headers["X-Token-Meter-Client"] = client
+        conn.putrequest(method, path, skip_host=True)
+        for key, value in headers.items():
+            conn.putheader(key, value)
+        conn.endheaders()
+        if data:
+            conn.send(data)
+        response = conn.getresponse()
+        text = response.read().decode()
+        conn.close()
+        try:
+            return response.status, json.loads(text), text
+        except json.JSONDecodeError:
+            return response.status, None, text
+
+
+_REAL_SCHEDULE = meter.schedule_pricing_recalculation
+_REAL_REFRESH = meter.refresh_cross_session_state
+
+
+class DiscountPricingFixture(unittest.TestCase):
+    """Temp settings file with discount rules for pricing behaviour tests."""
+
+    T0 = 1_788_000_000
+
+    def setUp(self):
+        meter._reset_cost_discount_cache()
+        self.addCleanup(meter._reset_cost_discount_cache)
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.tmp = Path(self._tmp.name)
+        self.path = self.tmp / "settings.json"
+        patcher = mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(self.path))
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.rules()
+
+    def rules(self, *rules):
+        self.path.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [
+            {"id": "d_rule{:04d}".format(index), "price_list": price_list, "channel": channel,
+             "percent": percent, "start": start, "end": None}
+            for index, (price_list, channel, percent, start) in enumerate(rules)]}}))
+        meter._reset_cost_discount_cache()
diff --git a/tests/opencode_test_support.py b/tests/opencode_test_support.py
new file mode 100644
index 00000000..501f24e7
--- /dev/null
+++ b/tests/opencode_test_support.py
@@ -0,0 +1,156 @@
+"""Shared setup and helpers for the OpenCodeTests split."""
+
+import unittest
+import json
+import sqlite3
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class OpenCodeCase(unittest.TestCase):
+    """OpenCode is discovered from its read-only SQLite database."""
+
+    def _build_db(self, root):
+        db_path = Path(root) / "opencode.db"
+        conn = sqlite3.connect(db_path)
+        conn.execute("CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, parent_id TEXT, "
+                     "slug TEXT, directory TEXT, title TEXT, version TEXT, time_created INTEGER, "
+                     "time_updated INTEGER, time_archived INTEGER, agent TEXT, model TEXT, cost REAL, "
+                     "tokens_input INTEGER, tokens_output INTEGER, tokens_reasoning INTEGER, "
+                     "tokens_cache_read INTEGER, tokens_cache_write INTEGER)")
+        conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER, "
+                     "time_updated INTEGER, data TEXT)")
+        conn.execute("CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, "
+                     "time_created INTEGER, time_updated INTEGER, data TEXT)")
+        conn.execute("CREATE TABLE todo (id TEXT PRIMARY KEY, session_id TEXT)")
+        return conn
+
+    def _session_row(self, sid, directory, title, model, cost, inp, out, rea, cr, cw,
+                     updated, parent_id=None, archived=None, agent="build",
+                     provider_id="opencode-go"):
+        return {
+            "id": sid, "project_id": "proj", "parent_id": parent_id, "slug": sid,
+            "directory": directory, "title": title, "version": "1.18.14",
+            "time_created": updated - 1000, "time_updated": updated,
+            "time_archived": archived, "agent": agent,
+            "model": json.dumps({"id": model, "providerID": provider_id, "variant": "high"}),
+            "cost": cost, "tokens_input": inp, "tokens_output": out,
+            "tokens_reasoning": rea, "tokens_cache_read": cr, "tokens_cache_write": cw,
+        }
+
+    def _message(self, mid, sid, data, created):
+        return (mid, sid, created, created, json.dumps(data))
+
+    def _pricing_state(self, root, model, provider_id, cache_read=5000,
+                       prices=None, cost=0.0123, messages=True):
+        root = Path(root)
+        base = 1_784_548_900_000
+        conn = self._build_db(root)
+        row = self._session_row("ses_priced", "/repo", "Priced", model,
+                                cost, 1000, 200, 0, cache_read, 0,
+                                base, provider_id=provider_id)
+        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                     tuple(row.values()))
+        if messages:
+            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (
+                "msg_priced", "ses_priced", base, base + 500, json.dumps({
+                    "role": "assistant", "modelID": model, "providerID": provider_id,
+                    "time": {"created": base, "completed": base + 500},
+                    "tokens": {"input": 1000, "output": 200, "reasoning": 0,
+                               "cache": {"read": cache_read, "write": 0}},
+                    "cost": cost, "finish": "stop",
+                }),
+            ))
+        conn.commit()
+        conn.close()
+        settings = Path(root) / "settings.json"
+        settings.write_text(json.dumps({"model_pricing": prices or {}}))
+        with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(settings)), \
+                mock.patch.object(meter, "_opencode_native_adapters", {}):
+            source = meter.opencode_session_sources()[0]
+            return meter.recompute_opencode(source)
+
+    def _insert_sessions(self, conn, rows):
+        for row in rows:
+            conn.execute(
+                "INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                (row["id"], row["project_id"], row["parent_id"], row["slug"],
+                 row["directory"], row["title"], row["version"], row["time_created"],
+                 row["time_updated"], row["time_archived"], row["agent"], row["model"],
+                 row["cost"], row["tokens_input"], row["tokens_output"],
+                 row["tokens_reasoning"], row["tokens_cache_read"],
+                 row["tokens_cache_write"]),
+            )
+
+    def _child_agent_row(self, source):
+        """Return the single spawned agent record a child session emits."""
+        meter._opencode_compatibility.cache_clear() \
+            if hasattr(meter._opencode_compatibility, "cache_clear") else None
+        row = meter.session_summary(source)
+        records = row.get("_agent_records") or []
+        self.assertEqual(len(records), 1, records)
+        return records[0]
+
+    def _assistant(self, conn, mid, sid, cost, created, inp=10, out=5):
+        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (
+            mid, sid, created, created + 500, json.dumps({
+                "role": "assistant", "modelID": "model-a", "providerID": "opencode-go",
+                "time": {"created": created, "completed": created + 500},
+                "tokens": {"input": inp, "output": out, "reasoning": 0,
+                           "cache": {"read": 0, "write": 0}},
+                "cost": cost,
+            }),
+        ))
+
+    def _family_db(self, root, base, rows, messages=True):
+        """Insert sessions plus one assistant message carrying each row's cost."""
+        conn = self._build_db(root)
+        self._insert_sessions(conn, rows)
+        if messages:
+            for index, row in enumerate(rows):
+                self._assistant(conn, "m-" + row["id"], row["id"], row["cost"],
+                                base + index)
+        conn.commit()
+        conn.close()
+        return root / "opencode.db"
+
+    def _cross(self, db_path, sources=None):
+        saved = dict(meter._xsess)
+        try:
+            meter._xsess["data"], meter._xsess["at"] = None, 0
+            meter._summary_cache.clear()
+            with mock.patch.object(meter, "OPENCODE_DB", str(db_path)), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                sources = meter.opencode_session_sources() if sources is None else sources
+                cross = meter.cross_session(sources=sources)
+                family_rows = list(meter._xsess.get("sessions") or [])
+            return sources, cross, family_rows
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved)
+            meter._summary_cache.clear()
+
+    def _sample_messages(self):
+        base = 1_784_548_800_000
+        return [
+            self._message("msg1", "ses_top", {
+                "role": "assistant", "agent": "build", "modelID": "deepseek-v4-pro",
+                "providerID": "opencode-go",
+                "tokens": {"input": 1000, "output": 200, "reasoning": 50,
+                           "cache": {"write": 0, "read": 300}},
+                "cost": 0.01, "finish": "tool-calls",
+                "time": {"created": base, "completed": base + 5000},
+            }, base),
+            self._message("msg2", "ses_top", {
+                "role": "assistant", "agent": "build", "modelID": "deepseek-v4-pro",
+                "providerID": "opencode-go",
+                "tokens": {"input": 500, "output": 100, "reasoning": 0,
+                           "cache": {"write": 0, "read": 0}},
+                "cost": 0.005, "finish": "turn_complete",
+                "time": {"created": base + 60_000, "completed": base + 70_000},
+            }, base + 60_000),
+            self._message("msg3", "ses_top", {"role": "user", "text": "hi"}, base + 10_000),
+        ]
diff --git a/tests/runtimes/test_pi_adapter.py b/tests/runtimes/test_pi_adapter.py
index 612d3bd0..31c849a5 100644
--- a/tests/runtimes/test_pi_adapter.py
+++ b/tests/runtimes/test_pi_adapter.py
@@ -342,7 +342,7 @@ def test_subagent_model_id_treats_a_bare_word_after_at_as_an_account(self):
         # A model id's "@" introduces a version or a tag, never an account, so
         # a bare word such as "user@host" is rejected. This is the shipped
         # sanitizer table's privacy invariant: see
-        # test_meter.PiSubagentTests.test_child_model_sanitizer_table.
+        # test_pi_sessions.PiSubagentTests.test_child_model_sanitizer_table.
         rejected = (
             "user@host",
             "user@internal",
diff --git a/tests/test_agent_access.py b/tests/test_agent_access.py
new file mode 100644
index 00000000..f24608cf
--- /dev/null
+++ b/tests/test_agent_access.py
@@ -0,0 +1,1111 @@
+import unittest
+import json
+import os
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+
+
+class AgentAccessTests(unittest.TestCase):
+    _real_app_running = staticmethod(meter.claude_app_running)
+
+    def setUp(self):
+        patcher = mock.patch.object(meter, "claude_app_running", return_value=False)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_client_environment_prepends_wrapper_runtime_directory(self):
+        with mock.patch.dict(meter.os.environ, {"PATH": "/usr/bin:/bin"}, clear=False):
+            env = meter.agent_client_environment("/Users/test/.nvm/versions/node/v24/bin/codex")
+        self.assertEqual(env["PATH"].split(":" )[0], "/Users/test/.nvm/versions/node/v24/bin")
+        self.assertIn("/usr/bin", env["PATH"].split(":"))
+
+    def test_client_environment_keeps_symlink_directory_for_sibling_node(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            wrapper_dir = Path(tmp) / "node" / "bin"
+            target_dir = Path(tmp) / "package" / "bin"
+            wrapper_dir.mkdir(parents=True)
+            target_dir.mkdir(parents=True)
+            target = target_dir / "codex.js"
+            target.write_text("#!/usr/bin/env node\n")
+            wrapper = wrapper_dir / "codex"
+            wrapper.symlink_to(target)
+            env = meter.agent_client_environment(str(wrapper))
+        self.assertEqual(env["PATH"].split(":")[0], str(wrapper_dir))
+
+    def test_client_discovery_checks_user_bin_when_service_path_is_minimal(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            binary = Path(tmp) / ".local" / "bin" / "claude"
+            binary.parent.mkdir(parents=True)
+            binary.write_text("#!/bin/sh\n")
+            binary.chmod(0o755)
+            with mock.patch.object(meter.os.path, "expanduser",
+                                   side_effect=lambda value: tmp if value == "~" else value):
+                found = meter.agent_client_executable("claude", which=lambda name: None)
+        self.assertEqual(found, str(binary))
+
+    def test_connection_commands_use_fixed_vectors_and_user_scope(self):
+        launcher = "/Applications/Token Meter/bin/token-meter-mcp"
+        codex = meter.agent_access_command("codex", True, launcher=launcher, cli_path="/usr/bin/codex")
+        claude = meter.agent_access_command("claude", True, launcher=launcher, cli_path="/usr/bin/claude")
+        self.assertEqual(codex, ["/usr/bin/codex", "mcp", "add", "--env",
+                                "TOKEN_METER_CALLER=codex", "tokenmeter", "--", launcher])
+        self.assertEqual(claude, ["/usr/bin/claude", "mcp", "add", "--transport", "stdio",
+                                 "--scope", "user", "tokenmeter", "--env",
+                                 "TOKEN_METER_CALLER=claude", "--", launcher])
+
+    def test_codex_status_requires_exact_launcher_and_caller_environment(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher = Path(tmp) / "token-meter-mcp"
+            launcher.write_text("#!/bin/sh\n")
+            launcher.chmod(0o755)
+
+            class Completed:
+                returncode = 0
+                stdout = json.dumps({"enabled": True, "transport": {
+                    "type": "stdio", "command": str(launcher), "args": [],
+                    "env": {"TOKEN_METER_CALLER": "codex"},
+                }})
+                stderr = ""
+
+            status = meter.agent_access_client_status(
+                "codex", launcher=str(launcher), runner=lambda *a, **k: Completed(),
+                which=lambda name: f"/usr/bin/{name}")
+        self.assertTrue(status["connected"])
+        self.assertFalse(status["conflict"])
+        self.assertNotIn("/usr/bin/codex", status["connect_command"])
+
+    def test_windows_codex_status_check_does_not_create_a_console_window(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher = Path(tmp) / "token-meter-mcp"
+            launcher.write_text("#!/bin/sh\n")
+            launcher.chmod(0o755)
+            observed = {}
+
+            def runner(command, **kwargs):
+                observed.update(kwargs)
+                return meter.subprocess.CompletedProcess(command, 1, "", "missing")
+
+            windows = meter.platform_services(
+                "windows", environment={"USERPROFILE": r"C:\Users\example"},
+                home=r"C:\Users\example",
+            )
+            with mock.patch.object(meter, "_PLATFORM_SERVICES", windows):
+                meter.agent_access_client_status(
+                    "codex", launcher=str(launcher), runner=runner,
+                    which=lambda name: fr"C:\Tools\{name}.exe",
+                )
+
+        self.assertEqual(observed["creationflags"], 0x08000000)
+        self.assertTrue(observed["close_fds"])
+
+    def test_windows_connection_change_does_not_create_a_console_window(self):
+        before = {"label": "Codex", "detected": True, "available": True,
+                  "configured": False, "connected": False, "conflict": False}
+        after = {**before, "configured": True, "connected": True}
+        states = iter((before, after))
+        observed = {}
+
+        def runner(command, **kwargs):
+            observed.update(kwargs)
+            return meter.subprocess.CompletedProcess(command, 0, "", "")
+
+        windows = meter.platform_services(
+            "windows", environment={"USERPROFILE": r"C:\Users\example"},
+            home=r"C:\Users\example",
+        )
+        with mock.patch.object(meter, "_PLATFORM_SERVICES", windows), \
+                mock.patch.object(meter, "agent_access_launcher",
+                                  return_value=r"C:\Token Meter\token-meter-mcp.cmd"), \
+                mock.patch.object(meter, "agent_client_executable",
+                                  return_value=r"C:\Tools\codex.exe"):
+            result = meter.set_agent_access(
+                "codex", True, runner=runner,
+                status_getter=lambda client: next(states),
+            )
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(observed["creationflags"], 0x08000000)
+        self.assertTrue(observed["close_fds"])
+
+    def test_claude_status_reads_only_the_user_scope_entry(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher = Path(tmp) / "token-meter-mcp"
+            launcher.write_text("#!/bin/sh\n")
+            launcher.chmod(0o755)
+            config = Path(tmp) / ".claude.json"
+            config.write_text(json.dumps({"mcpServers": {"tokenmeter": {
+                "type": "stdio", "command": str(launcher), "args": [],
+                "env": {"TOKEN_METER_CALLER": "claude"},
+            }}}))
+            status = meter.agent_access_client_status(
+                "claude", launcher=str(launcher), claude_config_path=str(config),
+                which=lambda name: f"/usr/bin/{name}", claude_desktop_config_paths=[])
+        self.assertTrue(status["connected"])
+        self.assertEqual(status["label"], "Claude")
+        self.assertEqual(status["status"], "Connected to Claude Code")
+
+    def test_different_existing_entry_is_reported_as_conflict(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher = Path(tmp) / "token-meter-mcp"
+            launcher.write_text("#!/bin/sh\n")
+            launcher.chmod(0o755)
+            config = Path(tmp) / ".claude.json"
+            config.write_text(json.dumps({"mcpServers": {"tokenmeter": {
+                "type": "stdio", "command": "/tmp/different", "args": [], "env": {},
+            }}}))
+            status = meter.agent_access_client_status(
+                "claude", launcher=str(launcher), claude_config_path=str(config),
+                which=lambda name: f"/usr/bin/{name}", claude_desktop_config_paths=[])
+        self.assertFalse(status["connected"])
+        self.assertTrue(status["conflict"])
+        self.assertEqual(status["status"], "Existing entry differs from this install")
+
+    def test_conflicting_entry_requires_explicit_repair_confirmation(self):
+        before = {"label": "Codex", "detected": True, "available": True,
+                  "configured": True, "connected": False, "conflict": True}
+        runner = mock.Mock()
+        result = meter.set_agent_access("codex", True, runner=runner,
+                                        status_getter=lambda client: before)
+        self.assertFalse(result["ok"])
+        self.assertTrue(result["conflict"])
+        self.assertIn("Confirm repair", result["error"])
+        runner.assert_not_called()
+
+    def test_repair_replaces_only_named_entry_and_verifies_connection(self):
+        before = {"label": "Codex", "detected": True, "available": True,
+                  "configured": True, "connected": False, "conflict": True}
+        after = {**before, "configured": True, "connected": True, "conflict": False}
+        states = iter((before, after))
+        commands = []
+
+        class Completed:
+            returncode = 0
+            stdout = ""
+            stderr = ""
+
+        def runner(argv, **kwargs):
+            commands.append(argv)
+            self.assertNotIn("shell", kwargs)
+            return Completed()
+
+        with mock.patch.object(meter, "agent_access_launcher", return_value="/tmp/token-meter-mcp"), \
+                mock.patch.object(meter, "agent_client_executable", return_value="/usr/bin/codex"):
+            result = meter.set_agent_access("codex", True, repair=True, runner=runner,
+                                            status_getter=lambda client: next(states))
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["repaired"])
+        self.assertTrue(result["restart_required"])
+        self.assertEqual(commands, [
+            ["/usr/bin/codex", "mcp", "remove", "tokenmeter"],
+            ["/usr/bin/codex", "mcp", "add", "--env", "TOKEN_METER_CALLER=codex",
+             "tokenmeter", "--", "/tmp/token-meter-mcp"],
+        ])
+
+    def test_repair_stops_when_existing_entry_cannot_be_removed(self):
+        before = {"label": "Claude Code", "detected": True, "available": True,
+                  "configured": True, "connected": False, "conflict": True}
+
+        class Completed:
+            returncode = 1
+            stdout = ""
+            stderr = "entry is locked\n"
+
+        runner = mock.Mock(return_value=Completed())
+        absent = {"label": "Claude app", "detected": False}
+        with mock.patch.object(meter, "agent_client_executable", return_value="/usr/bin/claude"):
+            result = meter.set_agent_access("claude", True, repair=True, runner=runner,
+                                            status_getter=lambda client: absent if client == "claude_desktop" else before)
+        self.assertFalse(result["ok"])
+        self.assertTrue(result["conflict"])
+        self.assertIn("remove the existing tokenmeter entry", result["error"])
+        self.assertIn("entry is locked", result["error"])
+        runner.assert_called_once()
+
+    def test_connection_change_is_verified_after_cli_success(self):
+        before = {"label": "Codex", "detected": True, "available": True,
+                  "configured": False, "connected": False, "conflict": False}
+        after = {**before, "configured": True, "connected": True}
+        states = iter((before, after))
+        observed = {}
+
+        class Completed:
+            returncode = 0
+            stdout = ""
+            stderr = ""
+
+        def runner(argv, **kwargs):
+            observed["argv"] = argv
+            observed["kwargs"] = kwargs
+            return Completed()
+
+        with mock.patch.object(meter, "agent_access_launcher", return_value="/tmp/token-meter-mcp"):
+            result = meter.set_agent_access("codex", True, runner=runner,
+                                            status_getter=lambda client: next(states))
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["restart_required"])
+        self.assertEqual(observed["argv"][-3:], ["tokenmeter", "--", "/tmp/token-meter-mcp"])
+        self.assertNotIn("shell", observed["kwargs"])
+
+    def test_connection_failure_includes_bounded_cli_reason(self):
+        before = {"label": "Codex", "detected": True, "available": True,
+                  "configured": False, "connected": False, "conflict": False}
+
+        class Completed:
+            returncode = 127
+            stdout = ""
+            stderr = "env: node: No such file or directory\n"
+
+        with mock.patch.object(meter, "agent_access_launcher", return_value="/tmp/token-meter-mcp"), \
+                mock.patch.object(meter, "agent_client_executable", return_value="/tmp/codex"):
+            result = meter.set_agent_access("codex", True, runner=lambda *a, **k: Completed(),
+                                            status_getter=lambda client: before)
+        self.assertFalse(result["ok"])
+        self.assertIn("env: node", result["error"])
+
+    def _desktop_fixture(self, tmp, config=None, root_name="Claude"):
+        launcher = Path(tmp) / "token-meter-mcp"
+        if not launcher.exists():
+            launcher.write_text("#!/bin/sh\n")
+            launcher.chmod(0o755)
+        root = Path(tmp) / root_name
+        root.mkdir()
+        path = root / "claude_desktop_config.json"
+        if isinstance(config, bytes):
+            path.write_bytes(config)
+        elif config is not None:
+            path.write_text(config if isinstance(config, str) else json.dumps(config, indent=2))
+        return str(launcher), path
+
+    def _desktop_toggle(self, launcher, paths, enabled, repair=False):
+        paths = [str(path) for path in paths]
+        status_getter = lambda client: meter.claude_desktop_access_status(launcher, paths)
+        with mock.patch.object(meter, "CLAUDE_DESKTOP_CONFIGS", paths), \
+                mock.patch.object(meter, "agent_access_launcher", return_value=launcher):
+            return meter._set_agent_access_part("claude_desktop", enabled, repair,
+                                                mock.Mock(side_effect=AssertionError("no subprocess")),
+                                                status_getter)
+
+    def test_status_lists_the_claude_app_beside_cli_clients(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp)
+            status = meter.agent_access_status(
+                launcher=launcher, which=lambda name: None,
+                claude_config_path=str(Path(tmp) / ".claude.json"),
+                claude_desktop_config_paths=[str(path)])
+        self.assertEqual([row["id"] for row in status["clients"]], ["codex", "claude"])
+        claude = status["clients"][1]
+        self.assertEqual(claude["label"], "Claude")
+        self.assertTrue(claude["detected"])
+        self.assertTrue(claude["available"])
+        self.assertFalse(claude["configured"])
+        self.assertEqual(claude["status"], "Ready to connect")
+        self.assertTrue(status["any_detected"])
+
+    def test_claude_app_missing_is_not_detected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            status = meter.claude_desktop_access_status(
+                str(Path(tmp) / "launcher"), [str(Path(tmp) / "absent" / "claude_desktop_config.json")])
+        self.assertFalse(status["detected"])
+        self.assertFalse(status["available"])
+        self.assertEqual(status["status"], "App not found")
+
+    def test_claude_app_connect_changes_only_the_tokenmeter_entry(self):
+        existing = {"preferences": {"sidebarMode": "chat", "name": "caf\u00e9"},
+                    "mcpServers": {"other": {"command": "/bin/other", "args": ["x"], "env": {"K": "v"}}}}
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp, existing)
+            path.chmod(0o600)
+            result = self._desktop_toggle(launcher, [path], True)
+            saved = json.loads(path.read_text(encoding="utf-8"))
+            mode = path.stat().st_mode & 0o777
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["client"]["connected"])
+        self.assertIn("Quit and reopen the Claude app", result["message"])
+        self.assertEqual(saved["preferences"], existing["preferences"])
+        self.assertEqual(saved["mcpServers"]["other"], existing["mcpServers"]["other"])
+        self.assertEqual(saved["mcpServers"]["tokenmeter"], {
+            "command": launcher, "args": [], "env": {"TOKEN_METER_CALLER": "claude"}})
+        self.assertEqual(mode, 0o600)
+
+    def test_claude_app_connect_writes_every_app_config_including_third_party_mode(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, first = self._desktop_fixture(tmp, {"preferences": {}})
+            _, third_party = self._desktop_fixture(tmp, {"deploymentMode": "3p", "mcpServers": {
+                "other": {"command": "/bin/other"}}}, root_name="Claude-3p")
+            partial = meter.claude_desktop_access_status(launcher, [str(first), str(third_party)])
+            meter.write_claude_desktop_access(True, launcher, [str(first)])
+            half = meter.claude_desktop_access_status(launcher, [str(first), str(third_party)])
+            result = self._desktop_toggle(launcher, [first, third_party], True)
+            saved = [json.loads(path.read_text()) for path in (first, third_party)]
+        self.assertFalse(partial["connected"])
+        self.assertFalse(half["connected"])
+        self.assertEqual(partial["status"], "Ready to connect")
+        self.assertEqual(half["status"], "Connected in only one Claude app config")
+        self.assertTrue(result["ok"])
+        for config in saved:
+            self.assertEqual(config["mcpServers"]["tokenmeter"], meter.claude_desktop_access_entry(launcher))
+        self.assertEqual(saved[1]["deploymentMode"], "3p")
+        self.assertEqual(saved[1]["mcpServers"]["other"], {"command": "/bin/other"})
+
+    def test_claude_app_only_third_party_root_is_detected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, third_party = self._desktop_fixture(tmp, {}, root_name="Claude-3p")
+            absent = Path(tmp) / "Claude" / "claude_desktop_config.json"
+            result = self._desktop_toggle(launcher, [absent, third_party], True)
+            self.assertFalse(absent.parent.exists())
+            saved = json.loads(third_party.read_text())
+        self.assertTrue(result["ok"])
+        self.assertIn("tokenmeter", saved["mcpServers"])
+
+    def test_claude_app_connect_creates_a_missing_config(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp)
+            self.assertIsNone(meter.write_claude_desktop_access(True, launcher, [str(path)]))
+            status = meter.claude_desktop_access_status(launcher, [str(path)])
+            saved = json.loads(path.read_text())
+        self.assertTrue(status["connected"])
+        self.assertEqual(list(saved), ["mcpServers"])
+
+    def test_claude_app_disconnect_removes_only_the_tokenmeter_entry(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp)
+            path.write_text(json.dumps({"keep": 1, "mcpServers": {
+                "other": {"command": "/bin/other"},
+                "tokenmeter": meter.claude_desktop_access_entry(launcher)}}))
+            result = self._desktop_toggle(launcher, [path], False)
+            saved = json.loads(path.read_text())
+        self.assertTrue(result["ok"])
+        self.assertEqual(saved, {"keep": 1, "mcpServers": {"other": {"command": "/bin/other"}}})
+
+    def test_claude_app_conflict_needs_repair_then_replaces_only_that_entry(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp, {"mcpServers": {
+                "other": {"command": "/bin/other"},
+                "tokenmeter": {"command": "/tmp/different", "args": [], "env": {}}}})
+            refused = self._desktop_toggle(launcher, [path], True)
+            untouched = json.loads(path.read_text())
+            repaired = self._desktop_toggle(launcher, [path], True, repair=True)
+            saved = json.loads(path.read_text())
+        self.assertFalse(refused["ok"])
+        self.assertTrue(refused["conflict"])
+        self.assertEqual(untouched["mcpServers"]["tokenmeter"]["command"], "/tmp/different")
+        self.assertTrue(repaired["ok"])
+        self.assertTrue(repaired["repaired"])
+        self.assertEqual(saved["mcpServers"]["tokenmeter"], meter.claude_desktop_access_entry(launcher))
+        self.assertEqual(saved["mcpServers"]["other"], {"command": "/bin/other"})
+
+    def test_claude_app_config_that_cannot_be_parsed_is_left_unchanged(self):
+        for raw in (b"{not json", b'["list"]', b'{"mcpServers": []}', b"", b'{"a": "\xff\xfe"}'):
+            with self.subTest(raw=raw), tempfile.TemporaryDirectory() as tmp:
+                launcher, path = self._desktop_fixture(tmp, raw)
+                status = meter.claude_desktop_access_status(launcher, [str(path)])
+                error = meter.write_claude_desktop_access(True, launcher, [str(path)])
+                toggled = self._desktop_toggle(launcher, [path], True)
+                self.assertEqual(status["status"], "Claude app config could not be read")
+                self.assertTrue(status["unreadable"])
+                self.assertTrue(status["available"])
+                self.assertIn("left", error)
+                self.assertNotIn(tmp, error)
+                self.assertFalse(toggled["ok"])
+                self.assertIn("could not read", toggled["error"])
+                self.assertEqual(path.read_bytes(), raw)
+
+    def _claude_fixture(self, tmp, code_entry=None, app_config=None):
+        launcher, app_path = self._desktop_fixture(tmp, app_config)
+        code_path = Path(tmp) / ".claude.json"
+        code_path.write_text(json.dumps({"mcpServers": {"tokenmeter": code_entry}} if code_entry else {"keep": 1}))
+        calls = []
+
+        def runner(argv, **kwargs):
+            calls.append(argv)
+            data = json.loads(code_path.read_text())
+            servers = data.setdefault("mcpServers", {})
+            if argv[1:3] == ["mcp", "add"]:
+                servers["tokenmeter"] = {"type": "stdio", "command": argv[-1], "args": [],
+                                         "env": {"TOKEN_METER_CALLER": "claude"}}
+            elif argv[1:3] == ["mcp", "remove"]:
+                servers.pop("tokenmeter", None)
+            code_path.write_text(json.dumps(data))
+            return meter.subprocess.CompletedProcess(argv, 0, "", "")
+
+        def status_getter(client):
+            return meter.agent_access_client_status(
+                client, launcher=launcher, which=lambda name: f"/usr/bin/{name}",
+                claude_config_path=str(code_path), claude_desktop_config_paths=[str(app_path)])
+
+        return launcher, code_path, app_path, runner, calls, status_getter
+
+    def _claude_toggle(self, launcher, app_path, runner, status_getter, enabled, repair=False):
+        with mock.patch.object(meter, "CLAUDE_DESKTOP_CONFIGS", [str(app_path)]), \
+                mock.patch.object(meter, "agent_access_launcher", return_value=launcher), \
+                mock.patch.object(meter, "agent_client_executable", return_value="/usr/bin/claude"):
+            return meter.set_agent_access("claude", enabled, repair=repair, runner=runner,
+                                          status_getter=status_getter)
+
+    def test_one_claude_connect_sets_up_claude_code_and_the_claude_app(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={"keep": 2})
+            before = getter("claude")
+            result = self._claude_toggle(launcher, app_path, runner, getter, True)
+            app = json.loads(app_path.read_text())
+            code = json.loads(code_path.read_text())
+        self.assertEqual(before["status"], "Ready to connect")
+        self.assertEqual(before["connect_command"].count("\n"), 1)
+        self.assertTrue(result["ok"], result)
+        self.assertTrue(result["client"]["connected"])
+        self.assertEqual(result["client"]["status"], "Connected to Claude Code and the Claude app")
+        self.assertEqual(result["message"],
+                         "Claude connected. Start a new Claude Code session and reopen the Claude app.")
+        self.assertEqual([argv[1:3] for argv in calls], [["mcp", "add"]])
+        self.assertEqual(app["keep"], 2)
+        self.assertEqual(app["mcpServers"]["tokenmeter"], meter.claude_desktop_access_entry(launcher))
+        self.assertEqual(code["mcpServers"]["tokenmeter"]["command"], launcher)
+
+    def test_one_claude_disconnect_removes_both(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
+            self._claude_toggle(launcher, app_path, runner, getter, True)
+            result = self._claude_toggle(launcher, app_path, runner, getter, False)
+            app = json.loads(app_path.read_text())
+            code = json.loads(code_path.read_text())
+        self.assertTrue(result["ok"], result)
+        self.assertFalse(result["client"]["configured"])
+        self.assertNotIn("tokenmeter", app["mcpServers"])
+        self.assertNotIn("tokenmeter", code["mcpServers"])
+
+    def test_running_claude_app_is_skipped_but_claude_code_still_connects(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
+            with mock.patch.object(meter, "claude_app_running", return_value=True):
+                status = getter("claude")
+                result = self._claude_toggle(launcher, app_path, runner, getter, True)
+            app = json.loads(app_path.read_text())
+            code = json.loads(code_path.read_text())
+        self.assertFalse(status["blocked"])
+        self.assertEqual(status["status"], "Ready to connect. Quit the Claude app to change its connection")
+        self.assertTrue(result["ok"], result)
+        self.assertTrue(result["partial"])
+        self.assertIn("Quit the Claude app first", result["message"])
+        self.assertIn("click Connect again", result["message"])
+        self.assertEqual(result["client"]["status"],
+                         "Connected to Claude Code only. Quit the Claude app to change its connection")
+        self.assertTrue(result["client"]["blocked"])
+        self.assertEqual(app, {})
+        self.assertIn("tokenmeter", code["mcpServers"])
+
+    def test_running_claude_app_blocks_when_only_the_app_is_left(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
+            self._claude_toggle(launcher, app_path, runner, getter, True)
+            app_before = app_path.read_bytes()
+            code_before = code_path.read_bytes()
+            calls.clear()
+            with mock.patch.object(meter, "claude_app_running", return_value=True):
+                status = getter("claude")
+                result = self._claude_toggle(launcher, app_path, runner, getter, False)
+            self.assertEqual(code_path.read_bytes(), code_before)
+            self.assertEqual(app_path.read_bytes(), app_before)
+        self.assertTrue(status["connected"])
+        self.assertTrue(status["blocked"])
+        self.assertFalse(result["ok"])
+        self.assertIn("Quit the Claude app first", result["error"])
+        self.assertEqual(calls, [])
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, _, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
+            with mock.patch.object(meter, "claude_app_running", return_value=True):
+                meter.write_claude_desktop_access(False, launcher, [str(app_path)])
+                self._claude_toggle(launcher, app_path, runner, getter, True)
+                calls.clear()
+                refused = self._claude_toggle(launcher, app_path, runner, getter, True)
+                blocked = getter("claude")
+        self.assertFalse(refused["ok"])
+        self.assertIn("Quit the Claude app first", refused["error"])
+        self.assertEqual(calls, [])
+        self.assertTrue(blocked["blocked"])
+
+    def test_unreadable_claude_app_config_does_not_stop_claude_code(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config=b"{bad")
+            result = self._claude_toggle(launcher, app_path, runner, getter, True)
+            self.assertEqual(app_path.read_bytes(), b"{bad")
+        self.assertTrue(result["ok"], result)
+        self.assertTrue(result["partial"])
+        self.assertIn("could not read", result["message"])
+        self.assertEqual(result["client"]["status"],
+                         "Connected to Claude Code only. The Claude app config could not be read")
+        self.assertTrue(result["client"]["blocked"])
+
+    def test_running_claude_app_does_not_block_finishing_claude_code(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, _, app_path, runner, calls, getter = self._claude_fixture(tmp)
+            meter.write_claude_desktop_access(True, launcher, [str(app_path)])
+            with mock.patch.object(meter, "claude_app_running", return_value=True):
+                partial = getter("claude")
+                result = self._claude_toggle(launcher, app_path, runner, getter, True)
+        self.assertEqual(partial["status"], "Connected to the Claude app only")
+        self.assertFalse(partial["blocked"])
+        self.assertTrue(result["ok"], result)
+        self.assertEqual([argv[1:3] for argv in calls], [["mcp", "add"]])
+
+    def test_claude_code_only_machine_still_connects_with_one_button(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, _, runner, calls, _ = self._claude_fixture(tmp)
+            getter = lambda client: meter.agent_access_client_status(
+                client, launcher=launcher, which=lambda name: f"/usr/bin/{name}",
+                claude_config_path=str(code_path), claude_desktop_config_paths=[])
+            result = self._claude_toggle(launcher, Path(tmp) / "absent" / "c.json", runner, getter, True)
+        self.assertTrue(result["ok"], result)
+        self.assertEqual(result["message"], "Claude connected. Start a new Claude Code session.")
+
+    def test_claude_app_running_is_checked_only_where_the_host_can_tell(self):
+        seen = []
+
+        def runner(argv, **kwargs):
+            seen.append(argv)
+            self.assertNotIn("shell", kwargs)
+            return meter.subprocess.CompletedProcess(argv, self._pgrep_code, "", "")
+
+        for platform_id, code, expected in (("macos", 0, True), ("macos", 1, False),
+                                            ("windows", 0, None), ("linux", 0, None)):
+            self._pgrep_code = code
+            with self.subTest(platform_id=platform_id, code=code), \
+                    mock.patch.object(meter._PLATFORM_SERVICES, "platform_id", platform_id):
+                self.assertEqual(self._real_app_running(runner), expected)
+        self.assertEqual(seen, [["pgrep", "-a", "-x", "Claude"]] * 2)
+
+    def test_disconnect_is_refused_while_a_claude_app_config_is_unreadable(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config=b"{bad")
+            self._claude_toggle(launcher, app_path, runner, getter, True)
+            code_before = code_path.read_bytes()
+            calls.clear()
+            result = self._claude_toggle(launcher, app_path, runner, getter, False)
+            self.assertEqual(code_path.read_bytes(), code_before)
+            self.assertEqual(app_path.read_bytes(), b"{bad")
+        self.assertFalse(result["ok"])
+        self.assertIn("could not read", result["error"])
+        self.assertEqual(calls, [])
+
+    def test_repair_message_reflects_whether_anything_was_repaired(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, _, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={"mcpServers": {
+                "tokenmeter": {"command": "/tmp/different", "args": [], "env": {}}}})
+            with mock.patch.object(meter, "claude_app_running", return_value=True):
+                result = self._claude_toggle(launcher, app_path, runner, getter, True, repair=True)
+        self.assertTrue(result["ok"], result)
+        self.assertFalse(result["repaired"])
+        self.assertTrue(result["message"].startswith("Claude Code connected."))
+
+    def test_malformed_tokenmeter_entries_are_conflicts_not_crashes(self):
+        for entry in ({"command": "c", "env": "x"}, {"command": "c", "args": 5, "env": {}},
+                      "oops", None, ["list"], {"env": {"TOKEN_METER_CALLER": "claude"}, "args": "x"}):
+            with self.subTest(entry=entry), tempfile.TemporaryDirectory() as tmp:
+                launcher, path = self._desktop_fixture(tmp, {"mcpServers": {"tokenmeter": entry}})
+                before = path.read_bytes()
+                status = meter.agent_access_status(
+                    launcher=launcher, which=lambda name: None,
+                    claude_config_path=str(Path(tmp) / ".claude.json"),
+                    claude_desktop_config_paths=[str(path)])["clients"][1]
+                refused = self._desktop_toggle(launcher, [path], True)
+                self.assertTrue(status["conflict"])
+                self.assertFalse(status["connected"])
+                self.assertFalse(refused["ok"])
+                self.assertEqual(path.read_bytes(), before)
+
+    def test_unreadable_config_wins_over_a_conflict_in_another_config(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, conflicting = self._desktop_fixture(tmp, {"mcpServers": {
+                "tokenmeter": {"command": "/tmp/different", "args": [], "env": {}}}})
+            _, unreadable = self._desktop_fixture(tmp, b"{bad", root_name="Claude-3p")
+            status = meter.claude_desktop_access_status(launcher, [str(conflicting), str(unreadable)])
+            toggled = self._desktop_toggle(launcher, [conflicting, unreadable], True, repair=True)
+            saved = json.loads(conflicting.read_text())
+        self.assertEqual(status["status"], "Claude app config could not be read")
+        self.assertFalse(toggled["ok"])
+        self.assertIn("could not read", toggled["error"])
+        self.assertEqual(saved["mcpServers"]["tokenmeter"]["command"], "/tmp/different")
+
+    def test_settings_row_shows_unreadable_claude_app_config_instead_of_launcher_error(self):
+        page = Path(DASHBOARD_PAGE).read_text()
+        self.assertIn("const disabled=!row.connected&&!row.available;", page)
+        self.assertIn("try{refreshed=await loadAgentAccess();}finally{agentAccessRechecking=false;}", page)
+        self.assertIn("if(!button||button.disabled)return;", page)
+        self.assertIn("title:'Quit the Claude app first'", page)
+        self.assertIn("title:'Claude app settings could not be read'", page)
+        self.assertIn("const action=row.connected?'Disconnect':row.conflict?'Repair':'Connect';", page)
+        self.assertIn("if(row)openAgentAccessDialog(client,!row.connected);", page)
+        self.assertIn("!row.detected?(row.id==='claude'?row.status:'CLI not found'):"
+                      "!row.available?'Token Meter launcher unavailable':row.status", page)
+
+    def test_unreadable_claude_app_config_does_not_break_other_clients(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp, b"\xff\xfe\x00")
+            status = meter.agent_access_status(
+                launcher=launcher, which=lambda name: None,
+                claude_config_path=str(Path(tmp) / ".claude.json"),
+                claude_desktop_config_paths=[str(path)])
+        self.assertTrue(status["ok"])
+        self.assertIn("The Claude app config could not be read", status["clients"][1]["status"])
+        self.assertEqual(status["clients"][0]["id"], "codex")
+
+    def test_claude_app_write_keeps_a_symlinked_config_linked(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp)
+            real = Path(tmp) / "dotfiles.json"
+            real.write_text(json.dumps({"keep": True}))
+            path.symlink_to(real)
+            self.assertIsNone(meter.write_claude_desktop_access(True, launcher, [str(path)]))
+            self.assertTrue(path.is_symlink())
+            saved = json.loads(real.read_text())
+        self.assertTrue(saved["keep"])
+        self.assertIn("tokenmeter", saved["mcpServers"])
+
+    def test_claude_app_refuses_to_overwrite_a_config_changed_mid_save(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            launcher, path = self._desktop_fixture(tmp, {"preferences": {"v": 1}})
+            original = meter._read_claude_desktop_config
+
+            def app_writes_during_read(target):
+                result = original(target)
+                Path(target).write_text(json.dumps({"preferences": {"v": 2}, "extra": "app"}))
+                return result
+
+            with mock.patch.object(meter, "_read_claude_desktop_config", side_effect=app_writes_during_read):
+                error = meter.write_claude_desktop_access(True, launcher, [str(path)])
+            saved = json.loads(path.read_text())
+        self.assertIn("changed its config", error)
+        self.assertEqual(saved, {"preferences": {"v": 2}, "extra": "app"})
+
+    def test_windows_claude_app_entry_runs_cmd_launcher_through_cmd_exe(self):
+        launcher = r"C:\Token Meter\scripts\run-token-meter-mcp.cmd"
+        entry = meter.claude_desktop_access_entry(launcher)
+        self.assertEqual(entry["command"], "cmd.exe")
+        self.assertEqual(entry["args"], ["/c", launcher])
+        self.assertTrue(meter._claude_desktop_entry_matches(entry, launcher))
+        self.assertFalse(meter._claude_desktop_entry_matches(
+            {"command": launcher, "args": [], "env": {"TOKEN_METER_CALLER": "claude"}}, launcher))
+
+
+class CapabilityConfigTests(unittest.TestCase):
+    def test_skill_catalog_cache_avoids_rescanning_but_refreshes_usage(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            skill = Path(tmp) / "custom" / "SKILL.md"
+            skill.parent.mkdir()
+            skill.write_text("---\nname: custom\n---\n")
+            codex_pattern = os.path.join(
+                os.path.expanduser("~/.codex/skills"), "**", "SKILL.md",
+            )
+
+            def matching_glob(pattern, recursive=False):
+                del recursive
+                return [str(skill)] if pattern == codex_pattern else []
+
+            meter.invalidate_discovered_skill_cache()
+            try:
+                with mock.patch.object(meter.glob, "glob", side_effect=matching_glob), \
+                        mock.patch.object(
+                            meter, "_skill_measurability", return_value="unknown",
+                        ) as measurability:
+                    first = meter.discovered_skills([{
+                        "name": "custom", "providers": ["codex"],
+                        "activations": 1, "sessions_used": 1,
+                        "last_used": "2026-08-18",
+                    }])
+                    second = meter.discovered_skills([{
+                        "name": "custom", "providers": ["codex"],
+                        "activations": 2, "sessions_used": 2,
+                        "last_used": "2026-08-19",
+                    }])
+            finally:
+                meter.invalidate_discovered_skill_cache()
+
+        self.assertEqual(measurability.call_count, 1)
+        self.assertEqual(first[0]["activations"], 1)
+        self.assertEqual(second[0]["activations"], 2)
+        self.assertEqual(second[0]["measurement"], "measurable")
+
+    def scan_claude_skill_rows(self, root, sources):
+        projects = root / "claude-projects"
+        meter.invalidate_discovered_skill_cache()
+        try:
+            with mock.patch.object(meter, "CLAUDE_USER_SKILLS", str(root / "user-skills")), \
+                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(projects)), \
+                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
+                    mock.patch.object(meter, "claude_plugin_installations", return_value={}), \
+                    mock.patch.object(meter, "source_inventory_snapshot",
+                                      return_value={"sources": tuple(sources)}):
+                rows = meter.discovered_skills()
+        finally:
+            meter.invalidate_discovered_skill_cache()
+        return [row for row in rows if row["runtime"] == "Claude"]
+
+    def test_inventory_lists_personal_and_session_project_claude_skills(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for skill_dir in (root / "user-skills" / "personal-helper",
+                              root / "repo" / ".claude" / "skills" / "repo-review",
+                              root / "codex-repo" / ".claude" / "skills" / "not-claude"):
+                skill_dir.mkdir(parents=True)
+                (skill_dir / "SKILL.md").write_text("---\nname: x\n---\n")
+            session = str(root / "claude-projects" / "p" / "s.jsonl")
+            rows = self.scan_claude_skill_rows(root, [
+                {"provider": "claude", "path": session, "project": str(root / "repo")},
+                {"provider": "claude", "path": session, "project": str(root / "repo")},
+                {"provider": "claude", "path": session, "project": "local"},
+                {"provider": "codex", "path": "/tmp/c.jsonl", "project": str(root / "codex-repo")},
+            ])
+
+        by_name = {row["name"]: row for row in rows}
+        self.assertEqual(set(by_name), {"personal-helper", "repo-review"})
+        self.assertEqual(by_name["personal-helper"]["source"], "Personal")
+        self.assertEqual(by_name["repo-review"]["source"], "Project")
+        self.assertEqual(by_name["repo-review"]["origin_id"], "claude:project")
+        self.assertTrue(by_name["repo-review"]["enabled"])
+        self.assertFalse(by_name["repo-review"]["mutable"])
+
+    def test_project_skill_roots_are_bounded(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            session = os.path.join(tmp, "claude-projects", "p", "s.jsonl")
+            sources = [
+                {"provider": "claude", "path": session, "project": f"/work/repo-{index}"}
+                for index in range(meter.MAX_PROJECT_SKILL_ROOTS + 10)
+            ]
+            with mock.patch.object(meter, "CLAUDE_PROJECTS", os.path.join(tmp, "claude-projects")), \
+                    mock.patch.object(meter, "source_inventory_snapshot",
+                                      return_value={"sources": tuple(sources)}):
+                roots = meter.claude_project_skill_roots()
+        self.assertEqual(len(roots), meter.MAX_PROJECT_SKILL_ROOTS)
+
+    def test_personal_skill_wins_name_clash_and_first_project_wins(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for skill_dir in (root / "user-skills" / "review",
+                              root / "a" / ".claude" / "skills" / "review",
+                              root / "a" / ".claude" / "skills" / "deploy",
+                              root / "b" / ".claude" / "skills" / "deploy"):
+                skill_dir.mkdir(parents=True)
+                (skill_dir / "SKILL.md").write_text("---\nname: x\n---\n")
+            session = str(root / "claude-projects" / "p" / "s.jsonl")
+            rows = self.scan_claude_skill_rows(root, [
+                {"provider": "claude", "path": session, "project": str(root / "a")},
+                {"provider": "claude", "path": session, "project": str(root / "b")},
+            ])
+
+        self.assertEqual(sorted((row["name"], row["source"]) for row in rows),
+                         [("deploy", "Project"), ("review", "Personal")])
+        deploy = next(row for row in rows if row["name"] == "deploy")
+        self.assertIn(os.path.join("a", ".claude", "skills", "deploy"), deploy["path"])
+
+    def test_skill_catalog_rescans_once_session_inventory_is_ready(self):
+        snapshot = {"ready": False, "sources": ()}
+        meter.invalidate_discovered_skill_cache()
+        try:
+            with mock.patch.object(meter, "source_inventory_snapshot", side_effect=lambda: snapshot), \
+                    mock.patch.object(meter, "_scan_discovered_skills", return_value=[]) as scan:
+                meter.discovered_skills()
+                meter.discovered_skills()
+                snapshot = {"ready": True, "sources": ()}
+                meter.discovered_skills()
+                meter.discovered_skills()
+        finally:
+            meter.invalidate_discovered_skill_cache()
+        self.assertEqual(scan.call_count, 2)
+
+    def test_only_native_skill_tool_calls_count_as_native_activations(self):
+        evidence = meter.summarize_tool_evidence([
+            {**meter.tool_identity("Skill"), "output_tokens": 0, "ts": 100,
+             "args_fingerprint": "a", "error": False, "skills": ["repo-review"]},
+            {**meter.tool_identity("Read"), "output_tokens": 0, "ts": 101,
+             "args_fingerprint": "b", "error": False,
+             "skills": meter.skill_names_from_value(
+                 {"file_path": "/r/.agents/skills/adapter-only/SKILL.md"}, "Read")},
+        ])
+        session = os.path.join(meter.CLAUDE_PROJECTS, "p", "s.jsonl")
+        waste = meter.global_tool_waste([{
+            "id": "s", "provider": "claude", "project": "/r", "path": session,
+            "_tool_evidence": evidence,
+        }])
+        hosts = {row["name"]: row["hosts"]["Claude"] for row in waste["skills"]}
+        self.assertEqual(hosts["repo-review"]["native_activations"], 1)
+        self.assertEqual(hosts["adapter-only"]["activations"], 1)
+        self.assertEqual(hosts["adapter-only"]["native_activations"], 0)
+
+        meter.invalidate_discovered_skill_cache()
+        try:
+            with mock.patch.object(meter, "_scan_discovered_skills", return_value=[]):
+                rows = meter.discovered_skills(waste["skills"])
+        finally:
+            meter.invalidate_discovered_skill_cache()
+        self.assertEqual([row["name"] for row in rows], ["repo-review"])
+
+    def test_unlisted_claude_skill_activations_become_observed_rows(self):
+        inventory = [{"name": "known", "runtime": "Claude", "measurement": "unknown"}]
+        usage = [
+            {"name": "known", "hosts": {"Claude": {"activations": 2, "native_activations": 2}}},
+            {"name": "repo-only", "hosts": {"Claude": {
+                "activations": 3, "native_activations": 3,
+                "sessions_used": 2, "last_used": "2026-10-27",
+            }}},
+            {"name": "path-only", "hosts": {"Claude": {"activations": 2, "native_activations": 0}}},
+            {"name": "codex-only", "hosts": {"Codex": {"activations": 4, "native_activations": 4}}},
+            {"name": "legacy", "providers": ["claude"], "activations": 1},
+            {"name": "${name}", "hosts": {"Claude": {"activations": 1, "native_activations": 1}}},
+        ]
+        meter.invalidate_discovered_skill_cache()
+        try:
+            with mock.patch.object(meter, "_scan_discovered_skills", return_value=inventory):
+                rows = meter.discovered_skills(usage)
+        finally:
+            meter.invalidate_discovered_skill_cache()
+
+        by_name = {row["name"]: row for row in rows}
+        self.assertEqual(set(by_name), {"known", "repo-only"})
+        self.assertEqual(by_name["known"]["activations"], 2)
+        observed = by_name["repo-only"]
+        self.assertEqual(observed["source"], "Observed in traces")
+        self.assertEqual(observed["configuration"], "Not in config")
+        self.assertIsNone(observed["enabled"])
+        self.assertEqual((observed["activations"], observed["sessions_used"]), (3, 2))
+        self.assertEqual(observed["last_used"], "2026-10-27")
+        self.assertEqual(observed["measurement"], "measurable")
+        self.assertEqual(observed["id"], "skill:claude:claude:observed:repo-only")
+
+    def test_skill_identity_separates_runtime_origin_and_plugin(self):
+        identities = {
+            meter.skill_identity("Codex", "browser", "codex:built-in"),
+            meter.skill_identity("Codex", "browser", "codex:user"),
+            meter.skill_identity("Codex", "browser", "codex:plugin:openai-bundled", "browser@openai-bundled"),
+            meter.skill_identity("Claude", "browser", "claude:plugin:skills-marketplace", "browser@skills-marketplace"),
+        }
+        self.assertEqual(len(identities), 4)
+
+    def test_optional_summary_counts_only_mutable_skill_packs(self):
+        mcp_items = [
+            {"name": "context7", "mutable": True, "enabled": True, "used": False,
+             "codex_enabled": True, "claude_enabled": False},
+            {"name": "core", "mutable": False, "enabled": True, "used": False},
+        ]
+        skill_items = [
+            {"name": "browser", "runtime": "Codex", "plugin_id": "browser@bundled",
+             "mutable": True, "enabled": True, "used": True, "activations": 2},
+            {"name": "local", "runtime": "Codex", "plugin_id": "",
+             "mutable": False, "enabled": True, "used": False},
+        ]
+        groups = meter.capability_control_groups(mcp_items, skill_items)
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(summary["enabled"], 1)
+        self.assertEqual(summary["used"], 1)
+        self.assertEqual(summary["unused"], 0)
+        self.assertEqual(summary["mcp_enabled"], 0)
+        self.assertEqual(summary["skill_packs_enabled"], 1)
+
+    def test_runtime_skill_packs_are_not_review_candidates(self):
+        skill_items = [
+            {"id": "runtime-skill", "name": "browser", "runtime": "Codex",
+             "plugin_id": "browser@openai-bundled", "mutable": True, "enabled": True,
+             "used": False, "reviewable": False, "origin": "runtime_pack"},
+            {"id": "user-skill", "name": "custom", "runtime": "Codex",
+             "plugin_id": "custom@personal", "mutable": True, "enabled": True,
+             "used": False, "reviewable": True, "origin": "user_plugin"},
+        ]
+        groups = meter.capability_control_groups([], skill_items)
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(summary["enabled"], 1)
+        self.assertEqual(summary["review_candidates"], ["skill_pack:Codex:custom@personal"])
+
+    def test_observed_tools_do_not_claim_configuration_enabled(self):
+        waste = {"inventory_tools": [{
+            "id": "codex::exec", "name": "exec", "display": "exec",
+            "kind": "tool", "runtime": "Codex", "namespace": "shell",
+            "calls": 2, "output_tokens": 120, "last_used": "2026-08-10",
+            "advertised_sessions": 0, "eager_sessions": 0, "deferred_sessions": 0,
+        }]}
+        with mock.patch.object(meter, "codex_mcp_states", return_value={}), \
+                mock.patch.object(meter, "claude_mcp_states", return_value={}), \
+                mock.patch.object(meter, "discovered_skills", return_value=[]), \
+                mock.patch.object(meter, "claude_desktop_index", return_value={}), \
+                mock.patch.object(meter, "claude_local_agent_sources", return_value=[]):
+            capabilities = meter.capability_inventory(waste)
+        row = capabilities["items"][0]
+        self.assertIsNone(row["enabled"])
+        self.assertEqual(row["configuration"], "Unknown")
+        self.assertEqual(row["state"], "Observed only")
+        self.assertIsNone(capabilities["summary"]["tools"]["enabled"])
+        self.assertEqual(capabilities["summary"]["tools"]["observed"], 1)
+
+    def test_capability_revisions_are_stable_across_generation_time(self):
+        waste = {"inventory_tools": [{
+            "id": "codex::exec", "name": "exec", "display": "exec",
+            "kind": "tool", "runtime": "Codex", "namespace": "shell",
+            "calls": 2, "output_tokens": 120, "last_used": "2026-08-10",
+            "advertised_sessions": 1, "eager_sessions": 1, "deferred_sessions": 0,
+        }]}
+        with mock.patch.object(meter, "codex_mcp_states", return_value={}), \
+                mock.patch.object(meter, "claude_mcp_states", return_value={}), \
+                mock.patch.object(meter, "discovered_skills", return_value=[]), \
+                mock.patch.object(meter, "claude_desktop_index", return_value={}), \
+                mock.patch.object(meter, "claude_local_agent_sources", return_value=[]), \
+                mock.patch.object(meter.time, "time", side_effect=[100, 200, 300]):
+            first = meter.capability_inventory(waste)
+            second = meter.capability_inventory(waste)
+            changed = meter.capability_inventory({
+                **waste,
+                "inventory_tools": [{**waste["inventory_tools"][0], "calls": 3}],
+            })
+        self.assertNotEqual(first["generated_at"], second["generated_at"])
+        self.assertEqual(first["review_revision"], second["review_revision"])
+        self.assertEqual(first["inventory_revision"], second["inventory_revision"])
+        self.assertEqual(first["revision"], second["revision"])
+        self.assertNotEqual(second["inventory_revision"], changed["inventory_revision"])
+        self.assertNotEqual(second["revision"], changed["revision"])
+
+    def test_dashboard_state_omits_heavy_capability_rows_and_tool_waste(self):
+        capabilities = {
+            "items": [{"id": "tool:exec"}],
+            "summary": {"tools": {"available": 1}},
+            "control_groups": [], "inventory_revision": "inventory-a",
+        }
+        state = {"xsession": {
+            "capabilities": capabilities,
+            "tool_waste": {"inventory_tools": [{"private": "trace detail"}]},
+            "total_sessions": 2,
+        }}
+        payload = meter.dashboard_state_payload(state)
+        public_capabilities = payload["xsession"]["capabilities"]
+        self.assertNotIn("items", public_capabilities)
+        self.assertEqual(public_capabilities["inventory_count"], 1)
+        self.assertNotIn("tool_waste", payload["xsession"])
+        self.assertIn("items", state["xsession"]["capabilities"])
+        self.assertIn("tool_waste", state["xsession"])
+        self.assertIn(
+            'elif req_path == "/capabilities/inventory":',
+            Path(meter.IMPLEMENTATION_FILE).read_text(),
+        )
+
+    def test_pack_without_runtime_logs_is_not_a_review_candidate(self):
+        base = {
+            "id": "skill_pack:Claude:custom@personal", "name": "custom@personal",
+            "control_type": "skill_pack", "enabled": True, "used": False,
+            "mutable": True, "reviewable": True, "unmeasurable": False,
+        }
+        unscanned = meter.optional_capability_summary([{**base, "scanned_sessions": 0}])
+        scanned = meter.optional_capability_summary([{**base, "scanned_sessions": 3}])
+        self.assertEqual(unscanned["review_candidates"], [])
+        self.assertEqual(unscanned["unscanned_packs"], 1)
+        self.assertEqual(scanned["review_candidates"], [base["id"]])
+        self.assertEqual(scanned["unscanned_packs"], 0)
+
+    def test_claude_desktop_and_3p_logs_do_not_cover_claude_code_packs(self):
+        skill = {
+            "id": "skill:claude:custom@personal:custom", "name": "custom",
+            "runtime": "Claude", "source": "User-installed plugin",
+            "plugin_id": "custom@personal", "mutable": True, "enabled": True,
+            "used": False, "reviewable": True, "measurement": "measurable",
+            "unmeasurable": False, "activations": 0, "last_used": "Never",
+            "setting_path": "~/.claude/settings.json",
+        }
+        for runtime in ("Claude Desktop", "Claude-3P"):
+            with self.subTest(runtime=runtime):
+                waste = meter.global_tool_waste([{
+                    "id": runtime, "provider": "claude", "runtime": runtime,
+                    "project": "/repo", "_tool_evidence": {},
+                }])
+                with mock.patch.object(meter, "codex_mcp_states", return_value={}), \
+                        mock.patch.object(meter, "claude_mcp_states", return_value={}), \
+                        mock.patch.object(meter, "discovered_skills", return_value=[skill]), \
+                        mock.patch.object(meter, "claude_desktop_index", return_value={}), \
+                        mock.patch.object(meter, "claude_local_agent_sources", return_value=[]):
+                    capabilities = meter.capability_inventory(waste)
+                self.assertEqual(capabilities["control_groups"][0]["scanned_sessions"], 0)
+                self.assertEqual(
+                    capabilities["summary"]["optional"]["review_candidates"], []
+                )
+
+    def test_bulk_disable_accepts_only_exact_review_candidates(self):
+        capabilities = {
+            "summary": {"optional": {"review_candidates": ["skill_pack:Claude:custom@personal"]}},
+            "control_groups": [
+                {"id": "skill_pack:Claude:custom@personal", "name": "custom@personal",
+                 "control_type": "skill_pack", "enabled": True, "used": False,
+                 "mutable": True, "reviewable": True},
+                {"id": "skill_pack:Codex:browser@openai-bundled", "name": "browser@openai-bundled",
+                 "control_type": "skill_pack", "enabled": True, "used": False,
+                 "mutable": True, "reviewable": False},
+            ],
+        }
+        changed = []
+
+        def fake_setter(control, enabled):
+            changed.append((control["id"], enabled))
+            return {"ok": True, "verified": True}
+
+        result = meter.disable_capability_controls(
+            ["skill_pack:Claude:custom@personal"], capabilities, fake_setter)
+        rejected = meter.disable_capability_controls(
+            ["skill_pack:Codex:browser@openai-bundled"], capabilities, fake_setter)
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["changed"], 1)
+        self.assertEqual(changed, [("skill_pack:Claude:custom@personal", False)])
+        self.assertFalse(rejected["ok"])
+        self.assertEqual(rejected["invalid_control_ids"], ["skill_pack:Codex:browser@openai-bundled"])
+
+    def test_session_optional_summary_excludes_mcp_and_default_activity(self):
+        capabilities = {"control_groups": [
+            {"id": "skill_pack:Codex:browser@bundled", "control_type": "skill_pack",
+             "name": "browser@bundled", "runtime": "Codex", "enabled": True,
+             "mutable": True, "members": ["browser"]},
+        ], "summary": {"optional": {"review_candidate_names": []}}}
+        state = {"provider": "codex", "tools": {
+            "by_name": [
+                {"name": "exec", "namespace": "exec", "kind": "tool", "calls": 3},
+                {"name": "mcp__context7__query", "namespace": "context7", "kind": "mcp", "calls": 1},
+            ],
+            "skills": [{"name": "browser", "activations": 1}],
+        }}
+        summary = meter.session_optional_capabilities(state, capabilities)
+        self.assertEqual(summary["enabled"], 1)
+        self.assertEqual(summary["used"], 1)
+        self.assertEqual(summary["mcp_enabled"], 0)
+        self.assertEqual(summary["avoidable_eager_definition_tokens"], 0)
+        self.assertNotIn("context7", [row["name"] for row in summary["groups"]])
+
+    def test_mcp_parser_ignores_nested_env_section(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "config.toml"
+            path.write_text("[mcp_servers.node_repl]\nenabled = false\n[mcp_servers.node_repl.env]\nTOKEN = 'x'\n")
+            rows = meter.toml_named_sections(str(path), "mcp_servers")
+        self.assertEqual(list(rows), ["node_repl"])
+
+    def test_codex_plugin_toggle_changes_only_enabled_state(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "config.toml"
+            path.write_text('[plugins."docs@runtime"]\nenabled = true\nsource = "keep"\n[features]\nskills = true\n')
+            with mock.patch.object(meter, "CODEX_CONFIG", str(path)):
+                result = meter.set_codex_plugin_enabled("docs@runtime", False)
+            text = path.read_text()
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["verified"])
+        self.assertIn("enabled = false", text)
+        self.assertIn('source = "keep"', text)
+
+    def test_claude_plugin_toggle_verifies_written_setting(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"enabledPlugins": {"docs@personal": True}}))
+            with (mock.patch.object(meter, "CLAUDE_SETTINGS", str(path)),
+                  mock.patch.object(meter, "claude_plugin_installations",
+                                    return_value={"docs@personal": {"installPath": tmp}})):
+                result = meter.set_claude_plugin_enabled("docs@personal", False)
+            written = json.loads(path.read_text())
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["verified"])
+        self.assertFalse(written["enabledPlugins"]["docs@personal"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_agent_data_contract.py b/tests/test_agent_data_contract.py
new file mode 100644
index 00000000..7742a2d3
--- /dev/null
+++ b/tests/test_agent_data_contract.py
@@ -0,0 +1,1404 @@
+import unittest
+import contextlib
+import datetime
+import io
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests import test_builder_recap  # module import: its test classes are not collected twice
+
+
+class AgentDataContractTests(unittest.TestCase):
+    def setUp(self):
+        self.source = {
+            "id": "safe-session", "provider": "codex", "client": "codex", "label": "Codex",
+            "path": "/private/logs/secret.jsonl", "session": "secret.jsonl",
+            "project": "/Users/test/work/repository", "mtime": meter.time.time(),
+        }
+        self.state = {
+            "provider": "codex", "source": self.source, "session": "secret.jsonl",
+            "project": self.source["project"], "total_cost": 1.25, "cost_approx": True,
+            "total_tokens": 120000, "turns": 4, "last_turn_cost": 0.21,
+            "context": {"latest": 40000, "window": 200000, "latest_pct": 0.2},
+            "tools": {"total_output_tokens": 9000, "flagged_tokens": 1000, "by_name": []},
+            "executions": [{"idx": 4, "cost": 0.21, "tokens": {
+                "input": 40000, "output": 900, "retrieval": 1000,
+            }, "context_pct": 0.2}],
+            "trace": [
+                {"execution": 4, "kind": "user", "label": "User message", "detail": "private prompt"},
+                {"execution": 4, "kind": "tool_call", "label": "search", "detail": "private args"},
+                {"execution": 4, "kind": "tool_result", "label": "search", "detail": "private result", "tokens": 1000},
+            ],
+            "insights": [], "ended": False,
+        }
+
+    def test_check_matches_runtime_and_project_and_omits_content(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=self.state):
+            result = meter.agent_check(execution=4, caller={
+                "runtime": "codex", "project": "/Users/test/work/repository/subdir",
+            })
+        encoded = json.dumps(result)
+        self.assertTrue(result["ok"])
+        self.assertNotIn("project", result["selected_session"])
+        self.assertNotIn("repository", encoded)
+        self.assertEqual(result["data_scope"], "matched_current_run")
+        self.assertNotIn("private prompt", encoded)
+        self.assertNotIn("private args", encoded)
+        self.assertNotIn("private result", encoded)
+        self.assertNotIn("/private/logs", encoded)
+        self.assertLessEqual(len(result["evidence"]), 3)
+        self.assertLessEqual(len(result["execution"]["activity"]), 5)
+        selected_tools = next(row for row in result["evidence"] if row["label"] == "Selected execution tool results")
+        self.assertEqual(selected_tools["value"], 1000)
+
+    def test_default_check_does_not_present_run_wide_tool_tokens_as_latest(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=self.state):
+            result = meter.agent_check(caller={
+                "runtime": "codex", "project": "/Users/test/work/repository",
+            })
+        latest_tools = next(row for row in result["evidence"] if row["label"] == "Latest execution tool results")
+        self.assertEqual(latest_tools["value"], 1000)
+        self.assertNotEqual(latest_tools["value"], self.state["tools"]["total_output_tokens"])
+
+    def test_cost_check_answers_the_cost_question(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=self.state):
+            result = meter.agent_check(focus="cost", caller={
+                "runtime": "codex", "project": "/Users/test/work/repository",
+            })
+
+        self.assertIn("$1.25", result["answer"])
+        self.assertIn("cost", result["recommended_action"].lower())
+
+    def test_context_check_answers_the_context_question(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=self.state):
+            result = meter.agent_check(focus="context", caller={
+                "runtime": "codex", "project": "/Users/test/work/repository",
+            })
+
+        self.assertIn("20%", result["answer"])
+        self.assertIn("context", result["recommended_action"].lower())
+
+    def test_check_dashboard_url_targets_the_single_run_surface(self):
+        state = {**self.state, "context": {"latest": 180000, "window": 200000,
+                                           "latest_pct": 0.9}}
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=state):
+            result = meter.agent_check(caller={
+                "runtime": "codex", "project": "/Users/test/work/repository",
+            })
+
+        self.assertTrue(result["dashboard_url"].endswith("#summary"))
+
+    def test_tools_check_answers_the_tool_volume_question(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=self.state):
+            result = meter.agent_check(focus="tools", caller={
+                "runtime": "codex", "project": "/Users/test/work/repository",
+            })
+
+        self.assertIn("9,000", result["answer"])
+        self.assertIn("tool", result["recommended_action"].lower())
+
+    def test_next_phase_check_summarizes_all_readiness_signals(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
+                mock.patch.object(meter, "recompute", return_value=self.state):
+            result = meter.agent_check(focus="next_phase", caller={
+                "runtime": "codex", "project": "/Users/test/work/repository",
+            })
+
+        self.assertIn("20%", result["answer"])
+        self.assertIn("$1.25", result["answer"])
+        self.assertIn("9,000", result["answer"])
+        self.assertIn("next phase", result["recommended_action"].lower())
+
+    def test_missing_context_percentage_is_not_described_as_zero(self):
+        state = {"context": {"latest_pct": None}, "last_turn_cost": 0,
+                 "insights": [], "executions": [], "ended": False}
+        recommendation = meter.menubar_recommendation(state)
+        verdict = meter.menubar_verdict(state, recommendation)
+        self.assertIn("not reported", verdict["detail"])
+        self.assertNotIn("Context is 0%", verdict["detail"])
+
+    def test_dashboard_omits_removed_session_tab_payloads(self):
+        state = {
+            "source": {"id": "session", "provider": "codex"},
+            "trace": [{"kind": "usage"}],
+            "insights": [{"kind": "warn"}],
+            "tools": {
+                "total_calls": 7,
+                "total_output_tokens": 1000,
+                "unique_used": 1,
+                "by_namespace": [{"namespace": "shell"}],
+                "by_name": [{"name": "exec"}],
+                "by_execution": [{"execution": 2}],
+            },
+        }
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            projected = meter.dashboard_state_payload(state)
+
+        self.assertNotIn("trace", projected)
+        self.assertNotIn("insights", projected)
+        self.assertEqual(projected["tools"]["total_calls"], 7)
+        self.assertEqual(projected["tools"]["total_output_tokens"], 1000)
+        self.assertEqual(projected["tools"]["unique_used"], 1)
+        for removed in ("by_namespace", "by_name", "by_execution"):
+            self.assertNotIn(removed, projected["tools"])
+        self.assertEqual(state["trace"], [{"kind": "usage"}])
+
+    def test_dashboard_payload_replaces_trace_paths_with_opaque_keys(self):
+        from token_meter.domain.compare import trace_key
+        current = "/Users/private-user/.codex/sessions/rollout-1.jsonl"
+        other = "/Users/private-user/.claude/projects/p/two.jsonl"
+        state = {
+            "source": {"id": "one", "path": current, "project": "~/p"},
+            "xsession": {
+                "sessions": [
+                    {"id": "one", "path": current, "project": "~/p"},
+                    {"id": "two", "path": other, "project": "~/p"},
+                ],
+                "current_sessions": [{"id": "one", "project": "~/p"}],
+                "capabilities": {
+                    "items": [],
+                    "claude_desktop": {
+                        "local_agent_sessions": 1,
+                        "roots": ["~/Library/Application Support/Claude"],
+                    },
+                },
+            },
+        }
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            projected = meter.dashboard_state_payload(state)
+
+        encoded = json.dumps(projected)
+        self.assertNotIn("private-user", encoded)
+        self.assertNotIn("path", projected["source"])
+        self.assertEqual(projected["source"]["key"], trace_key({"path": current}))
+        self.assertEqual(projected["source"]["project"], "~/p")
+        rows = projected["xsession"]["sessions"]
+        self.assertEqual([row["key"] for row in rows],
+                         [trace_key({"path": current}), trace_key({"path": other})])
+        self.assertTrue(all("path" not in row for row in rows))
+        self.assertEqual([row["project"] for row in rows], ["~/p", "~/p"])
+        self.assertEqual(projected["xsession"]["current_sessions"], [{"id": "one", "project": "~/p"}])
+        desktop = projected["xsession"]["capabilities"]["claude_desktop"]
+        self.assertNotIn("roots", desktop)
+        self.assertEqual(desktop["local_agent_sessions"], 1)
+        self.assertEqual(state["source"]["path"], current)
+        self.assertEqual(state["xsession"]["sessions"][0]["path"], current)
+        self.assertIn("roots", state["xsession"]["capabilities"]["claude_desktop"])
+
+    def test_dashboard_reprojects_agent_data_at_the_browser_boundary(self):
+        state = {
+            "source": {"id": "root", "provider": "codex"},
+            "agent_group": {
+                "root_session_id": "root", "selected_agent_id": "root",
+                "coverage": {}, "totals": {"agents": 2},
+                "agents": [{
+                    "id": "root", "kind": "root", "depth": 0,
+                    "agent_path": "/private/agent.md", "prompt": "secret",
+                }],
+                "_all_agents": [{"path": "/private/trace.jsonl"}],
+            },
+            "xsession": {
+                "agent_usage": {
+                    "totals": {"agents": 1},
+                    "models": [{
+                        "id": "model::codex", "runtime": "codex",
+                        "model": "model", "agents": 1,
+                        "session_id": "private-session",
+                    }],
+                },
+            },
+        }
+        registry = mock.Mock()
+        registry.descriptors = ()
+
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            projected = meter.dashboard_state_payload(state)
+
+        encoded = json.dumps(projected)
+        self.assertEqual(projected["agent_group"]["root_session_id"], "root")
+        self.assertEqual(
+            projected["xsession"]["agent_usage"]["models"][0]["id"],
+            "model::codex",
+        )
+        for forbidden in (
+            "/private", "secret", "_all_agents", "agent_path",
+            "private-session", "session_id\": \"private-session",
+        ):
+            self.assertNotIn(forbidden, encoded)
+
+    def _live_state_with_cross(self, cross):
+        return {
+            "ok": True,
+            "source": {"id": "root", "provider": "codex"},
+            "trace": [{"kind": "usage", "text": "PRIVATE-TRACE"}],
+            "insights": [{"text": "PRIVATE-INSIGHT"}],
+            "recommendation": "PRIVATE-RECOMMENDATION",
+            "verdict": "PRIVATE-VERDICT",
+            "tools": {
+                "total_calls": 3,
+                "by_name": [{"name": "PRIVATE-TOOL"}],
+                "by_execution": [{"execution": 1}],
+            },
+            "agent_group": {
+                "root_session_id": "root", "selected_agent_id": "root",
+                "coverage": {}, "totals": {"agents": 1},
+                "agents": [{"id": "root", "kind": "root", "depth": 0,
+                            "agent_path": "/private/agent.md", "prompt": "PRIVATE-PROMPT"}],
+                "_all_agents": [{"path": "/private/trace.jsonl"}],
+            },
+            "total_cost": 1.5,
+            "xsession": cross,
+        }
+
+    def test_dashboard_state_body_replaces_trace_paths_on_cached_and_held_polls(self):
+        from token_meter.domain.compare import trace_key
+        current = "/Users/private-user/.codex/sessions/rollout-1.jsonl"
+        other = "C:\\Users\\private-user\\.claude\\projects\\p\\two.jsonl"
+        cross = {
+            "generated_at": 100,
+            "sessions": [
+                {"id": "one", "path": current, "project": "~/p"},
+                {"id": "two", "path": other, "project": "~/p"},
+            ],
+        }
+        state = {"source": {"id": "one", "path": current}, "xsession": cross}
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            first = meter.dashboard_state_body(state)
+            full = json.loads(first)
+            again = json.loads(meter.dashboard_state_body(state))
+            held = json.loads(meter.dashboard_state_body(state, full["xsession_revision"]))
+
+        self.assertNotIn("private-user", first)
+        self.assertEqual(full["source"]["key"], trace_key({"path": current}))
+        self.assertEqual([row["key"] for row in full["xsession"]["sessions"]],
+                         [trace_key({"path": current}), trace_key({"path": other})])
+        self.assertEqual(again["xsession"], full["xsession"])
+        self.assertNotIn("xsession", held)
+        self.assertEqual(held["source"], full["source"])
+        self.assertEqual(cross["sessions"][0]["path"], current)
+
+    def test_dashboard_state_body_matches_projected_payload(self):
+        cross = {
+            "generated_at": 100,
+            "tool_waste": {"secret": True},
+            "agent_usage": {
+                "totals": {"agents": 1},
+                "models": [{"id": "model::codex", "runtime": "codex", "model": "model",
+                            "agents": 1, "session_id": "private-session"}],
+            },
+            "daily": [{"day": "2026-10-23", "cost": 2.0}],
+        }
+        state = self._live_state_with_cross(cross)
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            expected = meter.dashboard_state_payload(state)
+            body = json.loads(meter.dashboard_state_body(state))
+
+        revision = body.pop("xsession_revision")
+        self.assertTrue(revision)
+        # Discounts are attached fresh from settings, outside the cached snapshot.
+        self.assertEqual(set(body.pop("cost_discounts")), set(meter.cost_discount_settings()))
+        self.assertEqual(body, expected)
+        self.assertNotIn("tool_waste", body["xsession"])
+        encoded = json.dumps(body)
+        for forbidden in ("PRIVATE", "/private", "_all_agents", "agent_path",
+                          "private-session", "by_name", "by_execution"):
+            self.assertNotIn(forbidden, encoded)
+
+    def test_dashboard_state_body_omits_unchanged_cross_session_snapshot(self):
+        cross = {"generated_at": 100, "daily": [{"day": "2026-10-23"}]}
+        state = self._live_state_with_cross(cross)
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            first = json.loads(meter.dashboard_state_body(state))
+            revision = first["xsession_revision"]
+            state["total_cost"] = 2.5
+            repeat = json.loads(meter.dashboard_state_body(state, revision))
+            stale = json.loads(meter.dashboard_state_body(state, "older"))
+
+        self.assertNotIn("xsession", repeat)
+        self.assertTrue(repeat["xsession_unchanged"])
+        self.assertEqual(repeat["xsession_revision"], revision)
+        self.assertEqual(repeat["total_cost"], 2.5)
+        self.assertEqual(stale["xsession"], first["xsession"])
+        self.assertNotIn("xsession_unchanged", stale)
+
+    def test_dashboard_state_body_encodes_each_cross_snapshot_once(self):
+        cross = {"generated_at": 100, "daily": [{"day": "2026-10-23"}]}
+        rebuilt = {"generated_at": 100, "daily": [{"day": "2026-10-24"}]}
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            with mock.patch.object(
+                    meter, "_dashboard_public_cross",
+                    wraps=meter._dashboard_public_cross) as project:
+                first = json.loads(meter.dashboard_state_body(
+                    self._live_state_with_cross(cross)))
+                again = json.loads(meter.dashboard_state_body(
+                    self._live_state_with_cross(cross)))
+                self.assertEqual(project.call_count, 1)
+                changed = json.loads(meter.dashboard_state_body(
+                    self._live_state_with_cross(rebuilt),
+                    first["xsession_revision"],
+                ))
+                self.assertEqual(project.call_count, 2)
+
+        self.assertEqual(first["xsession_revision"], again["xsession_revision"])
+        self.assertNotEqual(changed["xsession_revision"], first["xsession_revision"])
+        self.assertEqual(changed["xsession"]["daily"], [{"day": "2026-10-24"}])
+
+    def test_dashboard_state_body_keeps_published_and_rebuilt_snapshots_encoded(self):
+        published = {"generated_at": 100, "daily": [{"day": "a"}]}
+        rebuilt = {"generated_at": 115, "daily": [{"day": "b"}]}
+        registry = mock.Mock()
+        registry.descriptors = ()
+        previous_state, saved_cache = meter.STATE, dict(meter._xsess)
+        try:
+            meter.STATE = self._live_state_with_cross(published)
+            meter._xsess["data"] = rebuilt
+            with mock.patch.object(meter, "runtime_registry", return_value=registry), \
+                    mock.patch.object(meter, "_dashboard_public_cross",
+                                      wraps=meter._dashboard_public_cross) as project:
+                revisions = [
+                    json.loads(meter.dashboard_state_body(
+                        self._live_state_with_cross(cross)))["xsession_revision"]
+                    for cross in (published, rebuilt, published, rebuilt)
+                ]
+                self.assertEqual(project.call_count, 2)
+                self.assertEqual(revisions[0], revisions[2])
+                self.assertEqual(revisions[1], revisions[3])
+                self.assertNotEqual(revisions[0], revisions[1])
+
+                replacement = {"generated_at": 130, "daily": [{"day": "c"}]}
+                meter.STATE = self._live_state_with_cross(replacement)
+                meter._xsess["data"] = replacement
+                meter.dashboard_state_body(meter.STATE)
+                cached = [entry[0] for entry in meter._dashboard_cross_cache["entries"]]
+                self.assertEqual(len(cached), 1)
+                self.assertIs(cached[0], replacement)
+        finally:
+            meter.STATE = previous_state
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+    def test_state_route_omits_cross_session_snapshot_the_client_holds(self):
+        cross = {"generated_at": 100, "daily": [{"day": "2026-10-23"}]}
+        previous = meter.STATE
+        try:
+            meter.STATE = self._live_state_with_cross(cross)
+            request = test_builder_recap.BuilderRecapEndpointTests.request
+            full, status, content_type = request(self, "/state")
+            self.assertEqual(status, 200)
+            self.assertEqual(content_type, "application/json")
+            revision = full["xsession_revision"]
+            self.assertEqual(full["xsession"]["daily"], cross["daily"])
+            held, _, _ = request(self, "/state?xsession=" + revision)
+            stale, _, _ = request(self, "/state?xsession=older")
+        finally:
+            meter.STATE = previous
+        self.assertNotIn("xsession", held)
+        self.assertTrue(held["xsession_unchanged"])
+        self.assertEqual(held["xsession_revision"], revision)
+        self.assertEqual(held["total_cost"], full["total_cost"])
+        self.assertEqual(stale["xsession"], full["xsession"])
+        for body in (full, held, stale):
+            self.assertNotIn("PRIVATE", json.dumps(body))
+
+    def test_session_route_omits_cross_session_snapshot_the_client_holds(self):
+        cross = {"generated_at": 100, "current_sessions": [{"id": "session-1"}]}
+        source = {"id": "session-1", "path": "/logs/exact.jsonl"}
+        saved_cache = dict(meter._xsess)
+
+        def get(path):
+            handler = object.__new__(meter.H)
+            handler.path = path
+            handler.headers = {"Host": "127.0.0.1:8722"}
+            sent = []
+            handler._send = lambda body, *_args, **_kwargs: sent.append(json.loads(body))
+            state = {"source": {"id": "session-1"}, "timing": {}}
+            with mock.patch.object(meter, "find_session", return_value=source), \
+                    mock.patch.object(meter, "cached_session_state", return_value=state), \
+                    mock.patch.object(meter, "selected_session_stats", return_value={}):
+                handler.do_GET()
+            return sent[0]
+
+        try:
+            meter._xsess["data"] = cross
+            full = get("/session?id=session-1&live=1")
+            held = get("/session?id=session-1&live=1&xsession=" + full["xsession_revision"])
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertEqual(full["xsession"]["current_sessions"], cross["current_sessions"])
+        self.assertFalse(full["ended"])
+        self.assertNotIn("xsession", held)
+        self.assertTrue(held["xsession_unchanged"])
+        self.assertFalse(held["ended"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for live polling verification")
+    def test_live_polling_reuses_only_the_snapshot_matching_its_revision(self):
+        page_path = Path(DASHBOARD_PAGE)
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start-(page.slice(start-6,start)==='async '?6:0),i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('adoptXsession'));eval(extract('fetchLiveJson'));
+const urls=[];let replies=[];
+global.fetch=async url=>{{urls.push(url);const r=replies.shift();return {{ok:r.status===undefined,status:r.status||200,json:async()=>r}};}};
+(async()=>{{
+ const holder={{snapshot:null,revision:''}};
+ replies=[{{xsession_revision:'r1',xsession:{{n:1}}}}];
+ const first=await fetchLiveJson('/state',holder,'State');
+ replies=[{{xsession_revision:'r1',xsession_unchanged:true}}];
+ const reused=await fetchLiveJson('/session?id=a&live=1',holder,'Session');
+ holder.revision='r1';holder.snapshot={{n:1}};
+ replies=[{{xsession_revision:'r2',xsession_unchanged:true}},{{xsession_revision:'r2',xsession:{{n:2}}}}];
+ const mismatch=await fetchLiveJson('/state',holder,'State');
+ replies=[{{status:503}}];
+ let error='';try{{await fetchLiveJson('/state',holder,'State');}}catch(e){{error=e.message;}}
+ console.log(JSON.stringify({{urls,first:first.xsession,reused:reused.xsession,sameObject:reused.xsession===first.xsession,
+  mismatch:mismatch.xsession,held:holder.revision,error}}));
+}})().catch(e=>{{console.error(e);process.exit(1);}});
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=False)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), {
+            "urls": [
+                "/state?xsession=",
+                "/session?id=a&live=1&xsession=r1",
+                "/state?xsession=r1",
+                "/state?xsession=",
+                "/state?xsession=r2",
+            ],
+            "first": {"n": 1},
+            "reused": {"n": 1},
+            "sameObject": True,
+            "mismatch": {"n": 2},
+            "held": "r2",
+            "error": "State request failed (503).",
+        })
+
+    def test_dashboard_state_body_without_cross_session_has_no_revision(self):
+        registry = mock.Mock()
+        registry.descriptors = ()
+        with mock.patch.object(meter, "runtime_registry", return_value=registry):
+            body = json.loads(meter.dashboard_state_body(
+                {"ok": False, "loading": True, "source": {}}, "stale",
+            ))
+        self.assertNotIn("xsession", body)
+        self.assertNotIn("xsession_unchanged", body)
+        self.assertEqual(body["xsession_revision"], "")
+
+    def test_publish_skips_serialization_without_subscribers(self):
+        state = {"ok": True, "source": {"id": "s"}}
+        previous = meter.STATE
+        try:
+            with mock.patch.object(meter.json, "dumps") as dumps:
+                meter.publish(state)
+            dumps.assert_not_called()
+            self.assertIs(meter.STATE, state)
+            q_ = meter.queue.Queue(maxsize=2)
+            with meter.subscribers_lock:
+                meter.subscribers.append(q_)
+            try:
+                meter.publish(state)
+            finally:
+                with meter.subscribers_lock:
+                    meter.subscribers.remove(q_)
+            self.assertEqual(q_.get_nowait(), "data: " + json.dumps(state) + "\n\n")
+        finally:
+            meter.STATE = previous
+
+    def test_check_refuses_to_fall_back_across_projects(self):
+        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]):
+            result = meter.agent_check(caller={"runtime": "codex", "project": "/another/repository"})
+        self.assertFalse(result["ok"])
+        self.assertIn("did not fall back", result["caveat"])
+
+    def test_claude_trace_cwd_preserves_hyphenated_project_name(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_text(json.dumps({
+                "type": "user", "cwd": "/Users/test/Documents/github/token-meter",
+            }) + "\n")
+            cwd = meter.claude_trace_cwd(str(path))
+        self.assertEqual(cwd, "/Users/test/Documents/github/token-meter")
+
+    def test_current_run_resolution_prefers_exact_project_over_newer_parent(self):
+        now = meter.time.time()
+        exact = {**self.source, "id": "exact", "project": "/Users/test/work/repository", "mtime": now - 10}
+        parent = {**self.source, "id": "parent", "project": "/Users/test/work", "mtime": now}
+        selected, resolution = meter.resolve_agent_source(
+            caller={"runtime": "codex", "project": "/Users/test/work/repository"},
+            sources=[parent, exact],
+        )
+        self.assertEqual(selected["id"], "exact")
+        self.assertEqual(resolution, "matched")
+
+    def test_current_run_resolution_rejects_stale_implicit_match(self):
+        stale = {**self.source, "mtime": meter.time.time() - meter.AGENT_CURRENT_MAX_AGE_S - 1}
+        selected, resolution = meter.resolve_agent_source(
+            caller={"runtime": "codex", "project": "/Users/test/work/repository"},
+            sources=[stale],
+        )
+        self.assertIsNone(selected)
+        self.assertIn("No recent Codex run", resolution)
+
+    def test_usage_is_aggregate_only_and_ranked_categories_are_bounded(self):
+        cross = {
+            "daily": [{"day": time_day, "cost": 2.0, "sessions": 2,
+                       "providers": [{"provider": "codex", "cost": 2.0}],
+                       "tool_tokens": 1000, "flagged_tokens": 300}
+                      for time_day in ("2026-07-01", "2026-06-30")],
+            "sessions": [{"cost_approx": True, "title": "private title", "project": "/private/repo"}],
+            "model_mix": [{"model": f"model-{idx}", "cost": idx, "tokens": idx * 100}
+                          for idx in range(8)],
+            "tool_waste": {"by_name": [
+                {"name": f"tool-{idx}", "namespace": "safe", "output_tokens": idx * 100, "calls": idx}
+                for idx in range(8)
+            ]},
+        }
+        with mock.patch.dict(meter._xsess, {
+                "data": cross, "at": meter.time.time(), "internal_rows": (),
+        }):
+            result = meter.agent_usage(window="7d", focus="models")
+        encoded = json.dumps(result)
+        self.assertEqual(result["data_scope"], "anonymous_aggregate_history")
+        self.assertLessEqual(len(result["categories"]), 5)
+        self.assertTrue(result["dashboard_url"].endswith("/#spend"))
+        self.assertNotIn("private title", encoded)
+        self.assertNotIn("/private/repo", encoded)
+
+    def test_usage_model_categories_are_scoped_to_calendar_window(self):
+        today = datetime.date.today()
+        recent = today - datetime.timedelta(days=1)
+        outside_seven_days = today - datetime.timedelta(days=7)
+        daily = [
+            {"day": today.isoformat(), "cost": 2.0, "sessions": 1,
+             "providers": [{"provider": "codex", "cost": 2.0}]},
+            {"day": recent.isoformat(), "cost": 3.0, "sessions": 1,
+             "providers": [{"provider": "codex", "cost": 3.0}]},
+            {"day": outside_seven_days.isoformat(), "cost": 5.0, "sessions": 1,
+             "providers": [{"provider": "codex", "cost": 5.0}]},
+        ]
+        internal = {
+            "id": "one", "provider": "codex", "runtime": "Codex",
+            "availability": {"cost": True, "tokens": True},
+            "_model_daily": [
+                {"model": "model-current", "day": today.isoformat(), "cost": 2.0,
+                 "input_tokens": 100, "output_tokens": 20, "executions": 1},
+                {"model": "model-week", "day": recent.isoformat(), "cost": 3.0,
+                 "input_tokens": 200, "output_tokens": 30, "executions": 1},
+                {"model": "model-fortnight", "day": outside_seven_days.isoformat(), "cost": 5.0,
+                 "input_tokens": 300, "output_tokens": 50, "executions": 1},
+            ],
+        }
+        cross = {
+            "daily": daily, "sessions": [internal],
+            "model_mix": [{"model": "all-time", "cost": 999.0, "tokens": 999999}],
+            "tool_waste": {"by_name": []},
+        }
+
+        with mock.patch.dict(meter._xsess, {
+                "data": cross, "at": meter.time.time(), "internal_rows": (internal,),
+        }):
+            today_result = meter.agent_usage(window="today", focus="models")
+            week_result = meter.agent_usage(window="7d", focus="models")
+            fortnight_result = meter.agent_usage(window="14d", focus="models")
+
+        self.assertEqual([row["model"] for row in today_result["categories"]], ["model-current"])
+        self.assertEqual(
+            {row["model"] for row in week_result["categories"]},
+            {"model-current", "model-week"},
+        )
+        self.assertEqual(
+            {row["model"] for row in fortnight_result["categories"]},
+            {"model-current", "model-week", "model-fortnight"},
+        )
+        self.assertEqual([today_result["days_observed"], week_result["days_observed"],
+                          fortnight_result["days_observed"]], [1, 2, 3])
+
+    def test_usage_tool_categories_and_evidence_share_the_selected_window(self):
+        today = datetime.date.today()
+        recent = today - datetime.timedelta(days=1)
+        outside_seven_days = today - datetime.timedelta(days=7)
+
+        def midday(day):
+            return int(time.mktime((*day.timetuple()[:3], 12, 0, 0, 0, 0, -1)))
+
+        internal = {
+            "id": "one", "provider": "codex", "runtime": "Codex",
+            "availability": {"cost": True, "tokens": True},
+            "_tool_evidence": meter.summarize_tool_evidence([
+                {**meter.tool_identity("search"), "output_tokens": 120,
+                 "ts": midday(today), "args_fingerprint": "today", "error": False},
+                {**meter.tool_identity("fetch"), "output_tokens": 80,
+                 "ts": midday(recent), "args_fingerprint": "recent", "error": False},
+                {**meter.tool_identity("search"), "output_tokens": 500,
+                 "ts": midday(outside_seven_days), "args_fingerprint": "older", "error": False},
+            ]),
+        }
+        cross = {
+            "daily": [
+                {"day": today.isoformat(), "cost": 2.0, "sessions": 1,
+                 "providers": [{"provider": "codex", "cost": 2.0}]},
+                {"day": recent.isoformat(), "cost": 3.0, "sessions": 1,
+                 "providers": [{"provider": "codex", "cost": 3.0}]},
+                {"day": outside_seven_days.isoformat(), "cost": 5.0, "sessions": 1,
+                 "providers": [{"provider": "codex", "cost": 5.0}]},
+            ],
+            "sessions": [internal], "model_mix": [],
+            "tool_waste": {"by_name": [
+                {"name": "search", "namespace": "unknown", "output_tokens": 620, "calls": 2},
+                {"name": "fetch", "namespace": "unknown", "output_tokens": 80, "calls": 1},
+            ]},
+        }
+
+        with mock.patch.dict(meter._xsess, {
+                "data": cross, "at": meter.time.time(), "internal_rows": (internal,),
+        }):
+            today_result = meter.agent_usage(window="today", focus="tools")
+            week_result = meter.agent_usage(window="7d", focus="tools")
+            fortnight_result = meter.agent_usage(window="14d", focus="tools")
+
+        def tool_evidence(result):
+            return next(row["value"] for row in result["evidence"]
+                        if row["label"] == "Trace-observed tool results")
+
+        self.assertEqual(today_result["categories"], [{
+            "name": "search", "namespace": "search", "returned_tokens": 120, "calls": 1,
+        }])
+        self.assertEqual(tool_evidence(today_result), 120)
+        self.assertEqual(tool_evidence(week_result), 200)
+        self.assertEqual(tool_evidence(fortnight_result), 700)
+        self.assertEqual(
+            {row["name"]: row["returned_tokens"] for row in week_result["categories"]},
+            {"search": 120, "fetch": 80},
+        )
+
+    def test_usage_headline_and_action_answer_the_requested_focus(self):
+        today = datetime.date.today()
+        recent = today - datetime.timedelta(days=1)
+
+        def midday(day):
+            return int(time.mktime((*day.timetuple()[:3], 12, 0, 0, 0, 0, -1)))
+
+        internal = {
+            "id": "one", "provider": "codex", "runtime": "Codex",
+            "availability": {"cost": True, "tokens": True},
+            "_model_daily": [
+                {"model": "model-top", "day": today.isoformat(), "cost": 5.0,
+                 "input_tokens": 100, "output_tokens": 20, "executions": 1},
+                {"model": "model-top", "day": recent.isoformat(), "cost": 5.0,
+                 "input_tokens": 100, "output_tokens": 20, "executions": 1},
+            ],
+            "_tool_evidence": meter.summarize_tool_evidence([
+                {**meter.tool_identity("search"), "output_tokens": 9000,
+                 "ts": midday(today), "args_fingerprint": "today", "error": False},
+            ]),
+        }
+        cross = {
+            "daily": [
+                {"day": today.isoformat(), "cost": 5.0, "sessions": 1,
+                 "providers": [{"provider": "codex", "cost": 5.0}]},
+                {"day": recent.isoformat(), "cost": 5.0, "sessions": 1,
+                 "providers": [{"provider": "codex", "cost": 5.0}]},
+            ],
+            "sessions": [internal], "model_mix": [], "tool_waste": {"by_name": []},
+        }
+
+        with mock.patch.dict(meter._xsess, {
+                "data": cross, "at": meter.time.time(), "internal_rows": (internal,),
+        }):
+            spend = meter.agent_usage(window="7d", focus="spend")
+            models = meter.agent_usage(window="7d", focus="models")
+            tools = meter.agent_usage(window="7d", focus="tools")
+
+        self.assertIn("$10.00", spend["answer"])
+        self.assertIn("spend", spend["recommended_action"].lower())
+        self.assertIn("model-top", models["answer"])
+        self.assertIn("model", models["recommended_action"].lower())
+        self.assertIn("9,000", tools["answer"])
+        self.assertIn("tool", tools["recommended_action"].lower())
+        self.assertEqual(len({spend["answer"], models["answer"], tools["answer"]}), 3)
+
+    def _windowed_usage_fixture(self):
+        today = datetime.date.today()
+        now = meter.time.time()
+
+        def midday(days_ago):
+            day = today - datetime.timedelta(days=days_ago)
+            return day, time.mktime((*day.timetuple()[:3], 12, 0, 0, 0, 0, -1))
+
+        def source(session_id, provider, days_ago, **extra):
+            _day, ts = midday(days_ago)
+            return {"id": session_id, "provider": provider, "path": f"/missing/{session_id}.jsonl",
+                    "mtime": min(ts, now), "signature_mtime": min(ts, now), **extra}
+
+        sources = [
+            source("recent-claude", "claude", 0),
+            source("old-claude", "claude", 30),
+            source("older-codex", "codex", 40, cost_approx=True),
+            source("old-cursor", "cursor", 50),
+            source("week-codex", "codex", 6),
+        ]
+        calls = []
+
+        def summary(row, opencode_conn=None):
+            calls.append(row["id"])
+            day, ts = midday(int((today - datetime.date.fromtimestamp(row["mtime"])).days))
+            key = day.isoformat()
+            return {
+                "id": row["id"], "provider": row["provider"], "runtime": row["provider"],
+                "mtime": row["mtime"], "turns": 1, "cost_approx": bool(row.get("cost_approx")),
+                "availability": {"cost": True, "tokens": True},
+                "_day_cost": {key: 1.0}, "_model_daily": [{
+                    "model": "m-" + row["id"], "day": key, "cost": 1.0,
+                    "input_tokens": 10, "output_tokens": 2, "executions": 1,
+                }],
+            }
+
+        return sources, calls, summary
+
+    def _windowed_usage(self, sources, summary, **patches):
+        with mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}), \
+                mock.patch.object(meter, "all_session_sources", return_value=list(sources)), \
+                mock.patch.object(meter, "session_summary", side_effect=summary), \
+                mock.patch.object(meter, "cross_session", side_effect=AssertionError), \
+                contextlib.ExitStack() as stack:
+            for name, value in patches.items():
+                stack.enter_context(mock.patch.object(meter, name, value))
+            return {
+                (window, focus): meter.agent_usage(window=window, focus=focus)
+                for window in ("today", "7d", "14d")
+                for focus in ("spend", "models", "tools", "changes")
+            }
+
+    def test_windowed_usage_skips_bounded_sessions_outside_the_window(self):
+        sources, calls, summary = self._windowed_usage_fixture()
+        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 2):
+            windowed = self._windowed_usage(sources, summary)
+        self.assertNotIn("old-claude", calls)
+        self.assertNotIn("older-codex", calls)
+        self.assertIn("old-cursor", calls)
+        self.assertEqual(set(calls), {"recent-claude", "week-codex", "old-cursor"})
+
+        calls.clear()
+        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 2):
+            unfiltered = self._windowed_usage(
+                sources, summary, source_activity_bound=lambda _source: None,
+            )
+        self.assertEqual(set(calls), {source["id"] for source in sources})
+        for key, result in windowed.items():
+            with self.subTest(key=key):
+                expected = dict(unfiltered[key])
+                actual = dict(result)
+                expected.pop("as_of")
+                actual.pop("as_of")
+                self.assertEqual(actual, expected)
+        self.assertEqual(
+            [row["model"] for row in windowed[("7d", "models")]["categories"]],
+            ["m-recent-claude", "m-week-codex"],
+        )
+        self.assertEqual(windowed[("7d", "models")]["approximate_fields"], [])
+
+    def test_windowed_usage_settles_the_recent_session_list(self):
+        sources, calls, summary = self._windowed_usage_fixture()
+        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 3):
+            windowed = self._windowed_usage(sources, summary)
+        # Three recent rows need the newest out-of-window bounded session, and only it.
+        self.assertIn("old-claude", calls)
+        self.assertNotIn("older-codex", calls)
+        self.assertEqual(windowed[("7d", "models")]["approximate_fields"], [])
+
+        calls.clear()
+        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 4):
+            windowed = self._windowed_usage(sources, summary)
+        self.assertIn("older-codex", calls)
+        self.assertEqual(windowed[("7d", "models")]["approximate_fields"], ["cost"])
+
+    def test_usage_serves_the_previous_snapshot_while_history_reprices(self):
+        today = datetime.date.today().isoformat()
+        cross = {"daily": [{"day": today, "cost": 4.0, "sessions": 1,
+                            "providers": [{"provider": "codex", "cost": 4.0}]}],
+                 "sessions": []}
+        with mock.patch.dict(meter._xsess, {"data": cross, "at": 0.0, "internal_rows": ()}), \
+                mock.patch.object(meter, "pricing_recalculation_running", return_value=True), \
+                mock.patch.object(meter, "all_session_sources", side_effect=AssertionError):
+            result = meter.agent_usage(window="today", focus="spend")
+        self.assertIn("$4.00", result["answer"])
+
+    def test_activity_bound_uses_the_newest_tracked_time_and_only_bounded_runtimes(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = os.path.join(directory, "trace.jsonl")
+            with open(path, "w", encoding="utf-8") as handle:
+                handle.write("{}\n")
+            os.utime(path, (2_000.0, 2_000.0))
+            self.assertEqual(meter.source_activity_bound(
+                {"provider": "claude", "path": path, "mtime": 1_000.0, "signature_mtime": 1_500.0},
+            ), 2_000.0)
+            self.assertEqual(meter.source_activity_bound(
+                {"provider": "codex", "path": path, "mtime": 3_000.0},
+            ), 3_000.0)
+        for source in (
+            {"provider": "cursor", "mtime": 1.0},
+            {"provider": "claude", "mtime": float("nan")},
+            {"provider": "codex", "mtime": "bad"},
+            {"provider": "claude"},
+            None,
+        ):
+            with self.subTest(source=source):
+                self.assertIsNone(meter.source_activity_bound(source))
+
+    def test_capability_result_names_only_requested_evidence(self):
+        cross = {"capabilities": {
+            "summary": {"optional": {
+                "enabled": 2, "unused": 1,
+                "review_candidates": ["skill_pack:Codex:docs@personal"],
+            }},
+            "control_groups": [
+                {"id": "skill_pack:Codex:docs@personal", "name": "docs@personal",
+                 "control_type": "skill_pack", "runtime": "Codex", "mutable": True,
+                 "reviewable": True, "used": False, "enabled": True, "activations": 0,
+                 "environment": {"TOKEN": "secret"}},
+                {"name": "tokenmeter", "control_type": "skill_pack", "runtime": "Codex",
+                 "used": False, "enabled": True},
+            ],
+        }}
+        with mock.patch.object(meter, "agent_capability_evidence",
+                               return_value=(cross["capabilities"], {"complete": True})):
+            result = meter.agent_capabilities(scope="all", limit=5)
+        encoded = json.dumps(result)
+        self.assertEqual([row["name"] for row in result["candidates"]], ["docs@personal"])
+        self.assertNotIn("TOKEN", encoded)
+        self.assertNotIn("secret", encoded)
+
+    def test_all_scope_capabilities_returns_only_counted_review_candidates(self):
+        candidate_id = "skill_pack:Codex:z-review"
+        cross = {"capabilities": {
+            "summary": {"optional": {
+                "enabled": 1, "unused": 1, "review_candidates": [candidate_id],
+            }},
+            "control_groups": [
+                {"id": "skill_pack:Codex:a-disabled", "name": "a-disabled",
+                 "control_type": "skill_pack", "runtime": "Codex", "mutable": True,
+                 "reviewable": True, "used": False, "enabled": False},
+                {"id": candidate_id, "name": "z-review", "control_type": "skill_pack",
+                 "runtime": "Codex", "mutable": True, "reviewable": True,
+                 "used": False, "enabled": True},
+            ],
+        }}
+
+        with mock.patch.object(meter, "agent_capability_evidence",
+                               return_value=(cross["capabilities"], {"complete": True})):
+            result = meter.agent_capabilities(scope="all", limit=5)
+
+        self.assertEqual([row["name"] for row in result["candidates"]], ["z-review"])
+        self.assertEqual(result["candidate_count"], 1)
+        self.assertEqual(result["candidates_returned"], 1)
+
+    @contextlib.contextmanager
+    def cold_session_history(self, count, parse_s, discovery_s=0.0, discovery_error=None):
+        sources = [
+            {"provider": "codex", "path": f"/synthetic/{index}.jsonl", "id": str(index),
+             "mtime": float(index)}
+            for index in range(count)
+        ]
+        parsed = []
+        scanned_rows = []
+
+        def discover():
+            time.sleep(discovery_s)
+            if discovery_error is not None:
+                raise discovery_error
+            return sources
+
+        def summarize(source, opencode_conn=None):
+            if source["path"] in meter._summary_cache:
+                return meter._summary_cache[source["path"]]["row"]
+            time.sleep(parse_s)
+            parsed.append(source["path"])
+            row = {"turns": 1, "path": source["path"], "mtime": source["mtime"]}
+            meter._summary_cache[source["path"]] = {"signature": source["path"], "row": row}
+            return row
+
+        def waste(rows):
+            scanned_rows[:] = rows
+            return {}
+
+        inventory = {
+            "summary": {"optional": {"enabled": 1, "review_candidates": ["skill_pack:Codex:docs"]}},
+            "control_groups": [{"id": "skill_pack:Codex:docs", "name": "docs",
+                                "control_type": "skill_pack", "runtime": "Codex",
+                                "used": False, "enabled": True}],
+        }
+        with mock.patch.dict(meter._xsess, {"data": None}), \
+                mock.patch.dict(meter._history_scan, {"progress": None, "last_complete": None}), \
+                mock.patch.dict(meter._summary_cache, {}, clear=True), \
+                mock.patch.object(meter, "all_session_sources", side_effect=discover), \
+                mock.patch.object(meter, "canonical_aggregation_sources", side_effect=list), \
+                mock.patch.object(meter, "session_summary", side_effect=summarize), \
+                mock.patch.object(meter, "global_tool_waste", side_effect=waste), \
+                mock.patch.object(meter, "capability_inventory", return_value=inventory), \
+                mock.patch.object(meter, "cross_session", side_effect=AssertionError("full aggregate")):
+            try:
+                yield parsed, scanned_rows
+            finally:
+                # The scan thread must not outlive these patches.
+                progress = meter._history_scan["progress"]
+                if progress is not None:
+                    self.assertTrue(progress["done"].wait(10))
+
+    def wait_for_history_scan(self):
+        self.assertTrue(meter._history_scan["progress"]["done"].wait(10))
+
+    def test_cold_capabilities_answers_inside_the_client_timeout_with_partial_coverage(self):
+        self.assertLess(meter.AGENT_HISTORY_BUDGET_S, 60)
+        with self.cold_session_history(count=40, parse_s=0.1) as (parsed, scanned_rows), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0):
+            started = time.monotonic()
+            result = meter.agent_capabilities(scope="all", limit=5)
+            elapsed = time.monotonic() - started
+
+            self.assertLess(elapsed, 1.0 + 1.0)
+            coverage = result["coverage"]
+            self.assertFalse(coverage["complete"])
+            self.assertEqual(coverage["sessions_total"], 40)
+            self.assertGreater(coverage["sessions_scanned"], 0)
+            self.assertLess(coverage["sessions_scanned"], 40)
+            self.assertEqual(result["assessment"], "Partial review")
+            self.assertIn("unscanned session", result["caveat"])
+            self.assertIn(f"{coverage['sessions_scanned']} of 40", result["answer"])
+            self.assertEqual(result["evidence"][-1]["label"], "Sessions scanned")
+            # Newest sources are scanned first.
+            self.assertEqual(
+                sorted(row["mtime"] for row in scanned_rows),
+                [float(index) for index in range(40 - len(scanned_rows), 40)],
+            )
+
+            self.wait_for_history_scan()
+            again = meter.agent_capabilities(scope="all", limit=5)
+
+        self.assertEqual(again["coverage"],
+                         {"complete": True, "sessions_scanned": 40, "sessions_total": 40})
+        self.assertEqual(again["assessment"], "Review available")
+        self.assertNotIn("unscanned session", again["caveat"])
+        self.assertEqual(len(again["evidence"]), 2)
+        # The background scan parsed each session once.
+        self.assertEqual(sorted(parsed), sorted(set(parsed)))
+        self.assertEqual(len(parsed), 40)
+
+    def test_capabilities_answers_while_discovery_outlasts_the_budget(self):
+        with self.cold_session_history(count=5, parse_s=0, discovery_s=2.0) as (parsed, _rows), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.05):
+            started = time.monotonic()
+            result = meter.agent_capabilities(scope="all", limit=5)
+            elapsed = time.monotonic() - started
+
+            self.assertLess(elapsed, 1.5)
+            self.assertEqual(parsed, [])
+            self.assertFalse(result["ok"])
+            self.assertEqual(result["candidates"], [])
+            self.assertNotIn("candidate_count", result)
+            self.assertEqual(result["evidence"],
+                             [{"label": "Sessions scanned", "value": "0; discovery still running"}])
+            self.assertEqual(result["coverage"],
+                             {"complete": False, "sessions_scanned": 0, "sessions_total": None})
+
+    def test_cold_current_scope_answers_before_discovery_finishes(self):
+        with self.cold_session_history(count=3, parse_s=0, discovery_s=2.0) as (parsed, _rows), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.05), \
+                mock.patch.object(meter, "recompute", side_effect=AssertionError("no run yet")):
+            started = time.monotonic()
+            result = meter.agent_capabilities(
+                scope="current", limit=5, caller={"runtime": "codex", "project": "/synthetic"},
+            )
+            elapsed = time.monotonic() - started
+            discoveries = meter.all_session_sources.call_count
+
+        self.assertLess(elapsed, 1.5)
+        # Run resolution waits for the scan's discovery instead of starting its own.
+        self.assertEqual(discoveries, 1)
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["assessment"], "History scan incomplete")
+        self.assertEqual(result["candidates"], [])
+        self.assertEqual(result["evidence"],
+                         [{"label": "Sessions scanned", "value": "0; discovery still running"}])
+        self.assertNotIn("0 of 0", json.dumps(result))
+
+    def test_current_scope_resolves_the_run_from_the_scan_discovery(self):
+        current = {"provider": "codex", "path": "/synthetic/2.jsonl", "id": "2"}
+        summary = {"enabled": 1, "groups": [
+            {"id": "skill_pack:Codex:docs", "name": "docs", "control_type": "skill_pack",
+             "runtime": "Codex", "current_used": False},
+        ]}
+        resolve = mock.Mock(return_value=(current, ""))
+        with self.cold_session_history(count=40, parse_s=0.1), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0), \
+                mock.patch.object(meter, "resolve_agent_source", resolve), \
+                mock.patch.object(meter, "recompute", return_value={"trace": []}), \
+                mock.patch.object(meter, "agent_session_summary", return_value={"id": "2"}), \
+                mock.patch.object(meter, "session_optional_capabilities", return_value=summary):
+            result = meter.agent_capabilities(scope="current", limit=5)
+            discoveries = meter.all_session_sources.call_count
+
+        self.assertEqual(discoveries, 1)
+        self.assertEqual(len(resolve.call_args.kwargs["sources"]), 40)
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["assessment"], "Partial review")
+        scanned = result["coverage"]["sessions_scanned"]
+        self.assertGreater(scanned, 0)
+        self.assertEqual(result["evidence"][-1]["value"], f"{scanned} of 40")
+        self.assertEqual([row["name"] for row in result["candidates"]], ["docs"])
+
+    def test_a_scan_thread_that_cannot_start_is_retried(self):
+        with self.cold_session_history(count=3, parse_s=0):
+            with mock.patch.object(meter.threading.Thread, "start",
+                                   side_effect=RuntimeError("can't start new thread")):
+                with self.assertRaises(RuntimeError):
+                    meter.agent_capabilities(scope="all", limit=5)
+            stuck = meter._history_scan["progress"]
+            self.assertTrue(stuck["done"].is_set())
+            result = meter.agent_capabilities(scope="all", limit=5)
+            self.assertIsNot(meter._history_scan["progress"], stuck)
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["coverage"],
+                         {"complete": True, "sessions_scanned": 3, "sessions_total": 3})
+
+    def test_cold_git_stats_withholds_totals_until_the_history_scan_completes(self):
+        project = mock.Mock(return_value={"ok": True, "projected": True})
+        spend_rows = []
+        with self.cold_session_history(count=40, parse_s=0.1) as (_parsed, _rows), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0), \
+                mock.patch.object(meter, "cached_git_delivery_candidates", return_value=()), \
+                mock.patch.object(meter, "git_delivery_ledger_candidates", return_value=()), \
+                mock.patch.object(meter, "delivery_spend_rows",
+                                  side_effect=lambda rows: spend_rows.append(
+                                      [row["mtime"] for row in rows]) or []), \
+                mock.patch.object(meter, "delivery_model_spend_rows", return_value=[]), \
+                mock.patch.object(meter, "git_delivery_service") as service, \
+                mock.patch.object(meter._mcp_delivery, "git_stats_projection", project):
+            started = time.monotonic()
+            cold = meter.agent_git_stats(range="30")
+            elapsed = time.monotonic() - started
+            self.wait_for_history_scan()
+            warm = meter.agent_git_stats(range="30")
+
+        self.assertLess(elapsed, 1.0 + 1.0)
+        self.assertTrue(cold["ok"])
+        self.assertFalse(cold["available"])
+        self.assertEqual(cold["reason"], "history_scan_incomplete")
+        self.assertFalse(cold["history"]["complete"])
+        self.assertEqual(cold["history"]["sessions_total"], 40)
+        self.assertNotIn("current", cold)
+        self.assertEqual(warm, {"ok": True, "projected": True})
+        # Totals are computed only from the complete scan, in discovery order like cross_session.
+        self.assertEqual(spend_rows, [[float(index) for index in range(40)]])
+        service.return_value.query.assert_called_once()
+
+    def test_cold_work_stats_withholds_totals_until_the_history_scan_completes(self):
+        settings = {"enabled": True, "paused_until": 0, "areas": [], "backfill_days": 0}
+        service = mock.Mock()
+        service.status.return_value = {"labels": 2, "pending": 0}
+        build = mock.Mock(return_value=({"insights": True}, None))
+        with self.cold_session_history(count=3, parse_s=0, discovery_s=2.0) as (_parsed, _rows), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.05), \
+                mock.patch.object(meter, "work_insights_supported", return_value=True), \
+                mock.patch.object(meter, "work_insights_settings", return_value=settings), \
+                mock.patch.object(meter, "work_insights_service", return_value=service), \
+                mock.patch.object(meter, "_work_insights_aggregate", build), \
+                mock.patch.object(meter._mcp_delivery, "work_stats_projection",
+                                  return_value={"ok": True, "available": True}):
+            started = time.monotonic()
+            cold = meter.agent_work_stats(period="30d", view="suggestions")
+            elapsed = time.monotonic() - started
+            self.wait_for_history_scan()
+            warm = meter.agent_work_stats(period="30d", view="suggestions")
+
+        self.assertLess(elapsed, 1.5)
+        self.assertFalse(cold["available"])
+        self.assertEqual(cold["reason"], "history_scan_incomplete")
+        self.assertEqual(cold["history"],
+                         {"complete": False, "sessions_scanned": 0, "sessions_total": None})
+        self.assertIn("withheld instead of undercounted", cold["caveat"])
+        self.assertTrue(warm["available"])
+        build.assert_called_once()
+        self.assertEqual(len(build.call_args.kwargs["source_rows"]), 3)
+
+    def test_history_scan_fills_newest_chunks_on_the_index_pool(self):
+        chunks = []
+        prefetch = mock.Mock(side_effect=lambda sources: chunks.append(
+            [int(source["id"]) for source in sources]))
+        with self.cold_session_history(count=40, parse_s=0), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_FIRST", 16), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MIN", 16), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MAX", 16), \
+                mock.patch.object(meter, "prefetch_session_summaries", prefetch):
+            result = meter.agent_capabilities(scope="all", limit=5)
+
+        self.assertTrue(result["coverage"]["complete"])
+        self.assertEqual(chunks, [list(range(39, 23, -1)), list(range(23, 7, -1)), list(range(7, -1, -1))])
+
+    def test_history_scan_shrinks_chunks_that_overrun_the_time_target(self):
+        sizes = []
+
+        def slow_fill(sources):
+            sizes.append(len(sources))
+            time.sleep(0.05)
+            return len(sources)
+
+        with self.cold_session_history(count=40, parse_s=0), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_FIRST", 16), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MIN", 4), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MAX", 64), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_TARGET_S", 0.01), \
+                mock.patch.object(meter, "prefetch_session_summaries", side_effect=slow_fill):
+            result = meter.agent_capabilities(scope="all", limit=5)
+
+        self.assertTrue(result["coverage"]["complete"])
+        # 16 sessions parsed in ~0.05 s is ~320/s, so a 0.01 s target is 3, clamped to 4.
+        self.assertEqual(sizes, [16] + [4] * 6)
+
+    def test_history_scan_never_grows_chunks_from_cached_or_tiny_fills(self):
+        sizes = []
+        returns = iter([0, 4, 40] + [0] * 20)
+
+        def fill(sources):
+            sizes.append(len(sources))
+            return next(returns)
+
+        with self.cold_session_history(count=60, parse_s=0), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_FIRST", 8), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MIN", 4), \
+                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MAX", 64), \
+                mock.patch.object(meter, "prefetch_session_summaries", side_effect=fill):
+            result = meter.agent_capabilities(scope="all", limit=5)
+
+        self.assertTrue(result["coverage"]["complete"])
+        # A cached (0) or sub-pool (4) fill keeps the size; a fast real fill at most doubles it.
+        self.assertEqual(sizes[:4], [8, 8, 8, 16])
+
+    def test_a_refresh_serves_the_last_complete_scan_while_it_runs(self):
+        with self.cold_session_history(count=5, parse_s=0) as (_parsed, _rows), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
+                mock.patch.object(meter, "HISTORY_REFRESH_WAIT_S", 0.05):
+            first = meter.agent_capabilities(scope="all", limit=5)
+            self.assertTrue(first["coverage"]["complete"])
+            self.expire_history_scan()
+            discovered = threading.Event()
+            release = threading.Event()
+
+            def slow_discovery():
+                discovered.set()
+                release.wait(5)
+                return [{"provider": "codex", "path": f"/synthetic/{index}.jsonl", "id": str(index),
+                         "mtime": float(index)} for index in range(5)]
+
+            with mock.patch.object(meter, "all_session_sources", side_effect=slow_discovery):
+                started = time.monotonic()
+                during = meter.agent_capabilities(scope="all", limit=5)
+                elapsed = time.monotonic() - started
+                release.set()
+                self.wait_for_history_scan()
+
+        self.assertTrue(discovered.is_set())
+        self.assertLess(elapsed, 1.5)
+        self.assertEqual(during["coverage"], {
+            "complete": True, "sessions_scanned": 5, "sessions_total": 5, "refreshing": True,
+        })
+        self.assertEqual(during["assessment"], "Review available")
+
+    def expire_history_scan(self):
+        meter._history_scan["progress"]["finished_at"] -= meter._XSESS_TTL + 1
+
+    def test_a_current_scope_refresh_resolves_the_run_from_the_last_complete_scan(self):
+        summary = {"enabled": 1, "groups": [
+            {"id": "skill_pack:Codex:docs", "name": "docs", "control_type": "skill_pack",
+             "runtime": "Codex", "current_used": False},
+        ]}
+        resolve = mock.Mock(return_value=({"provider": "codex", "path": "/synthetic/4.jsonl", "id": "4"}, ""))
+        release = threading.Event()
+
+        def slow_discovery():
+            release.wait(5)
+            return []
+
+        with self.cold_session_history(count=5, parse_s=0), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
+                mock.patch.object(meter, "HISTORY_REFRESH_WAIT_S", 0.05), \
+                mock.patch.object(meter, "resolve_agent_source", resolve), \
+                mock.patch.object(meter, "recompute", return_value={"trace": []}), \
+                mock.patch.object(meter, "agent_session_summary", return_value={"id": "4"}), \
+                mock.patch.object(meter, "session_optional_capabilities", return_value=summary):
+            meter.agent_capabilities(scope="current", limit=5)
+            self.expire_history_scan()
+            with mock.patch.object(meter, "all_session_sources", side_effect=slow_discovery):
+                started = time.monotonic()
+                during = meter.agent_capabilities(scope="current", limit=5)
+                elapsed = time.monotonic() - started
+                release.set()
+                self.wait_for_history_scan()
+
+        self.assertLess(elapsed, 1.5)
+        self.assertTrue(during["ok"])
+        self.assertEqual(len(resolve.call_args.kwargs["sources"]), 5)
+        self.assertTrue(during["coverage"]["refreshing"])
+
+    @contextlib.contextmanager
+    def warm_current_scope(self, previous_age_s=0.0):
+        """A process whose last complete scan finished and has expired; yields the resolve mock."""
+        summary = {"enabled": 1, "groups": [
+            {"id": "skill_pack:Codex:docs", "name": "docs", "control_type": "skill_pack",
+             "runtime": "Codex", "current_used": False},
+        ]}
+        resolve = mock.Mock(return_value=({"provider": "codex", "path": "/synthetic/4.jsonl", "id": "4"}, ""))
+        with self.cold_session_history(count=5, parse_s=0), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0), \
+                mock.patch.object(meter, "HISTORY_REFRESH_WAIT_S", 0.05), \
+                mock.patch.object(meter, "resolve_agent_source", resolve), \
+                mock.patch.object(meter, "recompute", return_value={"trace": []}), \
+                mock.patch.object(meter, "agent_session_summary", return_value={"id": "4"}), \
+                mock.patch.object(meter, "session_optional_capabilities", return_value=summary), \
+                contextlib.redirect_stderr(io.StringIO()):
+            meter.agent_capabilities(scope="current", limit=5)
+            self.wait_for_history_scan()
+            previous = meter._history_scan["last_complete"]
+            self.assertIs(previous, meter._history_scan["progress"])
+            self.expire_history_scan()
+            previous["discovered_at"] -= previous_age_s
+            resolve.reset_mock()
+            yield resolve
+
+    @staticmethod
+    def fresh_sources(count):
+        return [{"provider": "codex", "path": f"/fresh/{index}.jsonl", "id": f"f{index}",
+                 "mtime": float(100 + index)} for index in range(count)]
+
+    def test_a_current_scope_refresh_that_fails_discovery_reuses_a_recent_scan_once(self):
+        with self.warm_current_scope() as resolve:
+            failing = mock.Mock(side_effect=OSError("gone"))
+            with mock.patch.object(meter, "all_session_sources", failing):
+                result = meter.agent_capabilities(scope="current", limit=5)
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(len(resolve.call_args.kwargs["sources"]), 5)
+        self.assertTrue(result["coverage"]["refreshing"])
+        # One call starts one refresh scan, even when that scan fails.
+        self.assertEqual(failing.call_count, 1)
+
+    def test_a_current_scope_refresh_with_old_sources_waits_like_a_cold_call(self):
+        with self.warm_current_scope(previous_age_s=meter.HISTORY_SOURCE_REUSE_S + 1) as resolve:
+            fresh = self.fresh_sources(3)
+
+            def discovery():
+                time.sleep(0.3)  # Longer than the refresh cap, shorter than the call budget.
+                return fresh
+
+            with mock.patch.object(meter, "all_session_sources", side_effect=discovery):
+                result = meter.agent_capabilities(scope="current", limit=5)
+                self.wait_for_history_scan()
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(resolve.call_args.kwargs["sources"], tuple(fresh))
+
+    def test_a_current_scope_refresh_never_resolves_from_old_sources(self):
+        release = threading.Event()
+        with self.warm_current_scope(previous_age_s=meter.HISTORY_SOURCE_REUSE_S + 1) as resolve:
+            with mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.1), \
+                    mock.patch.object(meter, "all_session_sources", side_effect=lambda: release.wait(5) and []):
+                result = meter.agent_capabilities(scope="current", limit=5)
+                release.set()
+                self.wait_for_history_scan()
+
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["assessment"], "History scan incomplete")
+        resolve.assert_not_called()
+
+    def test_a_current_scope_refresh_with_old_sources_reports_failed_discovery(self):
+        with self.warm_current_scope(previous_age_s=meter.HISTORY_SOURCE_REUSE_S + 1) as resolve:
+            with mock.patch.object(meter, "all_session_sources", side_effect=OSError("gone")), \
+                    self.assertRaisesRegex(RuntimeError, "could not scan session history"):
+                meter.agent_capabilities(scope="current", limit=5)
+        resolve.assert_not_called()
+
+    def test_a_refresh_that_fails_after_discovery_resolves_from_its_own_sources(self):
+        with self.warm_current_scope() as resolve:
+            fresh = self.fresh_sources(3)
+            summarize = meter.session_summary.side_effect
+
+            def failing_summary(source, opencode_conn=None):
+                if source["path"].startswith("/fresh/"):
+                    raise ValueError("unreadable")
+                return summarize(source, opencode_conn)
+
+            with mock.patch.object(meter, "all_session_sources", return_value=fresh), \
+                    mock.patch.object(meter, "session_summary", side_effect=failing_summary):
+                result = meter.agent_capabilities(scope="current", limit=5)
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(resolve.call_args.kwargs["sources"], tuple(fresh))
+        self.assertTrue(result["coverage"]["refreshing"])
+
+    def test_a_failed_refresh_falls_back_to_the_last_complete_scan(self):
+        with self.cold_session_history(count=5, parse_s=0), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
+                contextlib.redirect_stderr(io.StringIO()):
+            meter.agent_capabilities(scope="all", limit=5)
+            self.expire_history_scan()
+            with mock.patch.object(meter, "all_session_sources", side_effect=OSError("gone")):
+                result = meter.agent_capabilities(scope="all", limit=5)
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["coverage"], {
+            "complete": True, "sessions_scanned": 5, "sessions_total": 5, "refreshing": True,
+        })
+
+    def test_capabilities_reports_a_failed_history_scan_and_retries_it(self):
+        stderr = io.StringIO()
+        with self.cold_session_history(count=3, parse_s=0, discovery_error=OSError("/secret/path boom")), \
+                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
+                contextlib.redirect_stderr(stderr):
+            with self.assertRaisesRegex(RuntimeError, "could not scan session history"):
+                meter.agent_capabilities(scope="all", limit=5)
+            failed = meter._history_scan["progress"]
+            with self.assertRaises(RuntimeError):
+                meter.agent_capabilities(scope="all", limit=5)
+            self.assertIsNot(meter._history_scan["progress"], failed)
+
+        self.assertIn("history scan: internal error at OSError at", stderr.getvalue())
+        self.assertNotIn("secret", stderr.getvalue())
+        self.assertNotIn("boom", stderr.getvalue())
+
+    def test_agent_result_has_a_hard_serialized_bound(self):
+        result = meter.bounded_agent_result({
+            "answer": "a" * 10000, "evidence": [{"label": "x", "value": "y" * 10000}] * 10,
+            "recommended_action": "z" * 10000, "caveat": "c" * 10000,
+        })
+        self.assertTrue(result["truncated"])
+        self.assertLessEqual(len(result["evidence"]), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_builder_recap.py b/tests/test_builder_recap.py
new file mode 100644
index 00000000..cf4b0768
--- /dev/null
+++ b/tests/test_builder_recap.py
@@ -0,0 +1,992 @@
+import unittest
+import datetime
+import http.client
+import json
+import os
+import sqlite3
+import tempfile
+import threading
+from pathlib import Path
+from unittest import mock
+import meter
+from token_meter.services import git_delivery as git_delivery_service_module
+from tests.meter_support import _TrackingSqliteConnection
+
+
+class GitDeliveryLedgerConnectionTests(unittest.TestCase):
+    """The ledger must close every sqlite connection it opens."""
+
+    def test_ledger_operations_close_every_connection(self):
+        from token_meter.services.git_delivery import GitDeliveryLedger
+
+        created = []
+        real_connect = sqlite3.connect
+
+        def tracking_connect(*args, **kwargs):
+            tracker = _TrackingSqliteConnection(real_connect(*args, **kwargs))
+            created.append(tracker)
+            return tracker
+
+        with tempfile.TemporaryDirectory() as directory:
+            path = os.path.join(directory, "ledger.sqlite3")
+            with mock.patch.object(
+                    git_delivery_service_module.sqlite3, "connect",
+                    side_effect=tracking_connect):
+                ledger = GitDeliveryLedger(path)
+                ledger.record("repo-key", "object-key", 1, 2, 3)
+                ledger.mark_seen("repo-key", "object-key")
+                self.assertTrue(ledger.has_seen("repo-key", "object-key"))
+                ledger.rows()
+                ledger.daily_rows(["repo-key"], "2026-09-01", "2026-09-30")
+                ledger.map_project("project-key", "repo-key")
+                ledger.repo_key_for_project("project-key")
+                ledger.set_repository_coverage("repo-key", 12, 1)
+                ledger.repository_coverage("repo-key")
+                ledger.set_last_checked(123)
+                ledger.last_checked()
+                ledger.baseline_at()
+                ledger.coalesce_repository("repo-key", "canonical-key")
+                ledger.clear(123)
+        self.assertTrue(created, "ledger operations should open connections")
+        leaked = [connection for connection in created if not connection.closed]
+        self.assertEqual(
+            [], leaked,
+            f"{len(leaked)} of {len(created)} ledger connections were never closed",
+        )
+
+
+class BuilderRecapDomainTests(unittest.TestCase):
+    def test_antigravity_is_a_public_recap_runtime(self):
+        from token_meter.domain.builder_recap import _safe_runtime
+
+        self.assertEqual(_safe_runtime("Antigravity"), "Antigravity")
+        self.assertEqual(_safe_runtime("Antigravity private"), "")
+
+    TODAY = datetime.date(2026, 9, 13)
+
+    def row(self, last, daily=(), **values):
+        return {
+            "last": last,
+            "runtime": "Codex",
+            "duration_s": 0,
+            "duration_available": False,
+            "output_tokens": 0,
+            "availability": {},
+            "_model_daily": list(daily),
+            "_performance_samples": [],
+            "_tool_evidence": {},
+            **values,
+        }
+
+    def recap(self, rows, days=7, git_days=(), previous_git_lines=None,
+              previous_git_commits=None):
+        from token_meter.domain.builder_recap import build_builder_recap
+        return build_builder_recap(
+            rows, None if git_days is None else list(git_days), days,
+            today=self.TODAY, generated_at=1_757_718_400,
+            previous_git_lines=previous_git_lines,
+            previous_git_commits=previous_git_commits,
+        )
+
+    def supporting(self, result, stat_id):
+        return next(stat for stat in result["supporting"] if stat["id"] == stat_id)
+
+    def spotlight(self, result, stat_id):
+        return next(stat for stat in result["spotlights"] if stat["id"] == stat_id)
+
+    def test_windows_are_inclusive_equal_and_local_calendar_based(self):
+        result = self.recap([], days=7)
+        self.assertEqual(result["current"], {
+            "start_day": "2026-09-07", "end_day": "2026-09-13",
+        })
+        self.assertEqual(result["previous"], {
+            "start_day": "2026-08-31", "end_day": "2026-09-06",
+        })
+        self.assertEqual(len(result["activity_days"]), 7)
+
+    def test_invalid_range_is_rejected_before_aggregation(self):
+        with self.assertRaisesRegex(ValueError, "7, 30, or 90"):
+            self.recap([], days=14)
+
+    def test_30_and_90_day_windows_remain_equal_length_and_inclusive(self):
+        recap_30 = self.recap([], days=30)
+        recap_90 = self.recap([], days=90)
+        self.assertEqual(recap_30["current"], {
+            "start_day": "2026-08-15", "end_day": "2026-09-13",
+        })
+        self.assertEqual(recap_30["previous"], {
+            "start_day": "2026-07-16", "end_day": "2026-08-14",
+        })
+        self.assertEqual(recap_90["current"], {
+            "start_day": "2026-06-16", "end_day": "2026-09-13",
+        })
+        self.assertEqual(recap_90["previous"], {
+            "start_day": "2026-03-18", "end_day": "2026-06-15",
+        })
+
+    def test_core_aggregates_use_day_level_paired_coverage(self):
+        paired = lambda day, output, cost: {
+            "day": day, "model": "gpt-5", "output_tokens": output,
+            "cost_covered_output_tokens": output, "cost_covered_cost": cost,
+        }
+        mixed = {
+            "day": "2026-09-13", "model": "gpt-5", "output_tokens": 900,
+            "cost_covered_output_tokens": 0, "cost_covered_cost": 9,
+        }
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [
+                paired("2026-09-13", 200, 1), paired("2026-08-31", 100, 1),
+            ]),
+            self.row("2026-09-12T18:00:00", [
+                paired("2026-09-12", 100, 0.5), paired("2026-09-10", 100, 0.5),
+            ]),
+            self.row("2026-09-01T18:00:00", [mixed]),
+        ])
+
+        self.assertEqual(result["activity_days"][-1], {
+            "day": "2026-09-13", "recorded_session": True,
+        })
+        self.assertEqual(self.spotlight(result, "build_streak")["current"], 2)
+        self.assertEqual(self.spotlight(result, "efficiency_change")["current"], 200.0)
+        self.assertEqual(self.spotlight(result, "efficiency_change")["previous"], 100.0)
+        self.assertEqual(self.spotlight(result, "efficiency_change")["delta_pct"], 100.0)
+
+    def test_covered_spend_sums_paired_cost_and_stays_unavailable_when_absent(self):
+        paired = lambda day, output, cost: {
+            "day": day, "model": "gpt-5", "output_tokens": output,
+            "cost_covered_output_tokens": output, "cost_covered_cost": cost,
+        }
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [
+                paired("2026-09-13", 200, 1.25), paired("2026-09-12", 100, 0.75),
+                paired("2026-08-31", 100, 2.5),
+            ]),
+        ])
+
+        spend = self.supporting(result, "covered_spend")
+        self.assertEqual(spend["family"], "cost")
+        self.assertTrue(spend["available"])
+        self.assertAlmostEqual(spend["current"], 2.0)
+        self.assertAlmostEqual(spend["previous"], 2.5)
+        self.assertEqual(spend["unit"], "USD")
+        self.assertEqual(spend["basis"], "paired cost-covered output and cost")
+        self.assertEqual(spend["sample_count"], 2)
+
+        # Output with no paired cost must not become a measured zero.
+        uncovered = self.recap([
+            self.row("2026-09-13T18:00:00", [{
+                "day": "2026-09-13", "model": "gpt-5", "output_tokens": 900,
+                "cost_covered_output_tokens": 0, "cost_covered_cost": 0,
+            }]),
+        ])
+        self.assertEqual(
+            [stat["id"] for stat in uncovered["supporting"]
+             if stat["id"] == "covered_spend"],
+            [],
+        )
+
+    def test_every_supporting_stat_id_has_a_deterministic_sort_position(self):
+        paired = lambda day, output, cost: {
+            "day": day, "model": "gpt-5", "output_tokens": output,
+            "cost_covered_output_tokens": output, "cost_covered_cost": cost,
+        }
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [
+                paired("2026-09-13", 200, 1.25), paired("2026-08-31", 100, 2.5),
+            ], duration_s=120, duration_available=True, _performance_samples=[
+                {"day": "2026-09-13", "output_tokens": 400, "generation_s": 4},
+                {"day": "2026-08-31", "output_tokens": 300, "generation_s": 5},
+            ], _tool_evidence={"tools": [{"daily": [
+                {"day": "2026-09-13", "calls": 12},
+            ]}]}),
+        ], git_days=[
+            {"day": "2026-09-13", "available": True, "active": True,
+             "changed_lines": 400},
+        ])
+
+        ordered = [stat["id"] for stat in result["supporting"]]
+        self.assertEqual(ordered, sorted(set(ordered), key=ordered.index))
+        self.assertIn("covered_spend", ordered)
+
+    def test_efficiency_comparison_is_unavailable_with_prior_zero_cost(self):
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [{
+                "day": "2026-09-13", "model": "gpt-5", "output_tokens": 100,
+                "cost_covered_output_tokens": 100, "cost_covered_cost": 1,
+            }, {
+                "day": "2026-08-31", "model": "gpt-5", "output_tokens": 100,
+                "cost_covered_output_tokens": 100, "cost_covered_cost": 0,
+            }]),
+        ])
+
+        efficiency = self.spotlight(result, "efficiency_change")
+        self.assertFalse(efficiency["available"])
+        self.assertIsNone(efficiency["delta_pct"])
+
+    def test_malformed_non_finite_evidence_is_ignored(self):
+        result = self.recap([self.row("not-a-date", [{
+            "day": "2026-09-13", "model": "gpt-5", "output_tokens": 100,
+            "cost_covered_output_tokens": float("nan"),
+            "cost_covered_cost": float("inf"),
+        }], mtime=float("inf"), _performance_samples=[{
+            "day": "2026-09-13", "output_tokens": float("inf"),
+            "duration_s": float("nan"),
+        }], _tool_evidence={"tools": [{"daily": [{
+            "day": "2026-09-13", "calls": float("inf"),
+        }]}]})])
+
+        self.assertEqual(result["activity_days"][-1], {
+            "day": "2026-09-13", "recorded_session": True,
+        })
+        self.assertFalse(self.spotlight(result, "efficiency_change")["available"])
+        self.assertNotIn("output_pace", [stat["id"] for stat in result["supporting"]])
+        self.assertEqual(result["coverage"]["tools"]["eligible"], 0)
+
+    def test_float_conversion_overflow_is_ignored_as_unavailable_evidence(self):
+        class OverflowingFloat:
+            def __float__(self):
+                raise OverflowError("malformed numeric evidence")
+
+        overflow = OverflowingFloat()
+        result = self.recap([
+            self.row("not-a-date", [], mtime=overflow),
+            self.row("2026-09-13T18:00:00", [{
+                "day": "2026-09-13", "model": "gpt-5",
+                "cost_covered_output_tokens": overflow,
+                "cost_covered_cost": overflow,
+            }]),
+        ])
+
+        self.assertEqual(result["activity_days"][-1], {
+            "day": "2026-09-13", "recorded_session": True,
+        })
+        self.assertFalse(self.spotlight(result, "efficiency_change")["available"])
+
+    def test_git_coverage_requires_explicit_available_evidence_and_counts_only_active_days(self):
+        unavailable = self.recap([], git_days=None)
+        no_measured_rows = self.recap([], git_days=())
+        measured_inactive = self.recap([], git_days=[
+            {"day": f"2026-09-{day:02d}", "available": True, "active": False}
+            for day in range(7, 14)
+        ] + [{"day": "2026-09-12", "available": False, "active": True}])
+
+        self.assertFalse(unavailable["coverage"]["git"]["available"])
+        self.assertFalse(unavailable["coverage"]["git"]["projection_available"])
+        self.assertFalse(no_measured_rows["coverage"]["git"]["available"])
+        self.assertTrue(no_measured_rows["coverage"]["git"]["projection_available"])
+        self.assertEqual(no_measured_rows["coverage"]["git"]["eligible"], 0)
+        self.assertFalse(self.spotlight(no_measured_rows, "lines_pushed")["available"])
+        self.assertNotIn("delivery_active_days", [
+            stat["id"] for stat in no_measured_rows["supporting"]
+        ])
+        self.assertTrue(measured_inactive["coverage"]["git"]["available"])
+        self.assertTrue(measured_inactive["coverage"]["git"]["projection_available"])
+        self.assertEqual(measured_inactive["coverage"]["git"]["eligible"], 7)
+        self.assertEqual(
+            self.supporting(measured_inactive, "delivery_active_days")["current"], 0
+        )
+        delivery = self.supporting(measured_inactive, "delivery_active_days")
+        self.assertIsNone(delivery["previous"])
+        self.assertIsNone(delivery["delta"])
+
+    def test_lines_pushed_sums_only_measured_nonnegative_integer_change_volume(self):
+        result = self.recap([], previous_git_lines=120_000, git_days=[
+            {"day": "2026-09-13", "available": True, "active": True,
+             "changed_lines": 184_392},
+            {"day": "2026-09-12", "available": True, "active": True,
+             "changed_lines": True},
+            {"day": "2026-09-11", "available": True, "active": True,
+             "changed_lines": -1},
+            {"day": "2026-09-10", "available": True, "active": True,
+             "changed_lines": 1.5},
+            {"day": "2026-09-09", "available": True, "active": True,
+             "changed_lines": float("inf")},
+            {"day": "2026-09-08", "available": True, "active": True,
+             "changed_lines": "999999"},
+            {"day": "2026-09-08", "available": True, "active": True,
+             "changed_lines": 10 ** 1000},
+            {"day": "2026-09-07", "available": False, "active": True,
+             "changed_lines": 999_999},
+        ])
+
+        lines = self.spotlight(result, "lines_pushed")
+        self.assertTrue(lines["available"])
+        self.assertEqual(lines["current"], 184_392)
+        self.assertEqual(lines["previous"], 120_000)
+        self.assertEqual(lines["delta"], 64_392)
+        self.assertAlmostEqual(lines["delta_pct"], 53.66, places=2)
+        self.assertEqual(lines["unit"], "lines")
+        self.assertEqual(
+            lines["basis"],
+            "added plus deleted text lines from successful local pushes",
+        )
+        self.assertEqual(lines["sample_count"], 1)
+
+    def test_commits_pushed_sums_only_measured_nonnegative_integer_commit_counts(self):
+        result = self.recap([], previous_git_commits=94, git_days=[
+            {"day": "2026-09-13", "available": True, "active": True,
+             "changed_lines": 900, "commits": 7},
+            {"day": "2026-09-12", "available": True, "active": True,
+             "changed_lines": 400, "commits": 5},
+            {"day": "2026-09-11", "available": True, "active": True,
+             "changed_lines": 300, "commits": True},
+            {"day": "2026-09-10", "available": True, "active": True,
+             "changed_lines": 200, "commits": -1},
+            {"day": "2026-09-09", "available": True, "active": True,
+             "changed_lines": 100, "commits": 2.5},
+            {"day": "2026-09-08", "available": True, "active": True,
+             "changed_lines": 100, "commits": "12"},
+            {"day": "2026-09-07", "available": False, "active": True,
+             "changed_lines": 100, "commits": 999},
+        ])
+
+        commits = self.spotlight(result, "commits_pushed")
+        self.assertTrue(commits["available"])
+        self.assertEqual(commits["current"], 12)
+        self.assertEqual(commits["previous"], 94)
+        self.assertEqual(commits["delta"], -82)
+        self.assertEqual(commits["unit"], "commits")
+        self.assertEqual(
+            commits["basis"],
+            "own non-merge commits introduced by successful local pushes",
+        )
+        self.assertEqual(commits["sample_count"], 2)
+
+    def test_commits_pushed_is_unavailable_without_measured_commit_evidence(self):
+        missing_projection = self.recap([], git_days=None)
+        no_commit_field = self.recap([], git_days=[
+            {"day": "2026-09-13", "available": True, "active": True,
+             "changed_lines": 120},
+        ])
+
+        for result in (missing_projection, no_commit_field):
+            commits = self.spotlight(result, "commits_pushed")
+            self.assertFalse(commits["available"])
+            self.assertIsNone(commits["current"])
+            self.assertEqual(commits["sample_count"], 0)
+        self.assertTrue(
+            self.spotlight(no_commit_field, "lines_pushed")["available"]
+        )
+
+    def test_public_labels_reject_paths_urls_controls_and_credentialish_values(self):
+        sentinels = ("/private/repo", "https://secret.example", "sk-live-secret",
+                     "api_key=secret", "builder@example.com", "<private>", "bad\x00label",
+                     "Untrusted runtime narrative", "Untrusted model narrative",
+                     "Please upload your credentials")
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [{
+                "day": "2026-09-13", "model": sentinels[0], "executions": 9,
+            }, {
+                "day": "2026-09-12", "model": "gpt-5.2-codex", "executions": 3,
+            }], runtime=sentinels[1], _tool_evidence={"tools": [
+                {"name": "read_file", "display": sentinels[2], "daily": [{
+                    "day": "2026-09-13", "calls": 9,
+                }]},
+                {"name": "read_file", "display": sentinels[9], "daily": [{
+                    "day": "2026-09-12", "calls": 3,
+                }]},
+            ]}),
+            self.row("2026-09-13T17:00:00", [{
+                "day": "2026-09-13", "model": sentinels[3], "executions": 9,
+            }], runtime=sentinels[4]),
+            self.row("2026-09-13T16:00:00", [{
+                "day": "2026-09-13", "model": sentinels[5], "executions": 9,
+            }], runtime=sentinels[6]),
+            self.row("2026-09-11T16:00:00", [{
+                "day": "2026-09-11", "model": "gpt-5.2-codex", "executions": 3,
+            }], runtime="Codex"),
+            self.row("2026-09-10T16:00:00", [{
+                "day": "2026-09-10", "model": sentinels[8], "executions": 3,
+            }], runtime=sentinels[7]),
+        ])
+
+        payload = json.dumps(result, sort_keys=True)
+        for sentinel in sentinels:
+            self.assertNotIn(sentinel, payload)
+        self.assertIn("gpt-5.2-codex", payload)
+        self.assertIn("Read file", payload)
+
+    def test_public_model_projection_rejects_project_like_identifiers(self):
+        private_models = (
+            "customer-acme-project", "project-alpha", "repo-token-meter",
+            "workspace-client-a", "internal-app", "my-secret-build",
+            "gpt-5.6-customer-acme-project", "claude-project-alpha",
+            "gpt5customer", "qwen3customer", "llama3project",
+            "gemma3tenant", "starcoder2internal", "gpt5acme",
+        )
+        daily = [{
+            "day": "2026-09-13", "model": model, "executions": 9,
+        } for model in private_models]
+        daily.append({
+            "day": "2026-09-13", "model": "gpt-5.6-sol", "executions": 3,
+        })
+
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", daily, runtime="Codex"),
+        ])
+
+        payload = json.dumps(result, sort_keys=True)
+        for model in private_models:
+            self.assertNotIn(model, payload)
+        self.assertIn("gpt-5.6-sol", payload)
+
+    def test_public_model_projection_preserves_versioned_family_labels(self):
+        public_models = (
+            "qwen3-coder", "starcoder2", "llama3.3", "gemma3",
+            "deepseek-v3", "o3", "claude-sonnet-4-6", "gpt-5.6-sol",
+        )
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [{
+                "day": "2026-09-13", "model": model, "executions": 1,
+            } for model in public_models], runtime="Codex"),
+        ])
+
+        self.assertEqual(
+            {row["model"] for row in result["stack"]["models"]},
+            set(public_models),
+        )
+
+    def test_output_pace_models_and_dated_tools_are_aggregated_by_period(self):
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [{
+                "day": "2026-09-13", "model": "gpt-5.5",
+            }], runtime="Codex", _performance_samples=[{
+                "day": "2026-09-13", "output_tokens": 300, "duration_s": 30,
+            }, {
+                "day": "2026-08-31", "output_tokens": 100, "duration_s": 20,
+            }], _tool_evidence={"tools": [{"name": "read_file", "display": "Read file", "daily": [{
+                "day": "2026-09-13", "calls": 4,
+            }, {"day": "2026-08-31", "calls": 2}]}]}),
+            self.row("2026-09-12T18:00:00", [{
+                "day": "2026-09-12", "model": "gpt-5.5",
+            }], runtime="Claude"),
+        ])
+
+        pace = self.supporting(result, "output_pace")
+        self.assertEqual(pace["current"], 10.0)
+        self.assertEqual(pace["previous"], 5.0)
+        self.assertEqual(pace["delta_pct"], 100.0)
+        self.assertEqual(result["stack"]["models"], [
+            {"runtime": "Claude", "model": "gpt-5.5"},
+            {"runtime": "Codex", "model": "gpt-5.5"},
+        ])
+        self.assertEqual(result["coverage"]["tools"]["eligible"], 1)
+
+    def test_usage_rankings_are_capped_scoped_and_private(self):
+        rows = []
+        fixtures = [
+            ("Codex", "gpt-5.3-codex", (4, 3, 2, 1)),
+            ("Claude", "gpt-5.5", (3, 2, 1)),
+            ("Cursor", "cursor-small", (2, 2)),
+            ("OpenCode", "gpt-5.5", (3,)),
+        ]
+        serial = 0
+        for runtime, model, executions in fixtures:
+            for count in executions:
+                serial += 1
+                day = 13 - ((serial - 1) % 7)
+                rows.append(self.row(
+                    f"2026-09-{day:02d}T12:00:00",
+                    [{"day": f"2026-09-{day:02d}", "model": model,
+                      "executions": count}],
+                    id=f"private-session-{serial}", runtime=runtime,
+                ))
+
+        result = self.recap(rows)
+
+        self.assertEqual(result["usage"]["agents"], [
+            {"label": "Codex", "count": 4, "share": 40.0},
+            {"label": "Claude", "count": 3, "share": 30.0},
+            {"label": "Cursor", "count": 2, "share": 20.0},
+        ])
+        self.assertEqual(result["usage"]["models"], [
+            {"label": "gpt-5.3-codex", "runtime": "Codex",
+             "count": 10, "share": 43.47826086956522},
+            {"label": "gpt-5.5", "runtime": "Claude",
+             "count": 6, "share": 26.08695652173913},
+            {"label": "cursor-small", "runtime": "Cursor",
+             "count": 4, "share": 17.391304347826086},
+        ])
+        serialized = json.dumps(result["usage"], sort_keys=True)
+        self.assertNotIn("private-session", serialized)
+        self.assertNotIn("OpenCode", serialized)
+
+    def test_spotlight_eligibility_uses_safe_period_evidence(self):
+        def daily(day, model, executions=1, output=0, cost=0):
+            return {"day": day, "model": model, "executions": executions,
+                    "output_tokens": output, "cost_covered_output_tokens": output,
+                    "cost_covered_cost": cost}
+
+        result = self.recap([
+            self.row("2026-09-13T18:00:00", [
+                daily("2026-09-13", "gpt-5", 5, 900, 3),
+                daily("2026-09-12", "gpt-5", 2, 100, 1),
+            ], id="session-secret", runtime="Codex", duration_s=50,
+                wall_duration_s=9_999, duration_available=True,
+                _performance_samples=[
+                    {"day": "2026-09-13", "model": "gpt-5", "output_tokens": 600, "generation_s": 30},
+                    {"day": "2026-09-12", "model": "gpt-5", "output_tokens": 500, "generation_s": 20},
+                    {"day": "2026-09-11", "model": "gpt-5", "output_tokens": 400, "generation_s": 10},
+                ], _tool_evidence={"tools": [
+                    {"name": "read_file", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 8}]},
+                    {"name": "Token Meter diagnostics", "daily": [{"day": "2026-09-13", "calls": 99}]},
+                ]}),
+            self.row("2026-09-13T17:00:00", [daily("2026-09-13", "claude", 5, 600, 3)],
+                id="codex-second", runtime="Codex", duration_s=10, duration_available=True),
+            self.row("2026-09-12T17:00:00", [daily("2026-09-12", "claude", 5, 600, 3)],
+                id="claude-first", runtime="Claude", duration_s=20, duration_available=True),
+            self.row("2026-09-11T17:00:00", [daily("2026-09-11", "unknown-model", 9)],
+                id="claude-second", runtime="unknown", duration_s=30, duration_available=False,
+                wall_duration_s=10_000),
+            self.row("2026-09-10T17:00:00", [daily("2026-09-10", "unknown", 9)],
+                runtime="unknown", id="unknown-session"),
+        ])
+
+        self.assertEqual({row["id"] for row in result["spotlights"]}, {
+            "efficiency_record", "efficiency_change", "marathon_session",
+            "speed_champion", "build_streak", "daily_driver", "go_to_model",
+            "lines_pushed", "commits_pushed", "biggest_build", "tool_mvp",
+            "stack_explorer",
+        })
+        self.assertEqual(self.spotlight(result, "marathon_session")["current"], 50)
+        self.assertEqual(self.spotlight(result, "speed_champion")["current"], 25.0)
+        self.assertEqual(self.spotlight(result, "speed_champion")["leaders"], [
+            {"runtime": "Codex", "model": "gpt-5"},
+        ])
+        self.assertEqual(self.spotlight(result, "daily_driver")["leaders"], [
+            {"runtime": "Codex"},
+        ])
+        self.assertEqual(self.spotlight(result, "go_to_model")["leaders"], [
+            {"runtime": "Codex", "model": "gpt-5"},
+        ])
+        biggest = self.spotlight(result, "biggest_build")
+        self.assertEqual(biggest["current"], 1_000)
+        self.assertEqual(biggest["leaders"], [{"runtime": "Codex"}])
+        self.assertEqual(self.spotlight(result, "tool_mvp")["leaders"], [
+            {"tool": "Read file"},
+        ])
+        self.assertEqual(self.spotlight(result, "stack_explorer")["current"], 5)
+
+    def test_record_ties_and_auto_selection_follow_the_contract(self):
+        def paired(day, output, cost):
+            return {"day": day, "model": "gpt-5", "executions": 1,
+                    "cost_covered_output_tokens": output, "cost_covered_cost": cost}
+
+        record_rows = [self.row("2026-09-13T12:00:00", [paired("2026-09-13", 400, 1)])]
+        for day in ("2026-09-06", "2026-08-30", "2026-08-23"):
+            record_rows[0]["_model_daily"].append(paired(day, 100, 1))
+        record_result = self.recap(record_rows)
+        self.assertTrue(self.spotlight(record_result, "efficiency_record")["available"])
+        self.assertEqual(record_result["spotlight_default"], "efficiency_change")
+
+        tied = self.recap([
+            self.row("2026-09-13T12:00:00", id="a", runtime="Codex"),
+            self.row("2026-09-12T12:00:00", id="b", runtime="Claude"),
+        ])
+        self.assertEqual(self.spotlight(tied, "daily_driver")["leaders"], [
+            {"runtime": "Claude"}, {"runtime": "Codex"},
+        ])
+        three_way = self.recap([
+            self.row("2026-09-13T12:00:00", id="a", runtime="Codex"),
+            self.row("2026-09-12T12:00:00", id="b", runtime="Claude"),
+            self.row("2026-09-11T12:00:00", id="c", runtime="Cursor"),
+        ])
+        self.assertFalse(self.spotlight(three_way, "daily_driver")["available"])
+
+        tied_record = self.recap([self.row("2026-09-13T12:00:00", [
+            paired("2026-09-13", 100, 1), paired("2026-09-06", 100, 1),
+            paired("2026-08-30", 50, 1), paired("2026-08-23", 50, 1),
+        ])])
+        self.assertFalse(self.spotlight(tied_record, "efficiency_record")["available"])
+
+        streak_result = self.recap([
+            self.row("2026-09-13T12:00:00", id="a"),
+            self.row("2026-09-12T12:00:00", id="b"),
+        ])
+        self.assertEqual(streak_result["spotlight_default"], "build_streak")
+        self.assertIsNone(self.recap([])["spotlight_default"])
+
+    def test_public_recap_is_a_recursive_privacy_allowlist(self):
+        def recursive_keys(value, path=()):
+            if isinstance(value, dict):
+                for key, item in value.items():
+                    yield path + (key,)
+                    yield from recursive_keys(item, path + (key,))
+            elif isinstance(value, list):
+                for item in value:
+                    yield from recursive_keys(item, path + ("*",))
+
+        result = self.recap([self.row("2026-09-13T12:00:00", [{
+            "day": "2026-09-13", "model": "gpt-5", "executions": 1,
+            "cost_covered_output_tokens": 100, "cost_covered_cost": 1,
+            "path": "/private/repo", "project": "SECRET_PROMPT",
+        }], id="session-secret", path="/private/repo", project="SECRET_PROMPT",
+            title="commit subject", session_name="session-secret",
+            desktop_session_id="session-secret", args_fingerprint="tool result secret",
+            raw_error="tool result secret", _tool_evidence={"tools": [{
+                "name": "read_file", "id": "tool-secret", "args_fingerprint": "tool result secret",
+                "daily": [{"day": "2026-09-13", "calls": 1, "raw_error": "tool result secret"}],
+            }]} )])
+        forbidden = {"path", "project", "title", "session_name", "desktop_session_id",
+                     "args_fingerprint", "raw_error"}
+        for path in recursive_keys(result):
+            self.assertNotIn(path[-1], forbidden)
+            if path[-1] == "id":
+                self.assertIn(path[:-1], {("spotlights", "*"), ("supporting", "*"),
+                                          ("headlines", "*")})
+        payload = json.dumps(result, sort_keys=True)
+        for sentinel in ("SECRET_PROMPT", "/private/repo", "session-secret",
+                         "commit subject", "tool result secret"):
+            self.assertNotIn(sentinel, payload)
+
+    def test_tool_mvp_excludes_token_meter_mcp_and_projects_safe_display(self):
+        result = self.recap([self.row("2026-09-13T12:00:00", [], _tool_evidence={
+            "tools": [{
+                "name": "mcp__tokenmeter__diagnose", "display": "diagnose",
+                "namespace": "tokenmeter", "kind": "mcp",
+                "daily": [{"day": "2026-09-13", "calls": 99}],
+            }, {
+                "name": "read_file_v2", "display": "Read file", "namespace": "filesystem",
+                "kind": "tool", "daily": [{"day": "2026-09-13", "calls": 3}],
+            }, {
+                "name": "secret", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
+            }, {
+                "name": "password", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
+            }, {
+                "name": "authorization", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
+            }, {
+                "name": "access_token", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
+            }, {
+                "name": "mcp__safe__access_token", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
+            }],
+        })])
+
+        tool = self.spotlight(result, "tool_mvp")
+        self.assertTrue(tool["available"])
+        self.assertEqual(tool["leaders"], [{"tool": "Read file"}])
+        self.assertEqual(result["coverage"]["tools"]["eligible"], 1)
+        payload = json.dumps(result, sort_keys=True)
+        for sentinel in ("mcp__tokenmeter__diagnose", "read_file_v2", "Secret", "Password",
+                         "Authorization", "Access token"):
+            self.assertNotIn(sentinel, payload)
+
+    def test_tool_mvp_projects_unknown_provider_identifiers_to_fixed_generic_labels(self):
+        private_names = (
+            "mcp__repo__private-project-alpha",
+            "mcp__workspace__customer_acme",
+            "git_private_repo",
+        )
+        result = self.recap([self.row("2026-09-13T12:00:00", [], _tool_evidence={
+            "tools": [
+                {"name": "read_file_v2", "display": "untrusted display", "daily": [
+                    {"day": "2026-09-13", "calls": 5},
+                ]},
+                *[{"name": name, "display": "untrusted display", "daily": [
+                    {"day": "2026-09-13", "calls": 1},
+                ]} for name in private_names],
+            ],
+        })])
+
+        self.assertEqual(self.spotlight(result, "tool_mvp")["leaders"], [{"tool": "Read file"}])
+        self.assertEqual(self.spotlight(result, "tool_mvp")["current"], 5)
+        self.assertEqual(result["coverage"]["tools"]["eligible"], 3)
+        payload = json.dumps(result, sort_keys=True)
+        for private_name in private_names:
+            self.assertNotIn(private_name, payload)
+        for fragment in ("private-project-alpha", "customer_acme", "private repo"):
+            self.assertNotIn(fragment, payload)
+
+    def headline(self, result, headline_id):
+        return next((item for item in result["headlines"] if item["id"] == headline_id), None)
+
+    def test_headlines_are_absent_without_evidence(self):
+        result = self.recap([], days=30)
+        self.assertEqual(result["headlines"], [])
+        # One session and one day prove no identity, streak, week, or cache claim.
+        single = self.recap([self.row("2026-09-13T12:00:00", [{
+            "day": "2026-09-13", "model": "gpt-5", "executions": 1,
+            "input_tokens": 100, "cache_read_tokens": 0,
+            "cost_covered_output_tokens": 100, "cost_covered_cost": 1,
+        }], id="only")], days=30)
+        self.assertEqual(single["headlines"], [])
+
+    def test_identity_headline_requires_sixty_percent_of_sessions(self):
+        rows = [self.row(f"2026-09-{13 - index:02d}T12:00:00", id=f"claude-{index}",
+                         runtime="Claude Code") for index in range(6)]
+        rows += [self.row("2026-09-01T12:00:00", id=f"codex-{index}") for index in range(4)]
+        at_threshold = self.headline(self.recap(rows, days=30), "identity")
+        self.assertEqual(at_threshold, {
+            "id": "identity", "title": "A Claude person", "value": "60%",
+            "detail": "of sessions on Claude Code",
+        })
+        below = self.recap(rows + [self.row("2026-09-02T12:00:00", id="codex-x")], days=30)
+        self.assertIsNone(self.headline(below, "identity"))
+        vowel = self.headline(self.recap([
+            self.row("2026-09-13T12:00:00", id=f"oc-{index}", runtime="OpenCode")
+            for index in range(3)
+        ], days=7), "identity")
+        self.assertEqual((vowel["title"], vowel["value"]), ("An OpenCode person", "100%"))
+        # Rounding never overstates a share.
+        rows = [self.row("2026-09-13T12:00:00", id=f"c-{index}", runtime="Claude Code")
+                for index in range(2)] + [self.row("2026-09-13T12:00:00", id="x")]
+        self.assertEqual(self.headline(self.recap(rows), "identity")["value"], "66%")
+
+    def test_streak_headline_reports_the_longest_run_of_three_or_more_days(self):
+        two = self.recap([self.row("2026-09-13T12:00:00", id="a"),
+                          self.row("2026-09-12T12:00:00", id="b")])
+        self.assertIsNone(self.headline(two, "streak"))
+        four = self.recap([self.row(f"2026-09-{day:02d}T12:00:00", id=str(day))
+                           for day in (13, 12, 11, 10, 8)])
+        self.assertEqual(self.headline(four, "streak"), {
+            "id": "streak", "title": "Longest streak", "value": "4 days",
+            "detail": "consecutive active days",
+        })
+
+    def test_best_week_headline_compares_comparable_weeks_and_says_estimate(self):
+        def day(value, output, cost):
+            return {"day": value, "model": "gpt-5", "executions": 1,
+                    "cost_covered_output_tokens": output, "cost_covered_cost": cost}
+        rows = [self.row("2026-09-13T12:00:00", [
+            day("2026-09-13", 3000, 1), day("2026-09-05", 1000, 1),
+            day("2026-08-29", 1000, 1),
+        ], id="weeks")]
+        best = self.headline(self.recap(rows, days=30), "best_week")
+        self.assertEqual(best["title"], "Best week")
+        self.assertEqual(best["value"], "3.0×")
+        self.assertIn("estimate", best["detail"])
+        # A 7-day period has one week, so there is nothing to compare against.
+        self.assertIsNone(self.headline(self.recap(rows, days=7), "best_week"))
+        flat = [self.row("2026-09-13T12:00:00", [
+            day("2026-09-13", 1000, 1), day("2026-09-05", 1000, 1),
+        ], id="flat")]
+        self.assertIsNone(self.headline(self.recap(flat, days=30), "best_week"))
+
+    def test_cache_share_headline_uses_only_cache_covered_input(self):
+        rows = [self.row("2026-09-13T12:00:00", [{
+            "day": "2026-09-13", "model": "gpt-5", "executions": 2,
+            "input_tokens": 1000, "cache_read_tokens": 875,
+        }, {
+            "day": "2026-09-13", "model": "gpt-5-mini", "executions": 1,
+            "input_tokens": 5000, "cache_read_tokens": 0,
+            "availability": {"cache": False},
+        }], id="cached")]
+        self.assertEqual(self.headline(self.recap(rows), "cache_share"), {
+            "id": "cache_share", "title": "Cache-powered", "value": "87%",
+            "detail": "of input tokens read from cache",
+        })
+        uncovered = [self.row("2026-09-13T12:00:00", [{
+            "day": "2026-09-13", "model": "gpt-5", "executions": 1,
+            "input_tokens": 1000, "cache_read_tokens": 900,
+        }], id="none", availability={"cache": False})]
+        self.assertIsNone(self.headline(self.recap(uncovered), "cache_share"))
+
+    def test_headlines_are_bounded_ordered_and_content_free(self):
+        rows = [self.row(f"2026-09-{13 - index:02d}T12:00:00", [{
+            "day": f"2026-09-{13 - index:02d}", "model": "claude-sonnet-4-5", "executions": 1,
+            "input_tokens": 1000, "cache_read_tokens": 900,
+            "cost_covered_output_tokens": 1000 * (index + 1), "cost_covered_cost": 1,
+        }], id=f"secret-session-{index}", runtime="Claude Code",
+            project="/private/repo", title="SECRET_PROMPT") for index in range(12)]
+        result = self.recap(rows, days=30)
+        self.assertEqual([item["id"] for item in result["headlines"]],
+                         ["identity", "best_week", "streak", "cache_share"])
+        self.assertLessEqual(len(result["headlines"]), 4)
+        for item in result["headlines"]:
+            self.assertEqual(sorted(item), ["detail", "id", "title", "value"])
+            self.assertTrue(all(isinstance(item[key], str) and len(item[key]) <= 48
+                                for key in item))
+        payload = json.dumps(result["headlines"])
+        for sentinel in ("secret-session", "/private/repo", "SECRET_PROMPT", "percentile"):
+            self.assertNotIn(sentinel, payload)
+
+
+class BuilderRecapEndpointTests(unittest.TestCase):
+    def setUp(self):
+        self.saved_cache = dict(meter._xsess)
+
+    def tearDown(self):
+        meter._xsess.clear()
+        meter._xsess.update(self.saved_cache)
+
+    def test_builder_recap_state_reduces_git_evidence_before_public_build(self):
+        expected = {"ok": True, "generated_at": 123, "privacy": {
+            "content_included": False, "project_identity_included": False,
+        }}
+        meter._xsess["internal_rows"] = [{"id": "private"}]
+        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
+                mock.patch.object(meter, "git_delivery_state", return_value={
+                    "ok": True,
+                    "previous": {
+                        "changed_lines": 8, "commits": 2,
+                        "availability": {"code_pushed": True},
+                        "project": "/private/previous", "subject": "secret previous",
+                    },
+                    "days": [{
+                        "day": "2026-09-13", "changed_lines": 12, "commits": 3,
+                        "availability": {"code_pushed": True},
+                        "project": "/private/repo", "subject": "secret",
+                    }],
+                }), \
+                mock.patch.object(meter, "_domain_build_builder_recap", return_value=expected) as build:
+            payload, status = meter.builder_recap_state("30")
+
+        self.assertEqual(status, 200)
+        self.assertEqual(payload, expected)
+        build.assert_called_once()
+        self.assertEqual(build.call_args.args[0], [{"id": "private"}])
+        self.assertEqual(build.call_args.args[1], [{
+            "day": "2026-09-13", "available": True, "active": True,
+            "changed_lines": 12, "commits": 3,
+        }])
+        self.assertEqual(build.call_args.args[2], 30)
+        self.assertEqual(build.call_args.kwargs["generated_at"], 123)
+        self.assertEqual(build.call_args.kwargs["previous_git_lines"], 8)
+        self.assertEqual(build.call_args.kwargs["previous_git_commits"], 2)
+        self.assertNotIn("/private/repo", json.dumps(build.call_args.args[1]))
+        self.assertNotIn("secret", json.dumps(build.call_args.args[1]))
+        self.assertNotIn("private/previous", json.dumps(build.call_args.kwargs))
+
+    def test_builder_recap_state_fails_closed_on_malformed_changed_line_counts(self):
+        meter._xsess["internal_rows"] = []
+        malformed = (True, -1, 1.5, float("inf"), "999", 10 ** 1000)
+        days = [{
+            "day": f"2026-09-{13 - index:02d}", "changed_lines": value,
+            "commits": value, "availability": {"code_pushed": True},
+        } for index, value in enumerate(malformed)]
+        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
+                mock.patch.object(meter, "git_delivery_state", return_value={
+                    "ok": True, "days": days,
+                    "previous": {
+                        "changed_lines": "999", "commits": 1.5,
+                        "availability": {"code_pushed": True},
+                    },
+                }), \
+                mock.patch.object(meter, "_domain_build_builder_recap", return_value={"ok": True}) as build:
+            payload, status = meter.builder_recap_state("30")
+
+        self.assertEqual((payload, status), ({"ok": True}, 200))
+        projected = build.call_args.args[1]
+        self.assertEqual(len(projected), len(malformed))
+        self.assertTrue(all(row["changed_lines"] is None for row in projected))
+        self.assertTrue(all(row["commits"] is None for row in projected))
+        self.assertIsNone(build.call_args.kwargs["previous_git_lines"])
+        self.assertIsNone(build.call_args.kwargs["previous_git_commits"])
+
+    def test_builder_recap_state_marks_git_failures_unavailable(self):
+        meter._xsess["internal_rows"] = [{"id": "private"}]
+        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
+                mock.patch.object(meter, "git_delivery_state", return_value={
+                    "ok": False, "error": "private git failure",
+                }), \
+                mock.patch.object(meter, "_domain_build_builder_recap", return_value={"ok": True}) as build:
+            payload, status = meter.builder_recap_state("7")
+
+        self.assertEqual((payload, status), ({"ok": True}, 200))
+        self.assertIsNone(build.call_args.args[1])
+
+    def test_builder_recap_state_rejects_invalid_ranges_without_discovery(self):
+        for value in ("", "14", "30.0", "seven"):
+            with self.subTest(value=value), \
+                    mock.patch.object(meter, "cross_session") as cross, \
+                    mock.patch.object(meter, "git_delivery_state") as git, \
+                    mock.patch.object(meter, "_domain_build_builder_recap") as build:
+                payload, status = meter.builder_recap_state(value)
+            self.assertEqual(status, 400)
+            self.assertEqual(payload, {
+                "ok": False, "error": "A valid recap range is required.",
+            })
+            cross.assert_not_called()
+            git.assert_not_called()
+            build.assert_not_called()
+
+    def request(self, path):
+        server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            conn = http.client.HTTPConnection("127.0.0.1", server.server_port, timeout=5)
+            conn.request("GET", path)
+            response = conn.getresponse()
+            payload = json.loads(response.read())
+            status = response.status
+            content_type = response.getheader("Content-Type")
+            conn.close()
+            return payload, status, content_type
+        finally:
+            server.shutdown()
+            server.server_close()
+            thread.join(timeout=5)
+
+    def test_builder_recap_http_route_defaults_validates_and_returns_json(self):
+        meter._xsess["internal_rows"] = [{
+            "id": "private-session", "path": "/private/trace.jsonl",
+            "project": "/private/repo", "title": "private title",
+            "last": "2026-09-13T12:00:00", "runtime": "Codex",
+        }]
+        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}) as cross, \
+                mock.patch.object(meter, "git_delivery_state", return_value={"ok": True, "days": []}) as git:
+            valid, valid_status, valid_type = self.request("/builder-recap?range=7")
+            default, default_status, _ = self.request("/builder-recap")
+            invalid, invalid_status, _ = self.request("/builder-recap?range=14")
+            repeated, repeated_status, _ = self.request("/builder-recap?range=7&range=30")
+            cross.reset_mock()
+            git.reset_mock()
+            blanks = [
+                self.request("/builder-recap?range="),
+                self.request("/builder-recap?range=7&range="),
+                self.request("/builder-recap?range=&range=30"),
+            ]
+
+        self.assertEqual((valid_status, valid_type), (200, "application/json"))
+        self.assertEqual(valid["range_days"], 7)
+        self.assertEqual(valid["privacy"], {
+            "content_included": False, "project_identity_included": False,
+        })
+        for sentinel in ("private-session", "/private/trace.jsonl", "/private/repo", "private title"):
+            self.assertNotIn(sentinel, json.dumps(valid, sort_keys=True))
+        self.assertEqual((default_status, default["range_days"]), (200, 30))
+        for payload, status in ((invalid, invalid_status), (repeated, repeated_status)):
+            self.assertEqual(status, 400)
+            self.assertEqual(payload, {
+                "ok": False, "error": "A valid recap range is required.",
+            })
+            self.assertNotIn("private", json.dumps(payload))
+        for payload, status, _ in blanks:
+            self.assertEqual(status, 400)
+            self.assertEqual(payload, {
+                "ok": False, "error": "A valid recap range is required.",
+            })
+        cross.assert_not_called()
+        git.assert_not_called()
+
+        source = Path(meter.IMPLEMENTATION_FILE).read_text()
+        self.assertIn('elif req_path == "/builder-recap":', source)
+        self.assertIn("builder_recap_state(range_values[0])", source)
+        post_source = source[source.index("def do_POST"):source.index("def do_GET")]
+        self.assertNotIn('req_path == "/builder-recap"', post_source)
+
+    def test_builder_recap_http_payload_rejects_unsafe_runtime_model_and_tool_labels(self):
+        sentinels = ("https://private.example", "/private/model", "sk-live-secret",
+                     "api_key=private", "<private-label>")
+        meter._xsess["internal_rows"] = [{
+            "last": "2026-09-13T12:00:00", "runtime": sentinels[0],
+            "_model_daily": [{"day": "2026-09-13", "model": sentinels[1], "executions": 3}],
+            "_performance_samples": [{"day": "2026-09-13", "model": sentinels[2],
+                                      "output_tokens": 1000, "duration_s": 10}],
+            "_tool_evidence": {"tools": [{"name": "read_file", "display": sentinels[3],
+                                              "daily": [{"day": "2026-09-13", "calls": 2}]},
+                                             {"name": "read_file", "display": sentinels[4],
+                                              "daily": [{"day": "2026-09-13", "calls": 2}]}]},
+        }]
+        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
+                mock.patch.object(meter, "git_delivery_state", return_value={"ok": True, "days": []}):
+            payload, status, _ = self.request("/builder-recap?range=7")
+
+        self.assertEqual(status, 200)
+        serialized = json.dumps(payload, sort_keys=True)
+        for sentinel in sentinels:
+            self.assertNotIn(sentinel, serialized)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_builder_recap_page.py b/tests/test_builder_recap_page.py
new file mode 100644
index 00000000..b2886284
--- /dev/null
+++ b/tests/test_builder_recap_page.py
@@ -0,0 +1,868 @@
+import unittest
+import http.client
+import json
+import re
+import shutil
+import subprocess
+import tempfile
+import threading
+from html.parser import HTMLParser
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class BuilderRecapStandalonePageTests(unittest.TestCase):
+    def request(self, method, path):
+        server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            conn = http.client.HTTPConnection(
+                "127.0.0.1", server.server_port, timeout=5,
+            )
+            conn.request(method, path)
+            response = conn.getresponse()
+            body = response.read()
+            result = {
+                "status": response.status,
+                "type": response.getheader("Content-Type"),
+                "length": response.getheader("Content-Length"),
+                "cache": response.getheader("Cache-Control"),
+                "body": body,
+            }
+            conn.close()
+            return result
+        finally:
+            server.shutdown()
+            server.server_close()
+            thread.join(timeout=5)
+
+    def test_performance_document_routes_and_manifest(self):
+        manifest = Path(meter.__file__).with_name("runtime-manifest.txt").read_text()
+        self.assertIn("required performance.html", manifest.splitlines())
+
+        with tempfile.TemporaryDirectory() as tmp:
+            page = Path(tmp) / "performance.html"
+            page.write_text("<!doctype html><title>Builder recap</title>")
+            with mock.patch.object(
+                    meter, "performance_page_path", return_value=str(page),
+                    create=True):
+                direct = self.request("GET", "/performance")
+                alias = self.request("GET", "/performance.html")
+                head = self.request("HEAD", "/performance")
+
+            for response in (direct, alias):
+                self.assertEqual(response["status"], 200)
+                self.assertEqual(response["type"], "text/html; charset=utf-8")
+                self.assertEqual(response["cache"], "no-store, max-age=0")
+                self.assertEqual(response["body"], page.read_bytes())
+            self.assertEqual(head["status"], 200)
+            self.assertEqual(head["body"], b"")
+            self.assertEqual(head["length"], str(page.stat().st_size))
+            self.assertEqual(head["cache"], "no-store, max-age=0")
+
+            with mock.patch.object(
+                    meter, "performance_page_path", return_value=None,
+                    create=True):
+                missing = self.request("GET", "/performance")
+            self.assertEqual(missing["status"], 503)
+            self.assertIn(b"performance.html is missing", missing["body"])
+            self.assertNotIn(str(tmp).encode(), missing["body"])
+
+    def test_standalone_page_declares_inline_svg_favicon(self):
+        class IconInventory(HTMLParser):
+            def __init__(self):
+                super().__init__()
+                self.icons = []
+
+            def handle_starttag(self, tag, attrs):
+                attributes = dict(attrs)
+                if tag == "link" and "icon" in attributes.get("rel", "").split():
+                    self.icons.append(attributes)
+
+        page = Path(meter.__file__).with_name("performance.html").read_text()
+        markup = IconInventory()
+        markup.feed(page)
+
+        self.assertEqual(len(markup.icons), 1)
+        self.assertEqual(markup.icons[0]["type"], "image/svg+xml")
+        self.assertTrue(markup.icons[0]["href"].startswith("data:image/svg+xml,"))
+
+    def test_standalone_studio_has_the_approved_controls_and_no_remote_assets(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        self.assertTrue(page_path.is_file())
+        page = page_path.read_text()
+        for marker in (
+            'href="/#subagents"', 'href="/#efficiency"', 'id=range-controls', 'data-range=7',
+            'data-range=30', 'data-range=90',
+            '<span>Name</span><input id=builder-name maxlength=40',
+            'id=include-usage type=checkbox', 'id=reset type=button',
+            'id=retry type=button hidden',
+            'id=download type=button disabled>Download PNG</button>',
+            'id=poster width=1080 height=1350 role=img',
+            'id=status role=status aria-live=polite',
+            'function drawBuilderRecap(', 'function loadRecap(',
+            '/builder-recap?range=', 'github.com/splunk/token-meter',
+            '@media(max-width:1024px)',
+        ):
+            self.assertIn(marker, page)
+        self.assertEqual(page.count("function drawBuilderRecap("), 1)
+        self.assertNotRegex(page, r'<(?:script|img|link)[^>]+(?:src|href)=["\']https?://')
+        self.assertNotIn("foreignObject", page)
+        # Only the shared theme boot script may read storage; the studio never persists builder input.
+        self.assertNotIn("localStorage", re.sub(r"<script id=theme-boot>.*?</script>", "", page, flags=re.S))
+        self.assertNotIn("Display name", page)
+        self.assertNotIn("id=spotlight", page)
+        self.assertNotIn("id=include-git", page)
+
+    def test_standalone_studio_uses_the_spectrum_shell_and_compact_editor(self):
+        class MarkupInventory(HTMLParser):
+            def __init__(self):
+                super().__init__()
+                self.body_classes = set()
+                self.by_id = {}
+
+            def handle_starttag(self, tag, attrs):
+                attributes = dict(attrs)
+                if tag == "body":
+                    self.body_classes.update(attributes.get("class", "").split())
+                if attributes.get("id"):
+                    self.by_id[attributes["id"]] = (tag, attributes)
+
+        page = Path(meter.__file__).with_name("performance.html").read_text()
+        markup = MarkupInventory()
+        markup.feed(page)
+
+        self.assertTrue({"spectrumApp", "performanceApp"}.issubset(markup.body_classes))
+        self.assertEqual(markup.by_id["performance-rail"][0], "aside")
+        self.assertEqual(
+            markup.by_id["performance-rail"][1]["aria-label"],
+            "Token Meter navigation",
+        )
+        self.assertEqual(markup.by_id["performance-navigation"][0], "nav")
+        performance = markup.by_id["tab-performance"]
+        self.assertEqual(performance[0], "a")
+        self.assertEqual(performance[1]["href"], "/performance")
+        self.assertEqual(performance[1]["aria-current"], "page")
+        self.assertEqual(markup.by_id["performance-surface"][0], "main")
+        self.assertEqual(markup.by_id["performance-header"][0], "header")
+        self.assertIn("<title>Token Meter — Performance card</title>", page)
+        self.assertIn("<h1>Performance card</h1>", page)
+        self.assertIn("<span class=railLabel>Performance</span>", page)
+        self.assertNotIn("headerMeta", page)
+        self.assertNotIn("<strong>4:5</strong>", page)
+        self.assertEqual(markup.by_id["performance-controls"][0], "section")
+        self.assertEqual(
+            markup.by_id["performance-controls"][1]["aria-label"],
+            "Performance controls",
+        )
+        self.assertEqual(markup.by_id["performance-preview"][0], "section")
+        logo = markup.by_id["performance-card-logo"]
+        self.assertEqual(logo[0], "img")
+        self.assertEqual(
+            logo[1]["src"], "/assets/brand/logo-splunk-by-cisco-rgb-w.png",
+        )
+        self.assertIn("hidden", logo[1])
+        self.assertIn("<div class=studioWorkspace>", page)
+        workspace_start = page.index("<div class=studioWorkspace>")
+        controls_start = page.index(
+            "<section class=controlDock id=performance-controls",
+        )
+        preview_start = page.index(
+            "<section class=stage id=performance-preview",
+        )
+        self.assertLess(workspace_start, controls_start)
+        self.assertLess(controls_start, preview_start)
+        self.assertIn(
+            ".studioWorkspace{display:grid;grid-template-columns:220px minmax(0,1fr)",
+            page,
+        )
+        self.assertNotIn("evidence-note", markup.by_id)
+        self.assertEqual(markup.by_id["status"][1]["role"], "status")
+        primary = page.split("<div class=railPrimary>", 1)[1].split("</div>", 1)[0]
+        self.assertLess(primary.index('href="/#models"'), primary.index('href="/#subagents"'))
+        self.assertLess(primary.index('href="/#subagents"'), primary.index('href="/#efficiency"'))
+        self.assertLess(primary.index('href="/#efficiency"'), primary.index('href="/#work"'))
+        self.assertLess(primary.index('href="/#work"'), primary.index('href="/#git"'))
+        self.assertLess(primary.index('href="/#git"'), primary.index("id=tab-performance"))
+        # Work appears only where the dashboard shows it.
+        self.assertIn('id=rail-work href="/#work" aria-label=Work title=Work hidden>', primary)
+        self.assertIn("$('rail-work').hidden=payload?.settings?.supported!==true;", page)
+        self.assertNotIn("Make it yours.", page)
+        self.assertNotIn("Builder Recap Studio", page)
+
+    def assert_measured_grid(self, cells):
+        """Equal columns span 72-1008 exactly and share every text baseline."""
+        self.assertTrue(cells)
+        self.assertEqual(cells[0]["x"], 72)
+        self.assertEqual(cells[-1]["x"] + cells[-1]["width"], 1008)
+        self.assertLessEqual(max(c["width"] for c in cells) - min(c["width"] for c in cells), 1)
+        gaps = [b["x"] - (a["x"] + a["width"]) for a, b in zip(cells, cells[1:])]
+        if gaps:
+            self.assertLessEqual(max(gaps) - min(gaps), 1)
+        for key in ("valueY", "labelY", "subY", "size"):
+            self.assertEqual(len({cell[key] for cell in cells}), 1, key)
+        for cell in cells:
+            self.assertIsNotNone(cell["value"], cell)
+            self.assertIsNotNone(cell["label"], cell)
+            self.assertIn(f"{cell['size']}px", cell["font"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for canvas verification")
+    def test_standalone_canvas_formats_and_aligns_metric_values(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap'])eval(extract(name));
+class Gradient{{constructor(kind,coords){{this.kind=kind;this.coords=coords;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
+class Context{{constructor(){{this.ops=[];this.font='';}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}drawImage(image,...v){{this.ops.push(['image',image.src,...v]);}}createLinearGradient(...c){{return new Gradient('linear',c);}}createRadialGradient(...c){{return new Gradient('radial',c);}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}arc(){{}}stroke(){{}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}}}
+class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
+const payload={{range_days:30,current:{{end_day:'2026-09-13'}},spotlights:[
+ {{id:'lines_pushed',available:true,current:184392,unit:'lines'}},
+ {{id:'efficiency_change',label:'Output efficiency',available:true,current:2680,unit:'output tokens/$'}},
+ {{id:'speed_champion',label:'Fastest model',available:true,current:42.8,unit:'output tokens/s',leaders:[{{model:'gpt-5.3'}}]}},
+ {{id:'marathon_session',label:'Longest session',available:true,current:24120,unit:'seconds'}},
+ {{id:'build_streak',available:true,current:14,unit:'days'}}
+],supporting:[{{id:'sessions',label:'AI coding sessions',available:true,current:126,unit:'sessions'}},{{id:'covered_spend',label:'Covered equivalent spend',family:'cost',available:true,current:2176.88,previous:null,delta_pct:null,unit:'USD'}}],activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<24}})),usage:{{agents:[],models:[]}}}};
+const canvas=new Canvas();
+function cellsOf(target,result){{return result.layout.stats.map(cell=>{{const at=(y)=>target.ctx.ops.find(op=>op[0]==='text'&&op[2]===cell.x&&op[3]===y);const value=at(cell.valueY),label=at(cell.labelY),sub=at(cell.subY);return {{id:cell.id,x:cell.x,width:cell.width,valueY:cell.valueY,labelY:cell.labelY,subY:cell.subY,size:cell.size,value:value&&value[1],font:value&&value[4],label:label&&label[1],sub:sub?sub[1]:''}};}});}}
+const mainResult=drawBuilderRecap(canvas,payload,{{name:'Ada Builder',includeUsage:true,logo:{{src:'/assets/brand/logo-splunk-by-cisco-rgb-w.png',complete:true,naturalWidth:1024}}}});
+const textOps=canvas.ctx.ops.filter(op=>op[0]==='text');
+const missingPayload=JSON.parse(JSON.stringify(payload));missingPayload.supporting=[];const missingCanvas=new Canvas(),missingResult=drawBuilderRecap(missingCanvas,missingPayload,{{name:'',includeUsage:true}});
+const unavailableSpeedPayload=JSON.parse(JSON.stringify(payload));unavailableSpeedPayload.spotlights.find(stat=>stat.id==='speed_champion').available=false;const unavailableSpeedCanvas=new Canvas(),unavailableSpeedResult=drawBuilderRecap(unavailableSpeedCanvas,unavailableSpeedPayload,{{name:'',includeUsage:true}});
+const pickedCanvas=new Canvas(),pickedResult=drawBuilderRecap(pickedCanvas,payload,{{name:'',includeUsage:true,stats:['marathon_session','tool_calls','active_days']}});
+const sixCanvas=new Canvas(),sixResult=drawBuilderRecap(sixCanvas,payload,{{name:'',includeUsage:true,stats:['active_days','efficiency_change','speed_champion','sessions','covered_spend','marathon_session']}});
+const longPayload=JSON.parse(JSON.stringify(payload));longPayload.supporting.find(stat=>stat.id==='sessions').current=1.2345678901234567e20;const longCanvas=new Canvas(),longResult=drawBuilderRecap(longCanvas,longPayload,{{name:'',includeUsage:true}});
+class InkContext extends Context{{measureText(v){{return {{...super.measureText(v),actualBoundingBoxLeft:-6,actualBoundingBoxRight:-3}};}}}}
+const inkCanvas=new Canvas();inkCanvas.ctx=new InkContext();drawBuilderRecap(inkCanvas,payload,{{name:'',includeUsage:true}});const inkOps=inkCanvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===486).map(op=>[op[1],op[2]]);
+console.log(JSON.stringify({{texts:textOps.map(op=>op[1]),logos:canvas.ctx.ops.filter(op=>op[0]==='image'),cells:cellsOf(canvas,mainResult),missingCells:cellsOf(missingCanvas,missingResult),unavailableSpeedCells:cellsOf(unavailableSpeedCanvas,unavailableSpeedResult),pickedCells:cellsOf(pickedCanvas,pickedResult),pickedTexts:pickedCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),sixCells:cellsOf(sixCanvas,sixResult),longCells:cellsOf(longCanvas,longResult),inkOps,ghost:textOps.filter(op=>String(op[4]).includes('330px')),aria:canvas.attrs['aria-label'],missingAria:missingCanvas.attrs['aria-label'],missingTexts:missingCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),commitOp:textOps.find(op=>op[2]===1008&&op[3]===486)}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        cells = rendered["cells"]
+        self.assertEqual(
+            [(cell["label"], cell["value"]) for cell in cells],
+            [("ACTIVE DAYS", "24/30"), ("OUTPUT EFFICIENCY", "2.68 K/$"),
+             ("FASTEST MODEL", "42.8 TOK/S"), ("AI SESSIONS", "126"),
+             ("EQUIV. SPEND", "$2.18K")],
+        )
+        self.assert_measured_grid(cells)
+        self.assertEqual([cell["sub"] for cell in cells],
+                         ["14 DAY STREAK", "", "GPT-5.3", "", "ESTIMATE"])
+        self.assertIn("30D", rendered["texts"])
+        self.assertEqual(rendered["ghost"], [])
+        visible = " ".join(rendered["texts"])
+        self.assertNotIn("LONGEST SESSION", visible)
+        self.assertNotIn("6H 42M", visible)
+        self.assertEqual(rendered["texts"].count("LINES PUSHED"), 1)
+        self.assertNotIn("LINES", rendered["texts"])
+        self.assertEqual(rendered["logos"], [[
+            "image", "/assets/brand/logo-splunk-by-cisco-rgb-w.png",
+            72, 46, 148, 54,
+        ]])
+        self.assertIn("TOKEN METER", rendered["texts"])
+        self.assertIn("PERFORMANCE CARD", rendered["texts"])
+        self.assertNotIn("TOKEN METER / PERFORMANCE", rendered["texts"])
+        self.assertNotIn("2.68K", rendered["texts"])
+        self.assertNotIn("Longest session", rendered["aria"])
+        self.assertIn("AI sessions 126.", rendered["aria"])
+        self.assertIn(
+            "Covered equivalent spend $2.18K, an estimate.", rendered["aria"],
+        )
+        self.assertIn("AI sessions unavailable.", rendered["missingAria"])
+        self.assertIn(
+            "Covered equivalent spend unavailable.", rendered["missingAria"],
+        )
+        # Unavailable evidence is omitted, not drawn as a zero or a dash, and the
+        # remaining columns redistribute across the full content measure.
+        self.assertEqual([cell["id"] for cell in rendered["missingCells"]],
+                         ["active_days", "efficiency_change", "speed_champion"])
+        self.assert_measured_grid(rendered["missingCells"])
+        self.assertNotIn("—", [cell["value"] for cell in rendered["missingCells"]])
+        self.assertNotIn("EQUIV. SPEND", rendered["missingTexts"])
+        self.assertEqual([cell["id"] for cell in rendered["unavailableSpeedCells"]],
+                         ["active_days", "efficiency_change", "sessions", "covered_spend"])
+        self.assert_measured_grid(rendered["unavailableSpeedCells"])
+        # Toggles pick cells in catalog order; unavailable picks drop out.
+        self.assertEqual([(cell["label"], cell["value"]) for cell in rendered["pickedCells"]],
+                         [("ACTIVE DAYS", "24/30"), ("LONGEST SESSION", "6H 42M")])
+        self.assert_measured_grid(rendered["pickedCells"])
+        self.assertNotIn("OUTPUT EFFICIENCY", rendered["pickedTexts"])
+        self.assertEqual(len(rendered["sixCells"]), 5)
+        self.assertNotIn("marathon_session", [cell["id"] for cell in rendered["sixCells"]])
+        # A value that cannot fit steps the whole row down to the floor before
+        # it ellipsizes; it never overflows its column.
+        long_cells = rendered["longCells"]
+        self.assertEqual({cell["size"] for cell in long_cells}, {24})
+        self.assertTrue(long_cells[3]["value"].endswith("…"))
+        self.assertEqual(long_cells[0]["value"], "24/30")
+        # Display numerals align by measured ink, not by their advance box.
+        self.assertEqual(rendered["inkOps"], [["184,392", 66], ["—", 1011]])
+        # Absent commit evidence must read as unavailable, never a measured zero.
+        self.assertEqual(rendered["commitOp"][1:4], ["—", 1008, 486])
+        self.assertIn("Commits pushed unavailable.", rendered["aria"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for headline verification")
+    def test_standalone_headline_band_rhythm_and_controls(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        names = ['safeArray', 'sanitizeBuilderName', 'compactNumber', 'durationLabel', 'formatStat',
+                 'formatSpend', 'ellipsize', 'fitText', 'gradientFill', 'radialFill', 'fillRoundedRect',
+                 'setTracking', 'cardPalette', 'ditherRegion', 'supportingStats', 'inkX', 'posterStatLimit',
+                 'defaultPosterStats', 'posterStatCatalog', 'findRecapStat', 'posterStatCells',
+                 'resolveHeadline', 'paperLayout', 'headlineBandHeight', 'statRowHeight',
+                 'usageBlockHeight', 'drawHeadlineBand', 'drawStatRow', 'drawUsageGroup',
+                 'drawBuilderRecap', 'renderControls', 'resetRecap']
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+for(const name of {json.dumps(names)})eval(extract(name));
+class Gradient{{constructor(kind){{this.kind=kind;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
+class Context{{constructor(){{this.ops=[];this.font='';}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}drawImage(){{}}createLinearGradient(){{return new Gradient('linear');}}createRadialGradient(){{return new Gradient('radial');}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}roundRect(...v){{this.ops.push(['round',...v]);}}fill(){{}}}}
+class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
+const payload={{range_days:30,current:{{end_day:'2026-09-13'}},spotlights:[{{id:'lines_pushed',available:true,current:184392,unit:'lines'}},{{id:'efficiency_change',available:true,current:2680,unit:'output tokens/$'}},{{id:'speed_champion',available:true,current:42.8,unit:'output tokens/s',leaders:[{{model:'gpt-5.3'}}]}},{{id:'build_streak',available:true,current:14,unit:'days'}}],supporting:[{{id:'sessions',available:true,current:126,unit:'sessions'}},{{id:'covered_spend',available:true,current:2176.88,unit:'USD'}}],
+ headlines:[{{id:'identity',title:'A Claude person',value:'92%',detail:'of sessions on Claude Code'}},{{id:'streak',title:'Longest streak',value:'14 days',detail:'consecutive active days'}}],
+ activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<24}})),usage:{{agents:[{{label:'Claude Code',share:92}},{{label:'Codex',share:8}}],models:[{{label:'sonnet-4.5',runtime:'Claude Code',share:70}},{{label:'opus-4.1',runtime:'Claude Code',share:20}},{{label:'gpt-5.3',runtime:'Codex',share:10}}]}}}};
+function draw(options){{const canvas=new Canvas(),result=drawBuilderRecap(canvas,payload,options);return {{result,texts:canvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),aria:canvas.attrs['aria-label'],ops:canvas.ctx.ops}};}}
+const auto=draw({{name:'',includeUsage:true}}),streak=draw({{name:'',includeUsage:true,headline:'streak'}}),none=draw({{name:'',includeUsage:true,headline:'none'}}),stale=draw({{name:'',includeUsage:true,headline:'best_week'}}),bare=draw({{name:'',includeUsage:false,headline:'none'}});
+const band=auto.result.layout.headline,bandRect=auto.ops.find(op=>op[0]==='round'&&op[1]===72&&op[3]===936);
+class Control{{constructor(stat){{this.disabled=false;this.checked=false;this.value='';this.textContent='';this.children=[];this.dataset=stat?{{stat}}:{{}};}}appendChild(child){{this.children.push(child);}}}}
+const statInputs=posterStatCatalog().map(entry=>new Control(entry.id)),controls={{'builder-name':new Control(),'include-usage':new Control(),'headline-select':new Control()}},$=id=>controls[id];
+const document={{querySelectorAll:selector=>selector==='[data-stat]'?statInputs:[],createElement:()=>new Control()}};
+const builderRecapState={{range:30,name:'',includeUsage:true,headline:'streak',stats:defaultPosterStats(),payload}};
+renderControls(payload);
+const select=controls['headline-select'],controlState={{options:select.children.map(option=>[option.value,option.textContent]),value:select.value,stats:statInputs.map(input=>[input.dataset.stat,input.checked,input.disabled])}};
+builderRecapState.headline='gone';renderControls(payload);const staleValue=select.value;
+builderRecapState.stats=['active_days'];builderRecapState.headline='none';let loads=0;function loadRecap(){{loads++;}}resetRecap();
+console.log(JSON.stringify({{auto:{{texts:auto.texts,aria:auto.aria,layout:auto.result.layout}},band,bandRect,streakTexts:streak.texts,noneLayout:none.result.layout,noneTexts:none.texts,staleTexts:stale.texts,bareLayout:bare.result.layout,controlState,staleValue,reset:{{headline:builderRecapState.headline,stats:builderRecapState.stats,loads}}}}));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=False)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        # Auto picks the first (highest-priority) candidate and draws it as a band.
+        for text in ("92%", "A CLAUDE PERSON", "OF SESSIONS ON CLAUDE CODE"):
+            self.assertIn(text, rendered["auto"]["texts"])
+        self.assertIn("Headline A Claude person: 92% of sessions on Claude Code.", rendered["auto"]["aria"])
+        band = rendered["band"]
+        self.assertEqual((band["left"], band["width"]), (72, 936))
+        self.assertEqual(rendered["bandRect"][1:5], [72, band["top"], 936, 96])
+        self.assertEqual(band["valueY"], band["detailY"])
+        self.assertLess(band["titleY"], band["valueY"])
+        self.assertGreater(band["textEdge"], band["valueEdge"])
+        # One spacing-scale gap separates every paper block, and the stack is
+        # centered with equal padding no smaller than that gap.
+        layout = rendered["auto"]["layout"]
+        blocks = layout["blocks"]
+        self.assertIn(layout["gap"], (16, 24, 32, 40, 48))
+        order = ["headline", "stats", "rule", "usage"]
+        self.assertEqual(sorted(blocks), sorted(order))
+        for upper, lower in zip(order, order[1:]):
+            self.assertEqual(
+                blocks[lower]["top"] - (blocks[upper]["top"] + blocks[upper]["height"]),
+                layout["gap"], (upper, lower))
+        top_pad = blocks["headline"]["top"] - 720
+        bottom_pad = 1220 - (blocks["usage"]["top"] + blocks["usage"]["height"])
+        self.assertLessEqual(abs(top_pad - bottom_pad), 1)
+        self.assertGreaterEqual(min(top_pad, bottom_pad), layout["gap"])
+        self.assertLess(band["top"], layout["stats"][0]["valueY"])
+        # Explicit choice, None, and a stale choice that is no longer available.
+        self.assertIn("14 days", rendered["streakTexts"])
+        self.assertNotIn("A CLAUDE PERSON", rendered["streakTexts"])
+        self.assertIsNone(rendered["noneLayout"]["headline"])
+        self.assertNotIn("headline", rendered["noneLayout"]["blocks"])
+        self.assertNotIn("A CLAUDE PERSON", rendered["noneTexts"])
+        self.assertIn("A CLAUDE PERSON", rendered["staleTexts"])
+        self.assertEqual(sorted(rendered["bareLayout"]["blocks"]), ["stats"])
+        # Controls: Auto, each candidate, None; stat toggles cap at five.
+        self.assertEqual(rendered["controlState"]["options"], [
+            ["auto", "Auto"], ["identity", "A Claude person · 92%"],
+            ["streak", "Longest streak · 14 days"], ["none", "None"],
+        ])
+        self.assertEqual(rendered["controlState"]["value"], "streak")
+        self.assertEqual(rendered["staleValue"], "auto")
+        stats = {stat_id: (checked, disabled) for stat_id, checked, disabled in rendered["controlState"]["stats"]}
+        for stat_id in ("active_days", "efficiency_change", "speed_champion", "sessions", "covered_spend"):
+            self.assertEqual(stats[stat_id], (True, False), stat_id)
+        # Five shown: no sixth choice; stats without evidence cannot be picked.
+        for stat_id in ("marathon_session", "output_pace", "tool_calls", "models"):
+            self.assertEqual(stats[stat_id], (False, True), stat_id)
+        self.assertEqual(rendered["reset"], {
+            "headline": "auto",
+            "stats": ["active_days", "efficiency_change", "speed_champion", "sessions", "covered_spend"],
+            "loads": 1,
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for headline verification")
+    def test_standalone_auto_headline_skips_facts_the_poster_already_shows(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}}}
+eval(extract('safeArray'));eval(extract('resolveHeadline'));
+const payload={{headlines:[{{id:'identity',title:'A Claude person',value:'92%'}},{{id:'streak',title:'Longest streak',value:'14 days'}},{{id:'cache_share',title:'Cache-powered',value:'87%'}}]}};
+const pick=(choice,shown)=>(resolveHeadline(payload,choice,shown)||{{}}).id||null;
+console.log(JSON.stringify({{
+ fresh:pick('auto',[]),
+ skipOne:pick('auto',['identity']),
+ skipTwo:pick('auto',['identity','streak']),
+ allShown:pick('auto',['identity','streak','cache_share']),
+ explicit:pick('identity',['identity']),
+ none:pick('none',[])
+}}));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=False)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), {
+            "fresh": "identity", "skipOne": "streak", "skipTwo": "cache_share",
+            "allShown": "identity", "explicit": "identity", "none": None,
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for texture verification")
+    def test_standalone_texture_helpers_dither_gradients_and_degrade_safely(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+for(const name of ['gradientFill','radialFill','fillRoundedRect','ditherRegion'])eval(extract(name));
+const put=[];
+const readable={{
+ getImageData(x,y,width,height){{const data=new Uint8ClampedArray(width*height*4);for(let i=0;i<data.length;i+=4){{data[i]=data[i+1]=data[i+2]=40;data[i+3]=255;}}return {{width,height,data}};}},
+ putImageData(image,x,y){{put.push([x,y,Array.from(image.data)]);}},
+}};
+const dithered=ditherRegion(readable,12,34,16,16,4);
+const channels=put[0][2].filter((_,index)=>index%4!==3),alphas=[...new Set(put[0][2].filter((_,index)=>index%4===3))];
+const missing=ditherRegion({{}},0,0,4,4,4);
+const tainted=ditherRegion({{getImageData(){{throw new Error('tainted');}},putImageData(){{}}}},0,0,4,4,4);
+const roundedOps=[],rounded={{roundRect(...v){{roundedOps.push(['roundRect',...v]);}},beginPath(){{roundedOps.push(['beginPath']);}},fill(){{roundedOps.push(['fill']);}},fillRect(...v){{roundedOps.push(['fillRect',...v]);}}}};
+const usedRound=fillRoundedRect(rounded,10,20,200,12,6);
+const plainOps=[],plain={{fillRect(...v){{plainOps.push(['fillRect',...v]);}}}};
+const usedPlain=fillRoundedRect(plain,10,20,200,12,6);
+console.log(JSON.stringify({{
+ dithered,target:[put[0][0],put[0][1]],levels:[...new Set(channels)].sort((a,b)=>a-b),alphas,
+ missing,tainted,usedRound,roundedOps,usedPlain,plainOps,
+ gradientFallback:gradientFill({{}},0,0,1,1,[[0,'#111111'],[1,'#222222']]),
+ radialFallback:radialFill({{}},0,0,10,[[0,'#333333'],[1,'#444444']]),
+}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertTrue(rendered["dithered"])
+        self.assertEqual(rendered["target"], [12, 34])
+        self.assertEqual(rendered["levels"], [0, 85])
+        self.assertEqual(rendered["alphas"], [255])
+        self.assertFalse(rendered["missing"])
+        self.assertFalse(rendered["tainted"])
+        self.assertTrue(rendered["usedRound"])
+        self.assertEqual(rendered["roundedOps"], [
+            ["beginPath"], ["roundRect", 10, 20, 200, 12, 6], ["fill"],
+        ])
+        self.assertFalse(rendered["usedPlain"])
+        self.assertEqual(rendered["plainOps"], [["fillRect", 10, 20, 200, 12]])
+        self.assertEqual(rendered["gradientFallback"], "#222222")
+        self.assertEqual(rendered["radialFallback"], "#444444")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dither wiring verification")
+    def test_standalone_canvas_dithers_each_band_before_drawing_any_text(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap'])eval(extract(name));
+const stops={{addColorStop(){{}}}};
+class Context{{
+ constructor(){{this.ops=[];this.font='';this.bands=[];}}
+ fillRect(...v){{this.ops.push(['rect',...v]);}}
+ fillText(v){{this.ops.push(['text',String(v)]);}}
+ drawImage(){{this.ops.push(['image']);}}
+ createLinearGradient(){{return stops;}}
+ createRadialGradient(){{return stops;}}
+ getImageData(x,y,width,height){{const data=new Uint8ClampedArray(width*height*4);data.fill(100);return {{width,height,data}};}}
+ putImageData(image,x,y){{this.ops.push(['dither',x,y,image.width,image.height]);this.bands.push([x,y,image.width,image.height,[...new Set(image.data.filter((_,i)=>i%4!==3))].sort((a,b)=>a-b)]);}}
+ measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}
+ beginPath(){{}}arc(){{}}stroke(){{}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}
+}}
+class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
+const payload={{range_days:30,current:{{end_day:'2026-09-13'}},spotlights:[{{id:'lines_pushed',available:true,current:39425,unit:'lines'}}],supporting:[],activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<26}})),usage:{{agents:[{{label:'Codex',share:71}}],models:[{{label:'gpt-5.6',runtime:'Codex',share:69}}]}}}};
+const canvas=new Canvas();drawBuilderRecap(canvas,payload,{{name:'Ada',includeUsage:true}});
+const kinds=canvas.ctx.ops.map(op=>op[0]);
+console.log(JSON.stringify({{
+ bands:canvas.ctx.bands,
+ lastDither:kinds.lastIndexOf('dither'),
+ firstText:kinds.indexOf('text'),
+}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertEqual(
+            [band[:4] for band in rendered["bands"]],
+            [[0, 0, 1080, 720], [0, 720, 1080, 500], [0, 1220, 1080, 130]],
+        )
+        # Distinct output values pin each band's quantization step, so changing a
+        # band's `levels` cannot pass silently.
+        self.assertEqual(
+            [band[4] for band in rendered["bands"]],
+            [[98, 118], [85, 102], [98, 118]],
+        )
+        self.assertGreater(rendered["firstText"], -1)
+        self.assertLess(rendered["lastDither"], rendered["firstText"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for rhythm verification")
+    def test_standalone_canvas_groups_long_ranges_into_active_rhythm_bars(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap'])eval(extract(name));
+class Gradient{{constructor(kind){{this.kind=kind;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
+class Context{{constructor(){{this.ops=[];this.font='';}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}drawImage(){{}}createLinearGradient(){{return new Gradient('linear');}}createRadialGradient(){{return new Gradient('radial');}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}arc(){{}}stroke(){{}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}}}
+class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
+const payload={{range_days:90,current:{{end_day:'2026-09-13'}},spotlights:[{{id:'lines_pushed',available:true,current:140514,unit:'lines'}}],supporting:[],activity_days:Array.from({{length:90}},(_,i)=>({{recorded_session:i<76}})),usage:{{agents:[],models:[]}}}};
+const canvas=new Canvas();drawBuilderRecap(canvas,payload,{{name:'',includeUsage:true}});
+const rhythmBars=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[2]>=72&&op[2]<1008&&op[3]+op[5]===694);
+console.log(JSON.stringify({{
+ total:rhythmBars.length,
+ active:rhythmBars.filter(op=>op[1]&&op[1].kind==='linear').length,
+ inactive:rhythmBars.filter(op=>op[1]==='rgba(159,180,189,.3)').map(op=>op[5]),
+ texts:canvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),
+ aria:canvas.attrs['aria-label'],
+}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["total"], 30)
+        self.assertEqual(rendered["active"], 26)
+        self.assertEqual(rendered["inactive"], [8, 8, 8, 8])
+        self.assertIn("76/90", rendered["texts"])
+        self.assertIn("LAST 90 DAYS", rendered["texts"])
+        # Bucketed bars must disclose their grouping instead of implying one day each.
+        self.assertIn("Rhythm chart groups 3 days per bar.", rendered["aria"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for canvas verification")
+    def test_standalone_canvas_is_a_linkedin_scale_builder_signal(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);if(page.slice(start-6,start)==='async ')start-=6;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+	for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap','hasActivity'])eval(extract(name));
+class Gradient{{constructor(kind,coords){{this.kind=kind;this.coords=coords;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
+class Context{{constructor(){{this.ops=[];this.font='';this.lineWidth=1;}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}createLinearGradient(...c){{return new Gradient('linear',c);}}createRadialGradient(...c){{return new Gradient('radial',c);}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}arc(...v){{this.ops.push(['arc',this.strokeStyle,...v]);}}stroke(){{this.ops.push(['stroke',this.strokeStyle,this.lineWidth]);}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}}}
+class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};this.width=1;this.height=1;}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
+	const payload={{ok:true,private_sentinel:'prompt://must-not-draw',range_days:30,current:{{start_day:'2026-08-15',end_day:'2026-09-13'}},spotlight_default:'efficiency_change',spotlights:[{{id:'efficiency_change',label:'Output efficiency',family:'efficiency',available:true,current:2680,previous:1942,delta_pct:38,unit:'output tokens/$',basis:'paired cost-covered output and cost'}},{{id:'speed_champion',label:'Fastest model',family:'efficiency',available:true,current:42.8,previous:null,delta_pct:null,unit:'output tokens/s',basis:'weighted measured generation samples',leaders:[{{runtime:'Codex',model:'gpt-5.3'}}]}},{{id:'lines_pushed',label:'Lines pushed',family:'delivery',available:true,current:184392,previous:120000,delta_pct:53.66,unit:'lines',basis:'added plus deleted text lines from successful local pushes'}},{{id:'commits_pushed',label:'Commits pushed',family:'delivery',available:true,current:1284,previous:940,delta_pct:36.6,unit:'commits',basis:'own non-merge commits introduced by successful local pushes'}},{{id:'marathon_session',label:'Longest session',family:'activity',available:true,current:24120,previous:18000,delta_pct:34,unit:'seconds',basis:'active execution duration'}},{{id:'build_streak',label:'Build streak',family:'consistency',available:true,current:14,previous:8,delta_pct:75,unit:'days',basis:'consecutive local days'}}],supporting:[{{id:'active_days',label:'Active days',family:'consistency',available:true,current:24,previous:20,delta_pct:20,unit:'days'}},{{id:'sessions',label:'AI coding sessions',family:'activity',available:true,current:126,previous:91,delta_pct:38.5,unit:'sessions'}},{{id:'delivery_active_days',label:'Delivery-active days',family:'delivery',available:true,current:12,previous:8,delta_pct:50,unit:'days'}},{{id:'output_pace',label:'Output pace',family:'efficiency',available:true,current:31.4,previous:28,delta_pct:12,unit:'output tokens/s'}}],activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<24}})),usage:{{agents:[{{label:'Codex',count:68,share:54}},{{label:'Claude',count:39,share:31}},{{label:'Cursor',count:19,share:15}}],models:[{{label:'gpt-5.3',runtime:'Codex',count:74,share:49}},{{label:'sonnet-4.5',runtime:'Claude',count:48,share:32}},{{label:'gpt-5.2',runtime:'Codex',count:29,share:19}}]}},coverage:{{git:{{available:true}},cost:{{available:true,eligible:22,total:30}},output:{{available:true,eligible:22,total:30}},timing:{{available:true,eligible:14,total:18}}}},privacy:{{content_included:false,project_identity_included:false}}}};
+		const canvas=new Canvas(),result=drawBuilderRecap(canvas,payload,{{name:' Ada\\n Builder ',includeUsage:true}}),texts=canvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),arcs=canvas.ctx.ops.filter(op=>op[0]==='arc'),bars=canvas.ctx.ops.filter(op=>op[0]==='rect'&&(op[5]===12||op[5]===6)),rhythmBars=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[2]>=72&&op[2]<1008&&op[3]+op[5]===694),heroFields=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[1]&&op[1].kind==='linear'&&op[2]===0&&op[3]===0&&op[4]===1080&&op[5]>=700),lowerFields=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[1]&&op[1].kind==='linear'&&op[2]===0&&op[3]>=700&&op[4]===1080&&op[5]>=450),nameOp=canvas.ctx.ops.find(op=>op[0]==='text'&&op[1]==='ADA BUILDER'),heroOp=canvas.ctx.ops.find(op=>op[0]==='text'&&op[3]===486),efficiencyLabelOp=canvas.ctx.ops.find(op=>op[0]==='text'&&op[1]==='OUTPUT EFFICIENCY'&&op[3]===result.layout.stats[0].labelY),metricLabelOps=canvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===result.layout.stats[0].labelY),ghostPeriodOps=canvas.ctx.ops.filter(op=>op[0]==='text'&&String(op[4]).includes('330px'));
+		const negativePayload=JSON.parse(JSON.stringify(payload));negativePayload.spotlights.find(stat=>stat.id==='lines_pushed').delta_pct=-25;const negativeCanvas=new Canvas();drawBuilderRecap(negativeCanvas,negativePayload,{{name:'',includeUsage:true}});
+		const unavailablePayload=JSON.parse(JSON.stringify(payload));Object.assign(unavailablePayload.spotlights.find(stat=>stat.id==='lines_pushed'),{{available:false,current:null,previous:null,delta_pct:null}});unavailablePayload.coverage.git.available=false;const unavailableCanvas=new Canvas();drawBuilderRecap(unavailableCanvas,unavailablePayload,{{name:'',includeUsage:true}});
+	const flatPayload=JSON.parse(JSON.stringify(payload));flatPayload.spotlights.find(stat=>stat.id==='lines_pushed').delta_pct=0;const flatCanvas=new Canvas();drawBuilderRecap(flatCanvas,flatPayload,{{name:'',includeUsage:true}});const flatTexts=flatCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]);
+	const privateCanvas=new Canvas();drawBuilderRecap(privateCanvas,payload,{{name:'',includeUsage:false}});const privateTexts=privateCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]);
+	const noUsagePayload=JSON.parse(JSON.stringify(payload));noUsagePayload.usage={{agents:[],models:[]}};const noUsageCanvas=new Canvas();drawBuilderRecap(noUsageCanvas,noUsagePayload,{{name:'',includeUsage:true}});const noUsageTexts=noUsageCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]);
+	const gitOnlyPayload=JSON.parse(JSON.stringify(payload));gitOnlyPayload.activity_days=gitOnlyPayload.activity_days.map(day=>({{...day,recorded_session:false}}));const gitOnlyActivity=hasActivity(gitOnlyPayload);
+	class Control{{constructor(){{this.disabled=false;this.checked=false;this.value='';this.textContent='';this.children=[];}}appendChild(child){{this.children.push(child);}}}}
+	const controlElements={{'builder-name':new Control(),'include-usage':new Control()}},$=id=>controlElements[id],document={{querySelectorAll:()=>[],createElement:()=>new Control()}},builderRecapState={{range:30,name:'',includeUsage:true,payload:noUsagePayload}};function builderOptions(){{return {{name:builderRecapState.name,includeUsage:builderRecapState.includeUsage}};}}eval(extract('renderControls'));renderControls(noUsagePayload);
+		const heroRowLabels=canvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===314).map(op=>[op[1],op[2]]),heroRowValues=canvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===486).map(op=>[op[1],op[2],op[4]]),columnRules=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[3]===282&&op[5]===3).map(op=>[op[2],op[4]]);
+		console.log(JSON.stringify({{size:[canvas.width,canvas.height],texts,arcs,bars,rhythmBars,heroFields,lowerFields,heroRowLabels,heroRowValues,columnRules,aria:canvas.attrs['aria-label'],negativeAria:negativeCanvas.attrs['aria-label'],unavailableAria:unavailableCanvas.attrs['aria-label'],flatAria:flatCanvas.attrs['aria-label'],flatTexts,nameOp,heroOp,efficiencyLabelOp,metricLabelOps,ghostPeriodOps,summary:result.summary,privateTexts,privateAria:privateCanvas.attrs['aria-label'],noUsageTexts,noUsageAria:noUsageCanvas.attrs['aria-label'],gitOnlyActivity,noUsageControl:{{disabled:controlElements['include-usage'].disabled,checked:controlElements['include-usage'].checked}}}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["size"], [1080, 1350])
+        for text in (
+            "TOKEN METER", "PERFORMANCE CARD", "LAST 30 DAYS", "30D",
+            "ADA BUILDER", "LINES PUSHED",
+            "184,392", "OUTPUT EFFICIENCY", "2.68 K/$", "24/30",
+            "ACTIVE DAYS", "14 DAY STREAK", "FASTEST MODEL", "42.8 TOK/S",
+            "GPT-5.3", "AI SESSIONS", "126",
+            "MOST-USED AGENT", "GO-TO MODEL", "CODEX", "54%", "49%",
+            "BUILD YOURS →", "github.com/splunk/token-meter",
+        ):
+            self.assertIn(text, rendered["texts"])
+        self.assertEqual(rendered["nameOp"][1:4], ["ADA BUILDER", 72, 250])
+        self.assertIn("44px", rendered["nameOp"][4])
+        self.assertEqual(rendered["heroOp"][1], "184,392")
+        # Lines and commits form one two-column hero: labels share a line, values
+        # share a baseline, and each column carries its own accent rule.
+        self.assertEqual(
+            [(op[0], op[1]) for op in rendered["heroRowLabels"]],
+            [("LINES PUSHED", 72), ("COMMITS", 1008)],
+        )
+        self.assertEqual(
+            [(op[0], op[1]) for op in rendered["heroRowValues"]],
+            [("184,392", 72), ("1,284", 1008)],
+        )
+        self.assertEqual(rendered["columnRules"], [[72, 108], [900, 108]])
+        # Commits must stay visually subordinate to the lines hero.
+        hero_size = int(re.search(r"(\d+)px", rendered["heroRowValues"][0][2]).group(1))
+        commit_size = int(re.search(r"(\d+)px", rendered["heroRowValues"][1][2]).group(1))
+        self.assertLess(commit_size, hero_size)
+        self.assertIn("Commits pushed 1,284.", rendered["aria"])
+        self.assertIsNotNone(rendered["efficiencyLabelOp"])
+        # No covered-spend evidence: the spend cell is omitted and four equal
+        # columns span the content measure instead of leaving a gap.
+        self.assertEqual(
+            [(op[1], op[2]) for op in rendered["metricLabelOps"]],
+            [("ACTIVE DAYS", 72), ("OUTPUT EFFICIENCY", 314),
+             ("FASTEST MODEL", 556), ("AI SESSIONS", 798)],
+        )
+        self.assertNotIn("EQUIV. SPEND", rendered["texts"])
+        self.assertEqual(rendered["ghostPeriodOps"], [])
+        self.assertGreaterEqual(len(rendered["bars"]), 6)
+        self.assertEqual(len(rendered["rhythmBars"]), 30)
+        for index, bar in enumerate(rendered["rhythmBars"][:24]):
+            self.assertEqual(bar[1]["kind"], "linear")
+            self.assertEqual(
+                [stop[1] for stop in bar[1]["stops"]],
+                ["#8ee9f2", "#00bceb", "rgba(64,84,214,.72)"],
+            )
+            self.assertEqual(bar[5], 28 + ((index * 19) % 66))
+        for bar in rendered["rhythmBars"][24:]:
+            self.assertEqual((bar[1], bar[5]), ("rgba(159,180,189,.3)", 8))
+        self.assertTrue(rendered["heroFields"])
+        self.assertTrue(rendered["lowerFields"])
+        self.assertEqual(
+            [stop[1] for stop in rendered["heroFields"][0][1]["stops"]],
+            ["#0d2c3d", "#081a27", "#040d14"],
+        )
+        self.assertEqual(
+            [stop[1] for stop in rendered["lowerFields"][0][1]["stops"]],
+            ["#f8f5ee", "#f1eee4", "#e4e0d3"],
+        )
+        self.assertFalse(rendered["arcs"])
+        for raw_count in ("68", "39", "19", "74", "48", "29"):
+            self.assertNotIn(raw_count, rendered["texts"])
+        visible = " ".join(rendered["texts"])
+        for rejected in (
+            "BUILDER FIELD SHEET", "DAY SIGNAL", "30-DAY RHYTHM", "AGENT MIX",
+            "MODEL MIX", "LOCAL / PARTIAL",
+            "PRIVATE LOCAL AGGREGATES", "AI BUILDER RECAP", "prompt://must-not-draw",
+            "VS PRIOR", "↑", "↓", "+54%", "−25%", "NO CHANGE",
+            "LONGEST SESSION", "6H 42M",
+        ):
+            self.assertNotIn(rejected, visible)
+        self.assertIn(
+            "Name Ada Builder. Current lines pushed 184,392 lines.",
+            rendered["aria"],
+        )
+        self.assertIn(
+            "Current lines pushed 184,392 lines.",
+            rendered["negativeAria"],
+        )
+        self.assertIn(
+            "Current lines pushed unavailable.",
+            rendered["unavailableAria"],
+        )
+        self.assertIn(
+            "Current lines pushed 184,392 lines.", rendered["flatAria"],
+        )
+        for output in (
+            rendered["aria"], rendered["negativeAria"],
+            rendered["unavailableAria"], rendered["flatAria"],
+            rendered["summary"], " ".join(rendered["flatTexts"]),
+        ):
+            for rejected in (
+                "Partial evidence", "Complete evidence", "increased", "decreased",
+                "unchanged", "versus prior", "comparison", "VS PRIOR", "↑", "↓",
+            ):
+                self.assertNotIn(rejected, output)
+        self.assertTrue(rendered["gitOnlyActivity"])
+        self.assertIn("runtime-scoped model usage", rendered["aria"])
+        self.assertNotIn("prompt://must-not-draw", rendered["aria"])
+        private_visible = " ".join(rendered["privateTexts"])
+        self.assertIn("LINES PUSHED", private_visible)
+        self.assertIn("184,392", rendered["privateTexts"])
+        self.assertIn("OUTPUT EFFICIENCY", private_visible)
+        for excluded in ("MOST-USED AGENT", "GO-TO MODEL", "CODEX", "CLAUDE",
+                         "CURSOR", "GPT-5.3", "SONNET-4.5", "GPT-5.2"):
+            self.assertNotIn(excluded, private_visible)
+        for excluded in ("Codex", "Claude", "Cursor", "gpt-5.3", "sonnet-4.5", "gpt-5.2"):
+            self.assertNotIn(excluded, rendered["privateAria"])
+        self.assertIn("Usage charts excluded", rendered["privateAria"])
+        no_usage_visible = " ".join(rendered["noUsageTexts"])
+        self.assertNotIn("MOST-USED AGENT", no_usage_visible)
+        self.assertNotIn("GO-TO MODEL", no_usage_visible)
+        self.assertIn("Usage charts unavailable", rendered["noUsageAria"])
+        self.assertEqual(rendered["noUsageControl"], {
+            "disabled": True, "checked": False,
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for preview verification")
+    def test_standalone_success_enables_download_without_export_ready_copy(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+class Element{{constructor(){{this.disabled=true;this.hidden=true;this.textContent='';this.dataset={{}};}}}}
+const elements={{download:new Element(),retry:new Element(),poster:new Element(),status:new Element()}},$=id=>elements[id];
+elements.poster.getContext=()=>({{}});elements.poster.setAttribute=()=>{{}};
+const builderRecapState={{payload:{{activity_days:[{{recorded_session:true}}]}},loading:false,error:'',rendered:false}};
+const logo={{complete:false,naturalWidth:0}};let shouldFail=false;function hasActivity(){{return true;}}function drawBuilderRecap(){{if(shouldFail)throw Error('private failure');}}function drawPlaceholder(){{}}function builderOptions(){{return {{logo}};}}function setStatus(message,kind=''){{elements.status.textContent=message;elements.status.dataset.kind=kind;}}
+for(const name of ['showLogoFailure','renderPreview'])eval(extract(name));
+const waitingReady=renderPreview(),waiting={{ready:waitingReady,download:elements.download.disabled,status:elements.status.textContent}};
+logo.complete=true;logo.naturalWidth=1024;
+const ready=renderPreview(),success={{ready,download:elements.download.disabled,status:elements.status.textContent,kind:elements.status.dataset.kind}};
+shouldFail=true;const failed=renderPreview(),failure={{failed,download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind}};
+console.log(JSON.stringify({{waiting,success,failure}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["waiting"], {
+            "ready": False, "download": True,
+            "status": "Loading local brand asset…",
+        })
+        self.assertEqual(rendered["success"], {
+            "ready": True, "download": False, "status": "", "kind": "",
+        })
+        self.assertEqual(rendered["failure"], {
+            "failed": False, "download": True, "retry": False,
+            "status": "Preview unavailable. Try again.", "kind": "error",
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for logo recovery verification")
+    def test_standalone_logo_error_retries_local_asset_before_enabling_download(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)return '';let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+class Element{{
+ constructor(){{this.disabled=true;this.hidden=true;this.textContent='';this.dataset={{}};this.listeners={{}};}}
+ addEventListener(type,handler){{this.listeners[type]=handler;}}
+ dispatch(type){{if(this.listeners[type])this.listeners[type]({{target:this}});}}
+}}
+class Logo extends Element{{
+ constructor(){{super();this.complete=false;this.naturalWidth=0;this._src='/assets/brand/logo-splunk-by-cisco-rgb-w.png';this.sourceWrites=[];this.sourceRemovals=0;}}
+ get src(){{return this._src;}}
+ set src(value){{this._src=String(value);this.sourceWrites.push(this._src);}}
+ getAttribute(name){{return name==='src'?this._src:null;}}
+ removeAttribute(name){{if(name==='src'){{this._src='';this.sourceRemovals++;}}}}
+}}
+const elements={{download:new Element(),retry:new Element(),reset:new Element(),poster:new Element(),status:new Element(),'performance-card-logo':new Logo()}},$=id=>elements[id];
+elements.poster.getContext=()=>({{}});elements.poster.setAttribute=()=>{{}};
+const builderRecapState={{range:30,payload:{{activity_days:[{{recorded_session:true}}]}},loading:false,error:'',rendered:false,logoError:false}};
+let recapLoads=0;function loadRecap(){{recapLoads++;}}function resetRecap(){{}}function downloadRecap(){{}}function hasActivity(){{return true;}}function drawBuilderRecap(){{}}function drawPlaceholder(){{}}function builderOptions(){{return {{logo:elements['performance-card-logo']}};}}function setStatus(message,kind=''){{elements.status.textContent=message;elements.status.dataset.kind=kind;}}
+for(const name of ['showLogoFailure','retryLogo','handleLogoLoad','renderPreview']){{const source=extract(name);if(source)eval(source);}}
+for(const line of page.split('\\n').filter(line=>line.includes("$('retry').addEventListener")||line.includes("$('performance-card-logo').addEventListener")))eval(line);
+renderPreview();
+const logo=elements['performance-card-logo'];logo.complete=true;logo.dispatch('error');
+const failure={{download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind}};
+elements.retry.dispatch('click');
+const retrying={{download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind,source:logo.src,sourceWrites:logo.sourceWrites,sourceRemovals:logo.sourceRemovals,recapLoads}};
+logo.complete=true;logo.naturalWidth=1024;logo.dispatch('load');
+const recovered={{rendered:builderRecapState.rendered,download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind}};
+console.log(JSON.stringify({{failure,retrying,recovered}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["failure"], {
+            "download": True, "retry": False,
+            "status": "Local brand asset unavailable. Try again.",
+            "kind": "error",
+        })
+        self.assertEqual(rendered["retrying"], {
+            "download": True, "retry": True,
+            "status": "Loading local brand asset…", "kind": "",
+            "source": "/assets/brand/logo-splunk-by-cisco-rgb-w.png",
+            "sourceWrites": ["/assets/brand/logo-splunk-by-cisco-rgb-w.png"],
+            "sourceRemovals": 1, "recapLoads": 0,
+        })
+        self.assertEqual(rendered["recovered"], {
+            "rendered": True, "download": False, "retry": True,
+            "status": "", "kind": "",
+        })
+
+    def test_standalone_export_contract_is_png_only(self):
+        page = Path(meter.__file__).with_name("performance.html").read_text()
+        for marker in (
+            "canvas.width=1080", "canvas.height=1350", "canvas.toBlob(blob=>",
+            "'image/png'", "URL.revokeObjectURL", "function downloadRecap(",
+            "function resetRecap(", "new AbortController()",
+        ):
+            self.assertIn(marker, page)
+        self.assertNotIn("LOCAL / PARTIAL", page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for input verification")
+    def test_standalone_name_input_preserves_spaces_while_typing(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const input={{value:'',addEventListener(type,handler){{this.handler=handler;}}}},$=id=>input;
+const builderRecapState={{name:''}};let renders=0;function renderPreview(){{renders++;}}
+eval(extract('sanitizeBuilderName'));
+const handlerSource=page.split('\\n').find(line=>line.startsWith("$('builder-name').addEventListener('input',"));eval(handlerSource);
+for(const character of 'Ada Lovelace'){{input.value+=character;input.handler({{target:input}});}}
+console.log(JSON.stringify({{field:input.value,state:builderRecapState.name,renders}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), {
+            "field": "Ada Lovelace", "state": "Ada Lovelace", "renders": 12,
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for request verification")
+    def test_standalone_request_lifecycle_is_latest_only_and_retryable(self):
+        page_path = Path(meter.__file__).with_name("performance.html")
+        script = f"""
+const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);if(page.slice(start-6,start)==='async ')start-=6;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+class Element{{constructor(){{this.disabled=false;this.hidden=true;this.checked=false;this.value='';this.dataset={{}};}}}}
+const elements=Object.fromEntries(['download','retry','builder-name','include-usage'].map(id=>[id,new Element()])), $=id=>elements[id];
+const builderRecapState={{range:30,name:'',includeUsage:true,payload:null,request:0,controller:null,loading:false,error:'',rendered:false}};
+class AbortController{{constructor(){{this.signal={{aborted:false}};}}abort(){{this.signal.aborted=true;}}}}
+let requests=[],status='';function fetch(url,options){{return new Promise(resolve=>requests.push({{url,options,resolve}}));}}function renderControls(){{}}function drawPlaceholder(){{}}function setStatus(message){{status=message;}}function renderPreview(){{builderRecapState.rendered=true;$('download').disabled=false;return true;}}
+eval(extract('sanitizeBuilderName'));eval(extract('defaultPosterStats'));eval(extract('loadRecap'));eval(extract('resetRecap'));
+const payload=range=>({{ok:true,range_days:range,activity_days:[{{recorded_session:true}}],coverage:{{git:{{available:true}}}}}});
+;(async()=>{{
+ const first=loadRecap(30);await Promise.resolve();const second=loadRecap(7);await Promise.resolve();const third=loadRecap(90);await Promise.resolve();
+ requests[0].resolve({{ok:true,json:async()=>payload(30)}});requests[1].resolve({{ok:true,json:async()=>payload(7)}});requests[2].resolve({{ok:true,json:async()=>payload(90)}});await Promise.all([first,second,third]);
+ const latest={{range:builderRecapState.range,payload:builderRecapState.payload.range_days,aborted:requests[1].options.signal.aborted,download:$('download').disabled}};
+ const sanitized=sanitizeBuilderName('  Ada\\n\\u0000 Lovelace  ');
+ const failedPromise=loadRecap(7);await Promise.resolve();requests[3].resolve({{ok:false,json:async()=>({{}})}});await failedPromise;const failed={{download:$('download').disabled,retry:$('retry').hidden,status}};
+ builderRecapState.name='Ada';builderRecapState.includeUsage=false;const resetPromise=resetRecap();await Promise.resolve();requests[4].resolve({{ok:true,json:async()=>payload(30)}});await resetPromise;
+ const reset={{range:builderRecapState.range,name:builderRecapState.name,usage:builderRecapState.includeUsage}};
+ console.log(JSON.stringify({{latest,sanitized,failed,reset,urls:requests.map(item=>item.url)}}));
+}})().catch(error=>{{console.error(error.stack||error);process.exitCode=1;}});
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=False,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["latest"], {
+            "range": 90, "payload": 90, "aborted": True, "download": False,
+        })
+        self.assertEqual(rendered["sanitized"], "Ada Lovelace")
+        self.assertEqual(rendered["failed"], {
+            "download": True, "retry": False,
+            "status": "Unable to load the builder recap. Try again.",
+        })
+        self.assertEqual(rendered["reset"], {
+            "range": 30, "name": "", "usage": True,
+        })
+        self.assertEqual(rendered["urls"], [
+            "/builder-recap?range=30", "/builder-recap?range=7",
+            "/builder-recap?range=90", "/builder-recap?range=7",
+            "/builder-recap?range=30",
+        ])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_cost_discount_flows.py b/tests/test_cost_discount_flows.py
new file mode 100644
index 00000000..0b038d7d
--- /dev/null
+++ b/tests/test_cost_discount_flows.py
@@ -0,0 +1,811 @@
+import unittest
+import json
+import os
+import sqlite3
+import tempfile
+import threading
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from token_meter.contracts import DiscoveryContext
+from tests.meter_support import LocalApiHttpBase, _REAL_SCHEDULE, _REAL_REFRESH
+from tests.opencode_test_support import OpenCodeCase
+
+
+class CostDiscountTests(unittest.TestCase):
+    """Contracted discounts apply per request to list-price estimates only."""
+
+    T0 = 1_788_000_000  # 2026-08-29T14:40:00Z
+
+    def setUp(self):
+        meter._reset_cost_discount_cache()
+        self.addCleanup(meter._reset_cost_discount_cache)
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.tmp = Path(self._tmp.name)
+
+    @staticmethod
+    def rule(price_list, channel, percent, start=None, end=None, rule_id=None):
+        return {"id": rule_id or "d_" + (price_list + channel + str(percent)).replace(".", "")[:30].lower().ljust(8, "0"),
+                "price_list": price_list, "channel": channel, "percent": percent,
+                "start": start, "end": end}
+
+    def settings(self, rules=(), runtime_channels=None, **other):
+        path = self.tmp / "settings-{}.json".format(len(list(self.tmp.iterdir())))
+        payload = dict(other)
+        if rules is not None:
+            payload["cost_discounts"] = {"version": 1, "rules": list(rules),
+                                         **({"runtime_channels": runtime_channels} if runtime_channels else {})}
+        path.write_text(json.dumps(payload))
+        meter._reset_cost_discount_cache()
+        return path
+
+    def patched(self, path):
+        return mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path))
+
+    CODEX_USAGE = {"input_tokens": 1_000_000, "output_tokens": 100_000,
+                   "cache_read_input_tokens": 0, "cache_creation_input_tokens": 0}
+
+    # ---- persistence -------------------------------------------------
+
+    def test_absent_key_means_list_price_and_reading_never_seeds(self):
+        path = self.settings(rules=None, budgets={"monthly_total": 5})
+        before = path.read_text()
+        with self.patched(path):
+            listed = meter.cost_of(self.CODEX_USAGE, "gpt-5.4", "codex", at=self.T0)
+            view = meter.cost_discount_settings()
+        self.assertEqual(listed.discount_usd, 0.0)
+        self.assertEqual(view["rules"], [])
+        self.assertEqual(view["runtime_channels"], {"claude_code": "auto", "claude_desktop": "auto"})
+        self.assertEqual(path.read_text(), before)
+        self.assertNotIn("cost_discounts", meter.OBSOLETE_SETTINGS_KEYS)
+
+    def test_ops_persist_atomically_and_preserve_other_settings(self):
+        path = self.settings(rules=None, budgets={"monthly_total": 5})
+        original = meter.atomic_write_text
+        with mock.patch.object(meter, "atomic_write_text", side_effect=original) as write:
+            result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {
+                "external_id": "sync:a", "price_list": "anthropic", "channel": "direct",
+                "percent": 30, "start": "2026-09-01T00:00:00-07:00", "end": None,
+                "label": "Team plan"}}], path=str(path), now=self.T0)
+        saved = json.loads(path.read_text())
+        self.assertTrue(result["ok"], result)
+        self.assertTrue(result["changed"])
+        self.assertEqual(write.call_count, 1)
+        self.assertEqual(saved["budgets"], {"monthly_total": 5})
+        stored = saved["cost_discounts"]["rules"][0]
+        self.assertRegex(stored["id"], r"^d_[a-z0-9]{8,40}$")
+        self.assertEqual((stored["start"], stored["set_by"], stored["source"]), (1788246000, "Settings", "dashboard"))
+        self.assertEqual(result["revision"], meter.cost_discount_settings(str(path))["revision"])
+        self.assertEqual(result["rules"][0]["start_iso"], "2026-09-01T07:00:00Z")
+
+    def test_invalid_stored_rule_is_ignored_without_rewrite(self):
+        path = self.settings([self.rule("openai", "any", 50), {"id": "broken", "percent": 500}])
+        before, mtime = path.read_text(), path.stat().st_mtime_ns
+        with self.patched(path):
+            view = meter.cost_discount_settings()
+            cost = meter.cost_of(self.CODEX_USAGE, "gpt-5.4", "codex", at=self.T0)
+        self.assertEqual(view["invalid_rules"], 1)
+        self.assertEqual(len(view["rules"]), 1)
+        self.assertAlmostEqual(cost.discount_usd, cost.list_usd * 0.5)
+        self.assertEqual((path.read_text(), path.stat().st_mtime_ns), (before, mtime))
+
+    def test_upsert_delete_replace_scope_and_runtime_channels(self):
+        path = str(self.settings(rules=None))
+        upsert = {"op": "upsert", "rule": {"external_id": "sync:a", "price_list": "anthropic",
+                                           "channel": "direct", "percent": 30}}
+        first = meter.apply_cost_discount_ops([upsert], path=path, now=1)
+        original = meter.atomic_write_text
+        with mock.patch.object(meter, "atomic_write_text", side_effect=original) as write:
+            again = meter.apply_cost_discount_ops([upsert], source="api", set_by="sync", path=path, now=2)
+        self.assertEqual((again["changed"], again["revision"], write.call_count), (False, first["revision"], 0))
+        rule_id = first["rules"][0]["id"]
+        edited = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {
+            "external_id": "sync:a", "percent": 25}}], source="api", set_by="contract-sync", path=path, now=3)
+        self.assertEqual((edited["rules"][0]["id"], edited["rules"][0]["percent"]), (rule_id, 25))
+        self.assertEqual(edited["rules"][0]["set_by"], "contract-sync")
+        scoped = meter.apply_cost_discount_ops([{"op": "replace_scope", "price_list": "openai", "channel": "any",
+                                                 "rules": [{"external_id": "sync:o", "percent": 62}]}], path=path)
+        self.assertEqual(sorted(r["price_list"] for r in scoped["rules"]), ["anthropic", "openai"])
+        cleared = meter.apply_cost_discount_ops([{"op": "replace_scope", "price_list": "openai",
+                                                  "channel": "any", "rules": []}], path=path)
+        self.assertEqual([r["id"] for r in cleared["rules"]], [rule_id])
+        missing = meter.apply_cost_discount_ops([{"op": "delete", "external_id": "nope"}], path=path)
+        self.assertEqual((missing["ok"], missing["changed"]), (True, False))
+        channels = meter.apply_cost_discount_ops([{"op": "set_runtime_channels", "claude_code": "bedrock"}], path=path)
+        self.assertTrue(channels["changed"])
+        self.assertEqual(meter.cost_discount_settings(path)["runtime_channels"]["claude_code"], "bedrock")
+        deleted = meter.apply_cost_discount_ops([{"op": "delete", "id": rule_id}], path=path)
+        self.assertEqual(deleted["rules"], [])
+
+    def test_batches_are_all_or_nothing_and_errors_are_plain(self):
+        path = str(self.settings([self.rule("anthropic", "direct", 30, start=100)]))
+        before = Path(path).read_text()
+        overlap = meter.apply_cost_discount_ops([
+            {"op": "upsert", "rule": {"price_list": "openai", "percent": 10}},
+            {"op": "upsert", "rule": {"price_list": "anthropic", "channel": "direct", "percent": 20, "start": 50}},
+        ], path=path)
+        self.assertFalse(overlap["ok"])
+        self.assertEqual(overlap["error"], "Anthropic billed by the provider already has 30% for overlapping dates.")
+        for ops in ([{"op": "rename"}], [{"op": "delete", "id": "x"}] * 65,
+                    [{"op": "upsert", "rule": {"price_list": "openai", "percent": 5, "start": "2026-09-01"}}],
+                    [{"op": "upsert", "rule": {"price_list": "cursor", "channel": "direct", "percent": 5}}]):
+            self.assertFalse(meter.apply_cost_discount_ops(ops, path=path)["ok"])
+        self.assertEqual(Path(path).read_text(), before)
+
+    def test_stale_expected_revision_is_a_conflict(self):
+        path = str(self.settings(rules=None))
+        stale = meter.cost_discount_settings(path)["revision"]
+        meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}], path=path)
+        result = meter.apply_cost_discount_ops(
+            [{"op": "upsert", "rule": {"price_list": "openai", "channel": "azure", "percent": 9}}],
+            expected_revision=stale, path=path)
+        self.assertEqual((result["ok"], result["conflict"]), (False, True))
+        self.assertEqual(result["revision"], meter.cost_discount_settings(path)["revision"])
+
+    def test_concurrent_settings_writers_keep_each_others_keys(self):
+        path = str(self.settings(rules=None))
+        original_load = meter.load_json
+
+        def slow_load(*args, **kwargs):
+            value = original_load(*args, **kwargs)
+            time.sleep(0.003)
+            return value
+
+        errors = []
+
+        def discounts():
+            for index in range(15):
+                result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {
+                    "external_id": "e{}".format(index), "price_list": "openai", "channel": "any",
+                    "percent": 5, "start": index * 10, "end": index * 10 + 10}}], path=path)
+                errors.extend([result] if not result["ok"] else [])
+
+        def other_features():
+            for index in range(15):
+                meter.set_update_settings({"enabled": index % 2 == 0}, path=path)
+                meter.set_model_price("openai", "gpt-custom-{}".format(index),
+                                      {"input": 1, "output": 2, "cache_write": 0, "cache_read": 0}, path=path)
+
+        with mock.patch.object(meter, "load_json", side_effect=slow_load):
+            threads = [threading.Thread(target=discounts), threading.Thread(target=other_features)]
+            for thread in threads:
+                thread.start()
+            for thread in threads:
+                thread.join()
+        saved = json.loads(Path(path).read_text())
+        self.assertEqual(errors, [])
+        self.assertEqual(len(saved["cost_discounts"]["rules"]), 15)
+        self.assertEqual(len(saved["model_pricing"]["codex"]), 15)
+        self.assertIn("updates", saved)
+
+    # ---- application -------------------------------------------------
+
+    def codex_rows(self, stamps):
+        rows = [{"type": "turn_context", "timestamp": stamps[0], "payload": {"model": "gpt-5.4"}}]
+        for stamp in stamps:
+            rows.append({"timestamp": stamp, "payload": {"type": "token_count", "info": {
+                "last_token_usage": {"input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}})
+        return rows
+
+    def codex_summary(self, path, stamps):
+        source = {"id": "s", "path": "/tmp/s.jsonl", "provider": "codex", "client": "codex",
+                  "label": "Codex", "project": "/repo", "mtime": 1, "title": "t", "model": "gpt-5.4"}
+        with self.patched(path):
+            return meter.codex_summary(source, self.codex_rows(stamps))
+
+    def test_codex_discount_applies_only_inside_its_range(self):
+        stamps = ["2026-09-01T10:00:00.000Z", "2026-09-02T10:00:00.000Z", "2026-09-03T10:00:00.000Z"]
+        start = meter.parse_iso("2026-09-02T00:00:00")
+        end = meter.parse_iso("2026-09-03T00:00:00")
+        listed = self.codex_summary(self.settings(rules=None), stamps)
+        discounted = self.codex_summary(self.settings([self.rule("openai", "direct", 50, start, end)]), stamps)
+        each = listed["cost"] / 3
+        self.assertAlmostEqual(discounted["cost"], each * 2.5)
+        self.assertAlmostEqual(discounted["discount_usd"], each * 0.5)
+        self.assertAlmostEqual(discounted["cost"] + discounted["discount_usd"], listed["cost"])
+        self.assertAlmostEqual(discounted["model_stats"][0]["discount_usd"], each * 0.5)
+        self.assertAlmostEqual(sum(discounted["_day_discount"].values()), each * 0.5)
+        self.assertAlmostEqual(sum(discounted["_day_cost"].values()), discounted["cost"])
+        azure = dict(listed)
+        self.assertEqual(azure["discount_usd"], 0.0)
+
+    def test_mid_day_boundary_splits_one_days_cost(self):
+        stamps = ["2026-09-02T10:00:00.000Z", "2026-09-02T14:00:00.000Z"]
+        start = meter.parse_iso("2026-09-02T12:00:00")
+        listed = self.codex_summary(self.settings(rules=None), stamps)
+        row = self.codex_summary(self.settings([self.rule("openai", "any", 40, start)]), stamps)
+        (day, cost), = row["_day_cost"].items()
+        self.assertAlmostEqual(cost, listed["_day_cost"][day] * 0.8)
+        self.assertAlmostEqual(row["_day_discount"][day], listed["_day_cost"][day] * 0.2)
+
+    def test_codex_on_azure_uses_azure_then_any_rule(self):
+        path = self.settings([self.rule("openai", "direct", 50), self.rule("openai", "azure", 20)])
+        source = {"id": "s", "path": "/tmp/s.jsonl", "provider": "codex", "client": "codex", "label": "Codex",
+                  "project": "/repo", "mtime": 1, "title": "t", "model": "gpt-5.4", "model_provider": "azure"}
+        with self.patched(path):
+            row = meter.codex_summary(source, self.codex_rows(["2026-09-02T10:00:00.000Z"]))
+        self.assertAlmostEqual(row["discount_usd"] / (row["cost"] + row["discount_usd"]), 0.2)
+
+    def test_cursor_hosted_gpt_ignores_openai_rule(self):
+        usage = {"input_tokens": 1_000_000, "output_tokens": 100_000}
+        with self.patched(self.settings([self.rule("openai", "any", 60)])):
+            openai_only = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=self.T0)
+        with self.patched(self.settings([self.rule("cursor", "any", 10)])):
+            cursor_rule = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=self.T0)
+        self.assertGreater(openai_only.list_usd, 0)
+        self.assertEqual(openai_only.discount_usd, 0.0)
+        self.assertAlmostEqual(cursor_rule.discount_usd, cursor_rule.list_usd * 0.1)
+
+    def test_kiro_takes_only_kiro_rules(self):
+        from token_meter.runtimes.kiro import KiroRuntimeAdapter
+        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
+                                     compatibility=meter._kiro_compatibility())
+        turn = {"input_tokens": 100_000, "output_tokens": 10_000, "end": self.T0, "model": "claude-sonnet-4-6"}
+        source = {"model": "claude-sonnet-4-6"}
+        with self.patched(self.settings([self.rule("anthropic", "any", 30)])):
+            _model, anthropic_only, available = adapter._legacy_turn(source, turn)
+        with self.patched(self.settings([self.rule("kiro", "any", 20)])):
+            _model, kiro_rule, _available = adapter._legacy_turn(source, turn)
+        self.assertTrue(available)
+        self.assertEqual(anthropic_only.discount_usd, 0.0)
+        self.assertAlmostEqual(kiro_rule.discount_usd, kiro_rule.list_usd * 0.2)
+        self.assertAlmostEqual(sum(kiro_rule.values()), sum(anthropic_only.values()) * 0.8)
+
+    def pi_summary(self, path, provider, child=None):
+        root = self.tmp / "pi-{}".format(len(list(self.tmp.iterdir())))
+        directory = root / "sessions" / "--repo--"
+        directory.mkdir(parents=True)
+        cost = {"input": 0.001, "output": 0.002, "cacheRead": 0.0001, "cacheWrite": 0.0002}
+        assistant = {"role": "assistant", "model": "claude-test", "provider": provider,
+                     "content": [{"type": "toolCall", "id": "call", "name": "subagent" if child else "read",
+                                  "arguments": {"agent": "probe"}}],
+                     "usage": {"input": 100, "output": 20, "cacheRead": 10, "cacheWrite": 5, "cost": cost}}
+        rows = [
+            {"type": "session", "version": 3, "id": "pi", "timestamp": "2026-09-04T10:00:00Z", "cwd": "/repo"},
+            {"type": "model_change", "timestamp": "2026-09-04T10:00:01Z", "provider": provider, "modelId": "claude-test"},
+            {"type": "message", "timestamp": "2026-09-04T10:00:02Z", "message": {"role": "user", "content": []}},
+            {"type": "message", "timestamp": "2026-09-04T10:00:05Z", "message": assistant},
+        ]
+        if child:
+            rows.append({"type": "message", "timestamp": "2026-09-04T10:00:09Z", "message": {
+                "role": "toolResult", "toolCallId": "call", "toolName": "subagent",
+                "details": {"mode": "single", "results": [{
+                    "agent": "probe", "exitCode": 0, "stopReason": "stop", "model": child,
+                    "usage": {"input": 1000, "output": 100, "cacheRead": 0, "cacheWrite": 0,
+                              "cost": 0.25, "turns": 2}}]}}})
+        (directory / "pi.jsonl").write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+        with self.patched(path), mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                mock.patch.object(meter, "_pi_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            return meter.pi_summary(meter.pi_session_sources()[0])
+
+    def test_pi_on_bedrock_uses_bedrock_then_any_never_direct(self):
+        own = 0.0033
+        direct_only = self.pi_summary(self.settings([self.rule("anthropic", "direct", 90)]), "amazon-bedrock")
+        both = self.pi_summary(self.settings([self.rule("anthropic", "bedrock", 40),
+                                              self.rule("anthropic", "any", 10)]), "amazon-bedrock")
+        any_only = self.pi_summary(self.settings([self.rule("anthropic", "any", 10)]), "amazon-bedrock")
+        self.assertAlmostEqual(direct_only["cost"], own)
+        self.assertEqual(direct_only["discount_usd"], 0.0)
+        self.assertAlmostEqual(both["cost"], own * 0.6)
+        self.assertAlmostEqual(any_only["cost"], own * 0.9)
+        self.assertAlmostEqual(any_only["cost"] + any_only["discount_usd"], own)
+
+    def test_pi_subagent_cost_is_discounted_once(self):
+        listed = self.pi_summary(self.settings(rules=None), "anthropic", child="anthropic/claude-sonnet-4-6")
+        row = self.pi_summary(self.settings([self.rule("anthropic", "any", 50)]), "anthropic",
+                              child="anthropic/claude-sonnet-4-6")
+        self.assertAlmostEqual(listed["cost"], 0.2533)
+        self.assertAlmostEqual(row["cost"], 0.2533 * 0.5)
+        self.assertAlmostEqual(row["discount_usd"], 0.2533 * 0.5)
+        records = {record["kind"]: record for record in row["_agent_records"]}
+        self.assertAlmostEqual(records["root"]["cost"] + records["spawned"]["cost"], row["cost"])
+        gateway = self.pi_summary(self.settings([self.rule("anthropic", "any", 50)]), "anthropic",
+                                  child="opencode-go/deepseek-v4.1-flash")
+        self.assertAlmostEqual(gateway["cost"], 0.0033 * 0.5 + 0.25)
+
+    def test_opencode_vendor_messages_take_vendor_rules_and_gateway_takes_opencode(self):
+        helper = OpenCodeCase()
+        conn = helper._build_db(self.tmp)
+        base = 1_788_000_000_000
+        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
+            helper._session_row("ses_mix", "/repo", "Mixed", "claude-sonnet-4-6", 1.11,
+                                300, 30, 0, 0, 0, base + 10_000, provider_id="anthropic").values()))
+        for index, (model, provider, cost) in enumerate((
+                ("claude-sonnet-4-6", "anthropic", 1.0), ("gpt-5.4", "openai", 0.1),
+                ("kimi-k2", "opencode", 0.01), ("free-model", "openai", 0.0))):
+            created = base + index * 1000
+            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", helper._message(
+                "m{}".format(index), "ses_mix", {
+                    "role": "assistant", "modelID": model, "providerID": provider, "cost": cost,
+                    "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}},
+                    "time": {"created": created, "completed": created + 500}}, created))
+        conn.commit()
+        conn.close()
+        path = self.settings([self.rule("anthropic", "direct", 10), self.rule("openai", "any", 50),
+                              self.rule("opencode", "any", 20)])
+        source = {"provider": "opencode", "id": "ses_mix", "model": "claude-sonnet-4-6", "label": "OpenCode",
+                  "runtime": "OpenCode", "session": "ses_mix", "path": "opencode:ses_mix",
+                  "project": "/repo", "title": "Mixed", "mtime": 1.0}
+        with self.patched(path), mock.patch.object(meter, "OPENCODE_DB", str(self.tmp / "opencode.db")), \
+                mock.patch.object(meter, "_opencode_native_adapters", {}):
+            row = meter.opencode_summary(source)
+        costs = {stats["model"]: stats for stats in row["model_stats"]}
+        self.assertAlmostEqual(costs["claude-sonnet-4-6"]["cost"], 0.9)
+        self.assertAlmostEqual(costs["gpt-5.4"]["cost"], 0.05)
+        self.assertAlmostEqual(costs["kimi-k2"]["cost"], 0.008)
+        self.assertEqual(costs["free-model"]["cost"], 0.0)
+        self.assertAlmostEqual(row["discount_usd"], 0.1 + 0.05 + 0.002)
+        self.assertAlmostEqual(row["cost"] + row["discount_usd"], 1.11)
+
+    def opencode_long_session(self, schema):
+        """A 10-message OpenCode session, 0.1 each, in a V1 or V2 store."""
+        from tests.runtimes.test_opencode_adapter import V2_SCHEMA
+        db = self.tmp / "opencode-{}.db".format(schema)
+        con = sqlite3.connect(db)
+        base = 1_788_000_000_000
+        model = json.dumps({"id": "gpt-5.4", "providerID": "openai"})
+        if schema == "v2":
+            con.executescript(V2_SCHEMA)
+            con.execute(
+                "INSERT INTO session_v2 (id, project_id, slug, directory, title, version, cost, "
+                "tokens_input, tokens_output, agent, model, time_created, time_updated) "
+                "VALUES ('ses','p','ses','/repo','Long','2',1.0,1000,100,'build',?,?,?)",
+                (model, base, base + 20_000))
+        else:
+            OpenCodeCase._build_db(None, self.tmp)
+            con.close()
+            (self.tmp / "opencode.db").rename(db)
+            con = sqlite3.connect(db)
+            con.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
+                OpenCodeCase._session_row(None, "ses", "/repo", "Long", "gpt-5.4", 1.0, 1000, 100, 0, 0, 0,
+                                           base + 20_000, provider_id="openai").values()))
+        for index in range(10):
+            created = base + index * 1000
+            data = {"role": "assistant", "modelID": "gpt-5.4", "providerID": "openai", "cost": 0.1,
+                    "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}},
+                    "time": {"created": created, "completed": created + 500}}
+            if schema == "v2":
+                data = dict(data, model={"id": "gpt-5.4", "providerID": "openai"})
+                con.execute("INSERT INTO session_message VALUES (?,?,?,?,?,?,?)",
+                            ("m{}".format(index), "ses", "assistant", index, created, created, json.dumps(data)))
+            else:
+                con.execute("INSERT INTO message VALUES (?,?,?,?,?)",
+                            ("m{}".format(index), "ses", created, created, json.dumps(data)))
+        con.commit()
+        con.close()
+        return db
+
+    def test_opencode_session_discount_covers_messages_beyond_the_load_cap(self):
+        from token_meter.runtimes import opencode as opencode_runtime
+        source = {"provider": "opencode", "id": "ses", "model": "gpt-5.4", "model_provider": "openai",
+                  "label": "OpenCode", "runtime": "OpenCode", "session": "ses", "path": "opencode:ses",
+                  "project": "/repo", "title": "Long", "mtime": 1.0}
+        path = self.settings([self.rule("openai", "any", 50)])
+        for schema in ("v1", "v2"):
+            with self.subTest(schema=schema):
+                db = self.opencode_long_session(schema)
+                adapter = opencode_runtime.OpenCodeRuntimeAdapter(
+                    db, None, compatibility=meter._opencode_compatibility(), detail_message_limit=3)
+                with self.patched(path), mock.patch.object(opencode_runtime, "SUMMARY_MESSAGE_LIMIT", 4):
+                    row = adapter.summarize_legacy(dict(source))
+                    state = adapter.recompute_legacy(dict(source))
+                self.assertEqual(row["turns"], 4)
+                self.assertAlmostEqual(row["discount_usd"], 0.5)
+                self.assertAlmostEqual(row["cost"], 0.5)
+                self.assertAlmostEqual(row["cost"] + row["discount_usd"], 1.0)
+                self.assertEqual(len(state["executions"]), 3)
+                self.assertAlmostEqual(state["total_cost"], 0.5)
+        with self.patched(self.settings(rules=None)):
+            listed = opencode_runtime.OpenCodeRuntimeAdapter(
+                db, None, compatibility=meter._opencode_compatibility()).summarize_legacy(dict(source))
+        self.assertAlmostEqual(listed["cost"], 1.0)
+        self.assertEqual(listed["discount_usd"], 0.0)
+
+    def hermes_cost(self, path, status, column):
+        db = self.tmp / "hermes-{}.db".format(len(list(self.tmp.iterdir())))
+        con = sqlite3.connect(db)
+        con.execute("""CREATE TABLE sessions (id TEXT PRIMARY KEY, model TEXT, billing_provider TEXT,
+            started_at REAL, ended_at REAL, last_activity_at REAL, input_tokens INTEGER, output_tokens INTEGER,
+            cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER,
+            estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT,
+            billing_mode TEXT, tool_call_count INTEGER, api_call_count INTEGER, cwd TEXT, title TEXT)""")
+        con.execute("INSERT INTO sessions VALUES ('h','claude-test','anthropic',?,?,?,100,20,10,5,3,"
+                    "?,?,?,'recorded',NULL,2,1,'/p','t')",
+                    (self.T0, self.T0 + 10, self.T0 + 10,
+                     2.0 if column == "estimated" else None, 2.0 if column == "actual" else None, status))
+        con.commit()
+        con.close()
+        from token_meter.contracts import DetailLevel, DiscoveryContext
+        from token_meter.runtimes.hermes import HermesRuntimeAdapter
+        with self.patched(path):
+            adapter = HermesRuntimeAdapter(db, compatibility={
+                "price_for": meter.price_for, "cost_of": meter.cost_of, "discount_amount": meter.discount_amount})
+            source = adapter.discover(DiscoveryContext(home="/home/test"))[0]
+            return adapter.load(source, DetailLevel.SUMMARY).usage.cost_usd.value
+
+    def test_hermes_billed_cost_is_untouched_and_estimate_is_discounted(self):
+        path = self.settings([self.rule("anthropic", "any", 25)])
+        self.assertAlmostEqual(self.hermes_cost(path, "actual", "actual"), 2.0)
+        self.assertAlmostEqual(self.hermes_cost(path, "estimated", "estimated"), 1.5)
+
+    def claude_rows(self, request_id):
+        row = {"type": "assistant", "timestamp": "2026-09-02T10:00:00.000Z", "message": {
+            "id": "msg-1", "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
+            "usage": {"input_tokens": 100_000, "output_tokens": 10_000,
+                      "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0}}}
+        if request_id:
+            row["requestId"] = request_id
+        return [row]
+
+    def claude_fraction(self, path, request_id, client="claude_code"):
+        source = {"id": "c", "path": "/tmp/c.jsonl", "provider": "claude", "client": client, "label": "Claude",
+                  "project": "/repo", "mtime": 1, "title": "t", "model": None}
+        with self.patched(path):
+            row = meter.claude_summary(source, self.claude_rows(request_id))
+        self.assertGreater(row["cost"], 0)
+        return round(row["discount_usd"] / (row["cost"] + row["discount_usd"]), 6)
+
+    def test_claude_channel_follows_request_id_shape_or_declaration(self):
+        uuid = "0b7c0a8e-3f7d-4c55-9b1e-6c2f6d1c9a10"
+        rules = [self.rule("anthropic", "direct", 30), self.rule("anthropic", "bedrock", 15)]
+        path = self.settings(rules)
+        self.assertEqual(self.claude_fraction(path, "req_011abc"), 0.30)
+        self.assertEqual(self.claude_fraction(path, uuid), 0.15)
+        self.assertEqual(self.claude_fraction(path, None), 0.0)
+        any_path = self.settings([*rules, self.rule("anthropic", "any", 5)])
+        self.assertEqual(self.claude_fraction(any_path, None), 0.05)
+        declared = self.settings(rules, runtime_channels={"claude_code": "bedrock"})
+        self.assertEqual(self.claude_fraction(declared, "req_011abc"), 0.15)
+        self.assertEqual(self.claude_fraction(declared, "req_011abc", client="claude_desktop"), 0.30)
+
+    def test_cache_savings_are_discounted_by_the_same_rate(self):
+        execution = {"tokens": {"cache_read": 1_000_000, "fresh_input": 0, "cache_write": 0, "output": 0},
+                     "model": "gpt-5.4", "ts": self.T0, "cost": 0.6, "discount_usd": 0.4}
+        with self.patched(self.settings(rules=None)):
+            listed = meter.cache_savings({}, "codex", "gpt-5.4", [dict(execution, discount_usd=0.0)])
+            plain_now = meter.cache_savings({"cache_read": 1_000_000}, "codex", "gpt-5.4")
+        with self.patched(self.settings([self.rule("openai", "any", 40)])):
+            discounted = meter.cache_savings({}, "codex", "gpt-5.4", [execution])
+            now = meter.cache_savings({"cache_read": 1_000_000}, "codex", "gpt-5.4")
+        self.assertGreater(listed, 0)
+        self.assertAlmostEqual(discounted, listed * 0.6)
+        self.assertAlmostEqual(now, plain_now * 0.6)
+
+    def test_discount_stacks_on_price_override_and_after_modifiers(self):
+        path = self.settings(rules=None)
+        meter.set_model_price("openai", "gpt-custom-1",
+                              {"input": 2, "output": 8, "cache_write": 0, "cache_read": 0.2}, path=str(path),
+                              apply_to_all_history=True)
+        rules = {"version": 1, "rules": [self.rule("openai", "any", 50), self.rule("anthropic", "any", 25)]}
+        data = json.loads(path.read_text())
+        data["cost_discounts"] = rules
+        path.write_text(json.dumps(data))
+        meter._reset_cost_discount_cache()
+        with self.patched(path):
+            override = meter.cost_of(self.CODEX_USAGE, "gpt-custom-1", "codex", at=self.T0)
+            usage = {"input_tokens": 100_000, "output_tokens": 10_000, "speed": "fast", "inference_geo": "us",
+                     "server_tool_use": {"web_search_requests": 3}}
+            fast = meter.cost_of(usage, "claude-opus-5-5", "claude", at=self.T0)
+            plain = meter.cost_of({"input_tokens": 100_000, "output_tokens": 10_000},
+                                  "claude-opus-5-5", "claude", at=self.T0)
+        self.assertAlmostEqual(sum(override.values()), (2 + 0.8) / 2)
+        self.assertGreater(fast.list_usd, plain.list_usd * 2)
+        self.assertAlmostEqual(sum(fast.values()), fast.list_usd * 0.75)
+        self.assertAlmostEqual(sum(fast.values()) + fast.discount_usd, fast.list_usd)
+        self.assertAlmostEqual(fast["server_tools"], 0.03 * 0.75)
+
+    def test_unavailable_and_free_stay_as_they_are(self):
+        with self.patched(self.settings([self.rule("openai", "any", 50)])):
+            unpriced = meter.cost_of(self.CODEX_USAGE, "no-such-model", "codex", at=self.T0)
+            free = meter.cost_of({"input_tokens": 0, "output_tokens": 0}, "gpt-5.4", "codex", at=self.T0)
+            self.assertEqual(meter.discount_amount(None, "openai", "direct", self.T0), (None, 0.0))
+            self.assertEqual(meter.discount_amount(0.0, "openai", "direct", self.T0), (0.0, 0.0))
+            row = self.codex_summary(Path(meter.TOKEN_METER_SETTINGS), ["2026-09-02T10:00:00.000Z"])
+        self.assertEqual((sum(unpriced.values()), unpriced.discount_usd), (0.0, 0.0))
+        self.assertEqual((sum(free.values()), free.discount_usd), (0.0, 0.0))
+        self.assertTrue(row["availability"]["cost"])
+
+    def test_cross_session_aggregates_carry_discount_beside_cost(self):
+        rows = [{
+            "id": "a", "provider": "codex", "runtime": "Codex", "cost": 6.0, "discount_usd": 4.0, "turns": 1,
+            "availability": {"cost": True}, "_model_cost": {"gpt": 6.0}, "_model_discount": {"gpt": 4.0},
+            "_model_tok": {"gpt": 10}, "_day_cost": {"2026-09-01": 2.0, "2026-09-02": 4.0},
+            "_day_discount": {"2026-09-02": 4.0}, "mtime": 1,
+        }, {
+            "id": "b", "provider": "claude", "runtime": "Claude", "cost": 1.0, "discount_usd": 0.0, "turns": 1,
+            "availability": {"cost": True}, "_model_cost": {"opus": 1.0}, "_model_tok": {"opus": 5},
+            "_day_cost": {"2026-09-02": 1.0}, "mtime": 2,
+        }]
+        aggregate = meter._domain_aggregate_cross_session_rows(rows)
+        daily = {row["day"]: row for row in meter.daily_summaries(rows, limit=None)}
+        months = meter.monthly_summaries(rows)
+        spend = meter.spend_projection(list(daily.values()))
+        self.assertEqual((aggregate["total_cost"], aggregate["discount_usd"]), (7.0, 4.0))
+        self.assertEqual({item["model"]: item.get("discount_usd") for item in aggregate["model_mix"]},
+                         {"gpt": 4.0, "opus": None})
+        self.assertEqual(daily["2026-09-02"]["discount_usd"], 4.0)
+        self.assertNotIn("discount_usd", daily["2026-09-01"])
+        self.assertEqual({p["provider"]: p.get("discount_usd") for p in daily["2026-09-02"]["providers"]},
+                         {"codex": 4.0, "claude": None})
+        listed = meter._domain_aggregate_cross_session_rows([rows[1]])
+        self.assertNotIn("discount_usd", listed)
+        self.assertEqual((months[0]["cost"], months[0]["discount_usd"]), (7.0, 4.0))
+        self.assertEqual(sum(day.get("discount_usd", 0.0) for day in spend), 4.0)
+
+    def test_pricing_recalculation_is_single_flight_and_repeats_when_stale(self):
+        calls = []
+        release = threading.Event()
+
+        def runner():
+            calls.append(1)
+            release.wait(5)
+            meter._pricing_state["cache_revision"] = meter.pricing_fingerprint()
+
+        with mock.patch.dict(meter._pricing_recalc, {"running": False, "pending": False}), \
+                mock.patch.dict(meter._pricing_state, {"cache_revision": None}):
+            self.assertEqual(meter.schedule_pricing_recalculation(runner), "scheduled")
+            self.assertEqual(meter.schedule_pricing_recalculation(runner), "scheduled")
+            release.set()
+            meter._pricing_recalc["thread"].join(5)
+            self.assertFalse(meter.pricing_recalculation_running())
+        self.assertEqual(len(calls), 2)
+
+    def test_invalidate_cost_caches_drops_cached_dollars(self):
+        meter._summary_cache["/x"] = {"signature": 1, "row": {}}
+        meter._xsess["data"], meter._xsess["at"] = {"total_cost": 1}, time.time()
+        path = self.settings([self.rule("openai", "any", 5)])
+        with self.patched(path), mock.patch.dict(meter._pricing_state, {"cache_revision": "p_old"}):
+            meter._load_cost_discounts()
+            meter._cost_discount_cache["state"] = dict(meter._cost_discount_cache["state"], revision="stale")
+            meter.invalidate_cost_caches()
+            self.assertNotIn("/x", meter._summary_cache)
+            self.assertIsNone(meter._xsess["data"])
+            self.assertNotEqual(meter._cost_discount_cache["state"]["revision"], "stale")
+            self.assertEqual(meter._pricing_state["cache_revision"], meter.pricing_fingerprint())
+
+
+class CostDiscountHttpTests(LocalApiHttpBase):
+    """The local discount API: Host/Origin gate, tokens, limits, and recalculation."""
+
+    UPSERT = {"ops": [{"op": "upsert", "rule": {"external_id": "sync:o", "price_list": "openai",
+                                                "channel": "any", "percent": 62}}]}
+
+    def test_bearer_and_action_tokens_are_accepted_and_others_refused(self):
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts")[0], 200)
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts", bearer=False, action=True)[0], 200)
+        for bearer in (False, "x" * 43):
+            status, payload, _ = self.request("GET", "/api/v1/cost-discounts", bearer=bearer)
+            self.assertEqual((status, payload), (401, {"ok": False, "error": "Unauthorized."}))
+        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, bearer=False)
+        self.assertEqual(status, 401)
+
+    def test_host_and_origin_must_be_loopback(self):
+        for host in ("evil.example:{}".format(self.port), "127.0.0.1:1", "127.0.0.1"):
+            status, payload, _ = self.request("GET", "/api/v1/cost-discounts", host=host)
+            self.assertEqual((status, payload), (403, {"ok": False, "error": "Forbidden."}))
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts",
+                                      host="localhost:{}".format(self.port))[0], 200)
+        status, _, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, origin="https://evil.example")
+        self.assertEqual(status, 403)
+        self.assertFalse(self.settings.exists())
+
+    def test_limits_and_validation_errors(self):
+        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", raw=b"{" + b" " * 9000 + b"}")
+        self.assertEqual((status, payload["error"]), (413, "Request too large."))
+        self.assertEqual(self.request("POST", "/api/v1/cost-discounts", raw=b"{nope")[0], 400)
+        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [{"op": "upsert", "rule": {
+            "price_list": "openai", "percent": 100}}]})
+        self.assertEqual((status, payload["error"]),
+                         (400, "Discount percent must be more than 0 and less than 100."))
+        self.scheduled.assert_not_called()
+
+    def test_write_records_client_conflicts_and_idempotent_repeat(self):
+        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, client="contract-sync")
+        self.assertEqual(status, 200, payload)
+        self.assertEqual((payload["changed"], payload["recalculation"]), (True, "scheduled"))
+        self.assertEqual(payload["rules"][0]["set_by"], "contract-sync")
+        self.assertEqual(payload["pricing_revision"], meter.pricing_fingerprint())
+        self.assertEqual(self.scheduled.call_count, 1)
+        status, again, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, client="<bad>")
+        self.assertEqual((status, again["changed"], again["recalculation"]), (200, False, "complete"))
+        self.assertEqual(self.scheduled.call_count, 1)
+        status, stale, _ = self.request("POST", "/api/v1/cost-discounts", {
+            "expected_revision": "r_0000000000000000", **self.UPSERT})
+        self.assertEqual((status, stale["revision"]), (409, payload["revision"]))
+        status, other, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [{"op": "upsert", "rule": {
+            "price_list": "anthropic", "percent": 5}}]}, client="<bad>")
+        self.assertEqual(other["rules"][0]["set_by"], "Another tool")
+
+    def test_resolve_endpoint(self):
+        self.request("POST", "/api/v1/cost-discounts", self.UPSERT)
+        status, payload, _ = self.request(
+            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=azure&at=2026-10-01T12:00:00Z")
+        self.assertEqual((status, payload["percent"]), (200, 62))
+        self.assertRegex(payload["rule_id"], r"^d_")
+        status, none, _ = self.request("GET", "/api/v1/cost-discounts/resolve?price_list=cursor&channel=any&at=1")
+        self.assertEqual((status, none["percent"], none["rule_id"]), (200, None, None))
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts/resolve?price_list=google&channel=any")[0], 400)
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=x")[0], 400)
+        self.assertEqual(self.request(
+            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=any&at=2026-10-01")[0], 400)
+
+    def test_rotate_replaces_token_and_old_token_stops_working(self):
+        old = self.token
+        status, payload, text = self.request("POST", "/api/v1/api-token/rotate", raw=b"")
+        self.assertEqual((status, payload), (200, {"ok": True}))
+        new = self.token_path.read_text().strip()
+        self.assertNotEqual(new, old)
+        self.assertNotIn(new, text)
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts", bearer=old)[0], 401)
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts", bearer=new)[0], 200)
+        self.assertEqual(self.request("POST", "/api/v1/api-token/rotate", raw=b"", bearer=False)[0], 401)
+
+    def test_token_file_is_private_and_reused_across_restarts(self):
+        self.assertEqual(self.token_path.stat().st_mode & 0o777, 0o600)
+        self.assertEqual(meter.ensure_api_token(), self.token)
+        os.chmod(self.token_path, 0o644)
+        self.assertEqual(meter.ensure_api_token(), self.token)
+        self.assertEqual(self.token_path.stat().st_mode & 0o777, 0o600)
+
+    def test_token_never_appears_in_dashboard_or_health_payloads(self):
+        with mock.patch.dict(meter._xsess, {"data": {"pricing_revision": "p_old"}, "at": time.time()}), \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value={}):
+            for path in ("/state", "/health", "/menubar", "/api/v1/cost-discounts"):
+                with self.subTest(path=path):
+                    _status, _payload, text = self.request("GET", path)
+                    self.assertNotIn(self.token, text)
+        self.assertNotIn(self.token, json.dumps(meter.health_state()[0]))
+
+    def test_dashboard_alias_needs_the_action_token(self):
+        status, payload, _ = self.request("POST", "/settings/cost-discounts", self.UPSERT)
+        self.assertEqual(status, 403)
+        status, payload, _ = self.request("POST", "/settings/cost-discounts", self.UPSERT,
+                                          bearer=False, action=True)
+        self.assertEqual(status, 200, payload)
+        self.assertEqual((payload["rules"][0]["source"], payload["rules"][0]["set_by"]), ("dashboard", "Settings"))
+
+    def test_health_reports_new_pricing_revision_once_recalculation_completes(self):
+        self.request("POST", "/api/v1/cost-discounts", self.UPSERT)
+        expected = meter.pricing_fingerprint()
+        self.assertEqual(meter.health_state()[0]["pricing_revision"], "p_old")
+        with mock.patch.object(meter, "schedule_pricing_recalculation", _REAL_SCHEDULE), \
+                mock.patch.object(meter, "all_session_sources", return_value=[]), \
+                mock.patch.object(meter, "newest_source", return_value=None), \
+                mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}), \
+                mock.patch.dict(meter._pricing_state, {"cache_revision": None}):
+            meter.schedule_pricing_recalculation()
+            meter._pricing_recalc["thread"].join(30)
+            self.assertFalse(meter.pricing_recalculation_running())
+            # Once the rebuilt snapshot is the one served, health reports its revision.
+            meter.STATE["xsession"] = meter._xsess["data"]
+            self.assertEqual(meter.health_state()[0]["pricing_revision"], expected)
+
+    def test_watcher_reprices_after_a_direct_settings_edit(self):
+        self.settings.write_text(json.dumps({"updates": {"enabled": True}}))
+        meter._reset_cost_discount_cache()
+        with mock.patch.dict(meter._pricing_state, {"cache_revision": meter.pricing_fingerprint()}):
+            self.assertFalse(meter.pricing_watch_tick())
+            self.settings.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [{
+                "id": "d_handedit1", "price_list": "openai", "channel": "any", "percent": 10}]}}))
+            meter._reset_cost_discount_cache()
+            self.assertTrue(meter.pricing_watch_tick())
+        self.scheduled.assert_called_once_with()
+
+
+class BudgetApiHttpTests(LocalApiHttpBase):
+    """Local tools can read and partially update monthly budgets; session caps stay private."""
+
+    def setUp(self):
+        super().setUp()
+        self.settings.write_text(json.dumps({"budgets": {
+            "allocations": {"claude": 100, "codex": 50},
+            "session_budgets": {"private-session-id": 3},
+        }, "updates": {"enabled": False}}))
+        self.refresh = mock.Mock(return_value={})
+        patcher = mock.patch.object(meter, "refresh_cross_session_state", self.refresh)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def saved(self):
+        return json.loads(self.settings.read_text())
+
+    def test_gate_matches_the_discount_api(self):
+        self.assertEqual(self.request("GET", "/api/v1/budgets")[0], 200)
+        self.assertEqual(self.request("GET", "/api/v1/budgets", bearer=False, action=True)[0], 200)
+        self.assertEqual(self.request("GET", "/api/v1/budgets", bearer=False)[0], 401)
+        self.assertEqual(self.request("GET", "/api/v1/budgets", bearer="x" * 43)[0], 401)
+        self.assertEqual(self.request("GET", "/api/v1/budgets", host="evil.example:{}".format(self.port))[0], 403)
+        self.assertEqual(self.request("POST", "/api/v1/budgets", {"thresholds": [50]},
+                                      origin="https://evil.example")[0], 403)
+        self.assertEqual(self.request("POST", "/api/v1/budgets", raw=b"{" + b" " * 9000 + b"}")[0], 413)
+        self.assertEqual(self.request("POST", "/api/v1/budgets", raw=b"{nope")[0], 400)
+        self.assertEqual(self.request("POST", "/api/v1/budgets", {"thresholds": [50]},
+                                      content_type="text/plain")[0], 415)
+        self.assertEqual(self.saved()["budgets"]["allocations"], {"claude": 100, "codex": 50})
+
+    def test_get_shape_never_includes_session_budgets(self):
+        status, payload, text = self.request("GET", "/api/v1/budgets")
+        self.assertEqual(status, 200)
+        self.assertEqual(set(payload), {"ok", "revision", "budgets", "runtimes", "limits", "month"})
+        self.assertRegex(payload["revision"], r"^b_[0-9a-f]{16}$")
+        self.assertEqual(set(payload["budgets"]), {"currency", "allocations", "monthly_total", "thresholds",
+                                                   "native_notifications", "default_session_budget"})
+        self.assertEqual(set(payload["budgets"]["allocations"]), set(meter.BUDGET_PROVIDERS))
+        self.assertEqual(payload["budgets"]["monthly_total"], 150)
+        self.assertEqual(payload["runtimes"], list(meter.BUDGET_PROVIDERS))
+        self.assertEqual(payload["limits"], {"max_monthly_budget": meter.MAX_MONTHLY_BUDGET,
+                                             "min_session_budget": meter.MIN_SESSION_BUDGET})
+        self.assertNotIn("private-session-id", text)
+        self.assertNotIn("session_budgets", text)
+
+    def test_month_reports_spend_and_list_spend_from_served_state(self):
+        cross = {"budget": {"month": "2026-10", "spend": 70.0, "partial": True},
+                 "monthly": [{"month": "2026-10", "cost": 70.0, "discount_usd": 30.0}]}
+        with mock.patch.object(meter, "STATE", {"ok": True, "xsession": cross}):
+            payload = self.request("GET", "/api/v1/budgets")[1]
+        self.assertEqual(payload["month"], {"month": "2026-10", "spent": 70.0, "list_spent": 100.0,
+                                            "coverage_partial": True})
+
+    def test_partial_allocation_merge_keeps_other_runtimes_and_session_caps(self):
+        status, payload, _ = self.request("POST", "/api/v1/budgets", {"allocations": {"cursor": 25}},
+                                          client="budget-sync")
+        self.assertEqual(status, 200, payload)
+        self.assertTrue(payload["changed"])
+        self.assertEqual(payload["budgets"]["allocations"]["claude"], 100)
+        self.assertEqual(payload["budgets"]["allocations"]["cursor"], 25)
+        self.assertEqual(payload["budgets"]["monthly_total"], 175)
+        saved = self.saved()
+        self.assertEqual(saved["budgets"]["session_budgets"], {"private-session-id": 3.0})
+        self.assertEqual(saved["updates"], {"enabled": False})
+        self.refresh.assert_called_once_with()
+        self.assertEqual(self.request("GET", "/api/v1/budgets")[1]["revision"], payload["revision"])
+
+    def test_validation_messages(self):
+        cases = (
+            ({"allocations": {"claude": -1}}, "Claude allocation must be between 0 and 100,000,000."),
+            ({"allocations": {"claude": 200_000_000}}, "Claude allocation must be between 0 and 100,000,000."),
+            ({"allocations": {"gemini": 5}}, "Unknown runtime: gemini"),
+            ({"thresholds": [90, 80]}, "Use 1 to 10 unique budget thresholds in increasing order."),
+            ({"thresholds": [0]}, "Budget thresholds must be whole percentages from 1 to 100."),
+            ({"session_budgets": {"x": 1}}, "Unknown field: session_budgets"),
+            ({"monthly_total": 5}, "Unknown field: monthly_total"),
+            ({"native_notifications": "yes"}, "Budget notifications must be on or off."),
+        )
+        before = self.settings.read_text()
+        for body, message in cases:
+            with self.subTest(body=body):
+                status, payload, _ = self.request("POST", "/api/v1/budgets", body)
+                self.assertEqual((status, payload["error"]), (400, message))
+        self.assertEqual(self.settings.read_text(), before)
+        self.refresh.assert_not_called()
+
+    def test_stale_revision_conflicts_and_repeat_is_a_no_op(self):
+        stale = self.request("GET", "/api/v1/budgets")[1]["revision"]
+        first = self.request("POST", "/api/v1/budgets", {"thresholds": [50, 100]})[1]
+        status, conflict, _ = self.request("POST", "/api/v1/budgets", {
+            "expected_revision": stale, "thresholds": [60]})
+        self.assertEqual((status, conflict["revision"]), (409, first["revision"]))
+        mtime = self.settings.stat().st_mtime_ns
+        status, again, _ = self.request("POST", "/api/v1/budgets", {
+            "expected_revision": first["revision"], "thresholds": [50, 100]})
+        self.assertEqual((status, again["changed"], again["revision"]), (200, False, first["revision"]))
+        self.assertEqual(self.settings.stat().st_mtime_ns, mtime)
+        self.assertEqual(self.refresh.call_count, 1)
+
+    def test_budget_status_after_post_reflects_the_new_total(self):
+        with mock.patch.object(meter, "refresh_cross_session_state", _REAL_REFRESH), \
+                mock.patch.object(meter, "all_session_sources", return_value=[]), \
+                mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
+            self.request("POST", "/api/v1/budgets", {"allocations": {"claude": 400}})
+            budget = meter._xsess["data"]["budget"]
+            self.assertEqual(budget["budget"], 450)
+            self.assertTrue(budget["configured"])
+            month = self.request("GET", "/api/v1/budgets")[1]["month"]
+        self.assertEqual(month["spent"], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_daily_budgets.py b/tests/test_daily_budgets.py
new file mode 100644
index 00000000..10b731e8
--- /dev/null
+++ b/tests/test_daily_budgets.py
@@ -0,0 +1,620 @@
+import unittest
+import json
+import tempfile
+import threading
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class DailySummaryTests(unittest.TestCase):
+    def test_compare_sessions_state_projects_selected_sessions_without_content(self):
+        from token_meter.domain.compare import trace_key
+        pool = [
+            {"id": "one", "path": "/private/traces/ws/one/messages.jsonl", "provider": "kiro"},
+            {"id": "two", "path": "/private/traces/ws/two/messages.jsonl", "provider": "kiro"},
+            {"id": "root", "path": "/private/traces/rollout-9-root.jsonl", "provider": "codex"},
+        ]
+        key = {source["id"]: trace_key(source) for source in pool}
+
+        def summary(source):
+            return {
+                "id": source["id"], "path": source["path"], "title": "Same prompt",
+                "label": "Kiro", "provider": source["provider"], "models": ["m"],
+                "usage_basis": "reported", "availability": {"cost": True},
+            }
+
+        def state(source):
+            cost = 1.0 if source["id"] == "one" else 2.5
+            return {
+                "availability": {"cost": True, "tokens": True},
+                "total_cost": cost, "turns": 4, "total_tokens": 1000,
+                "timing": {"duration_s": 60, "duration_available": True},
+                "series": [{"i": 1, "cost": cost, "in": 10, "out": 5,
+                            "user_message": "PRIVATE PROMPT TEXT"}],
+                "source": {"path": source["path"]},
+            }
+
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["sessions"] = [
+                {"id": "one", "title": "Same prompt", "path": pool[0]["path"]},
+                {"id": "root", "title": "same prompt", "mtime": 5, "cost": 0.4, "path": pool[2]["path"]},
+                {"id": "four", "title": "Different", "path": "/private/traces/four.jsonl"},
+            ]
+            with mock.patch.object(meter, "cached_session_sources", return_value=(pool, True)), \
+                    mock.patch.object(meter, "session_summary", side_effect=summary), \
+                    mock.patch.object(meter, "cached_session_state", side_effect=state):
+                payload, status = meter.compare_sessions_state(f"{key['one']},{key['two']},tgone")
+                single, single_status = meter.compare_sessions_state(key["one"])
+                empty, empty_status = meter.compare_sessions_state("")
+                missing, missing_status = meter.compare_sessions_state("tgone,talsogone")
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(status, 200)
+        self.assertTrue(payload["ok"])
+        self.assertEqual([row["letter"] for row in payload["sessions"]], ["A", "B"])
+        self.assertEqual([row["id"] for row in payload["sessions"]], ["one", "two"])
+        # Repeated file names fall back to the session id; unique stems open the exact trace.
+        self.assertEqual([row["open_id"] for row in payload["sessions"]], ["one", "two"])
+        self.assertEqual(payload["missing"], ["tgone"])
+        self.assertTrue(payload["same_title"])
+        self.assertEqual(payload["best"]["cost"], key["one"])
+        self.assertEqual([row["key"] for row in payload["matches"]], [key["root"]])
+        self.assertEqual(payload["matches"][0]["open_id"], "rollout-9-root")
+        encoded = json.dumps(payload)
+        self.assertNotIn("PRIVATE PROMPT TEXT", encoded)
+        self.assertNotIn("/private/traces", encoded)
+        self.assertEqual(single_status, 200)
+        self.assertNotIn("insights", single)
+        self.assertNotIn("insights", payload)
+        self.assertEqual((empty_status, empty["ok"]), (400, False))
+        self.assertEqual((missing_status, missing["ok"]), (404, False))
+        self.assertIn(
+            'elif req_path == "/session/compare":',
+            Path(meter.IMPLEMENTATION_FILE).read_text(),
+        )
+        self.assertFalse(meter.is_dashboard_page_path("/session/compare"))
+
+    def test_spend_logs_state_validates_and_returns_full_range(self):
+        sessions = (
+            {
+                "id": "multi-day", "title": "Multi day", "project": "/repo/a",
+                "provider": "codex", "label": "Codex",
+                "availability": {"cost": True},
+                "input_tokens": 12000, "output_tokens": 600, "turns": 6,
+                "duration_s": 420, "duration_available": True,
+                "duration_basis": "observed", "token_estimate": True,
+                "_day_cost": {
+                    "2026-08-01": 1.25,
+                    "2026-08-02": 2.75,
+                    "2026-08-03": 8.0,
+                },
+            },
+            {
+                "id": "second", "title": "Second", "project": "/repo/b",
+                "provider": "claude", "label": "Claude",
+                "availability": {"cost": True},
+                "_day_cost": {"2026-08-02": 2.0},
+            },
+        )
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["internal_rows"] = sessions
+            with mock.patch.object(
+                meter, "cross_session", return_value={"generated_at": 123},
+            ):
+                payload, status = meter.spend_logs_state(
+                    "2026-08-01", "2026-08-02",
+                )
+                missing, missing_status = meter.spend_logs_state("", "2026-08-02")
+                malformed, malformed_status = meter.spend_logs_state(
+                    "2026-08-01", "not-a-date",
+                )
+                reversed_range, reversed_status = meter.spend_logs_state(
+                    "2026-08-03", "2026-08-02",
+                )
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(status, 200)
+        self.assertTrue(payload["ok"])
+        self.assertEqual(payload["generated_at"], 123)
+        self.assertEqual(payload["from"], "2026-08-01")
+        self.assertEqual(payload["to"], "2026-08-02")
+        self.assertEqual(payload["total_sessions"], 2)
+        self.assertEqual(payload["total_cost"], 6.0)
+        self.assertEqual(payload["sessions"][0]["id"], "multi-day")
+        self.assertEqual(payload["sessions"][0]["input_tokens"], 12000)
+        self.assertEqual(payload["sessions"][0]["output_tokens"], 600)
+        self.assertEqual(payload["sessions"][0]["turns"], 6)
+        self.assertEqual(payload["sessions"][0]["duration_s"], 420)
+        self.assertTrue(payload["sessions"][0]["duration_available"])
+        self.assertEqual(payload["sessions"][0]["duration_basis"], "observed")
+        self.assertEqual(payload["sessions"][0]["usage_basis"], "local_estimate")
+        for error, error_status in (
+            (missing, missing_status),
+            (malformed, malformed_status),
+            (reversed_range, reversed_status),
+        ):
+            self.assertEqual(error_status, 400)
+            self.assertFalse(error["ok"])
+        self.assertIn(
+            'elif req_path == "/spend/logs":',
+            Path(meter.IMPLEMENTATION_FILE).read_text(),
+        )
+
+    def test_aggregates_daily_spend_providers_and_logs(self):
+        sessions = [
+            {"id": "one", "title": "One", "project": "/repo/a", "provider": "codex",
+             "label": "Codex", "_day_cost": {"2026-07-01": 1.25},
+             "_wait_samples": [
+                 {"day": "2026-07-01", "duration_s": 20},
+                 {"day": "2026-07-01", "duration_s": 40},
+             ]},
+            {"id": "two", "title": "Two", "project": "/repo/b", "provider": "claude",
+             "label": "Claude Code", "_day_cost": {"2026-07-01": 0.75, "2026-06-30": 0.5},
+             "_wait_samples": [{"day": "2026-07-01", "duration_s": 30}]},
+        ]
+        days = meter.daily_summaries(sessions)
+        self.assertEqual(days[0]["day"], "2026-07-01")
+        self.assertEqual(days[0]["cost"], 2.0)
+        self.assertEqual(days[0]["sessions"], 2)
+        self.assertEqual(days[0]["projects"], 2)
+        self.assertNotIn("tool_tokens", days[0])
+        self.assertNotIn("flagged_tokens", days[0])
+        provider = days[0]["providers"][0]
+        self.assertEqual(provider["provider"], "codex")
+        self.assertEqual(provider["cost"], 1.25)
+        self.assertEqual(provider["wait_s"], 60.0)
+        self.assertEqual(provider["wait_samples"], 2)
+        self.assertEqual(provider["usage_basis"], "reported")
+        self.assertEqual(days[0]["wait_time"]["total_s"], 90)
+        self.assertEqual(days[0]["wait_time"]["avg_s"], 30)
+        self.assertEqual(days[0]["wait_time"]["max_s"], 40)
+
+    def test_unbounded_daily_history_has_compact_spend_projection(self):
+        sessions = [{
+            "id": "one", "title": "Private title", "project": "/private/repo",
+            "provider": "codex", "label": "Codex",
+            "_day_cost": {
+                f"2026-07-{day:02d}": float(day) for day in range(1, 32)
+            },
+        }]
+        legacy = meter.daily_summaries(sessions)
+        complete = meter.daily_summaries(sessions, limit=None)
+        spend = meter.spend_projection(complete)
+        self.assertEqual(len(legacy), 30)
+        self.assertEqual(len(complete), 31)
+        self.assertEqual(spend[0]["day"], "2026-07-31")
+        self.assertEqual(spend[0]["providers"][0]["provider"], "codex")
+        self.assertEqual(spend[0]["providers"][0]["cost"], 31.0)
+        self.assertEqual(
+            set(spend[0]),
+            {"day", "cost", "providers", "coverage", "provenance",
+             "usage_basis", "availability"},
+        )
+        serialized = json.dumps(spend)
+        self.assertNotIn("Private title", serialized)
+        self.assertNotIn("/private/repo", serialized)
+        self.assertNotIn("top_sessions", serialized)
+
+    def test_cross_session_publishes_spend_history_and_keeps_daily(self):
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess.update({"data": None, "at": 0, "sessions": []})
+            result = meter.cross_session(sources=[])
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertEqual(result["spend"], {"days": []})
+        self.assertEqual(result["daily"], [])
+
+
+class MonthlyBudgetTests(unittest.TestCase):
+    def test_budget_settings_persist_session_overrides_without_changing_defaults(self):
+        """A session cap survives settings writes and remains distinct from its default."""
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            result = meter.set_budget_settings({
+                "default_session_budget": 10,
+                "session_budgets": {"session-1": 25.5},
+                "allocations": {},
+                "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            }, str(path))
+            stored = json.loads(path.read_text())
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["budgets"].get("default_session_budget"), 10.0)
+        self.assertEqual(result["budgets"].get("session_budgets"), {"session-1": 25.5})
+        self.assertEqual(stored["budgets"].get("session_budgets"), {"session-1": 25.5})
+
+    def test_general_budget_save_preserves_existing_session_overrides(self):
+        """The Settings form must not erase caps it does not display or submit."""
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            meter.set_session_budget_override("session-1", 25, path=str(path))
+            result = meter.set_budget_settings({
+                "default_session_budget": 12,
+                "allocations": {},
+                "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            }, str(path))
+            stored = json.loads(path.read_text())
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(stored["budgets"]["default_session_budget"], 12.0)
+        self.assertEqual(stored["budgets"]["session_budgets"], {"session-1": 25.0})
+
+    def test_concurrent_session_compare_and_set_allows_one_writer(self):
+        """Competing confirmed writes must serialize to success plus stale response."""
+        with tempfile.TemporaryDirectory() as tmp:
+            path = str(Path(tmp) / "settings.json")
+            ready = threading.Barrier(2)
+            results = []
+
+            def change(budget):
+                ready.wait()
+                results.append(meter.set_session_budget_override(
+                    "session-1", budget, expected_current_budget_usd=10, path=path,
+                ))
+
+            first = threading.Thread(target=change, args=(12,))
+            second = threading.Thread(target=change, args=(15,))
+            first.start()
+            second.start()
+            first.join()
+            second.join()
+
+        self.assertEqual(sum(result["ok"] for result in results), 1)
+        self.assertEqual(sum("changed" in result.get("error", "") for result in results), 1)
+
+    def test_default_session_budget_compare_and_set_rejects_a_stale_budget(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = str(Path(tmp) / "settings.json")
+            first = meter.set_default_session_budget_value(
+                12, expected_current_budget_usd=10, path=path,
+            )
+            stale = meter.set_default_session_budget_value(
+                15, expected_current_budget_usd=10, path=path,
+            )
+
+        self.assertTrue(first["ok"])
+        self.assertFalse(stale["ok"])
+        self.assertIn("changed", stale["error"])
+
+    def test_agent_budget_projection_excludes_unrequested_global_configuration(self):
+        source = {"id": "session-1", "provider": "codex", "client": "Codex"}
+        state = {"total_cost": 3, "availability": {"cost": True}}
+        settings = meter.normalize_budget_settings({
+            "default_session_budget": 10,
+            "session_budgets": {"session-1": 5},
+            "allocations": {}, "thresholds": [80, 90, 100],
+            "native_notifications": True,
+        })
+        with mock.patch.object(meter, "resolve_agent_source", return_value=(source, "explicit")), \
+                mock.patch.object(meter, "recompute", return_value=state), \
+                mock.patch.object(meter, "budget_settings", return_value=settings):
+            result = meter.agent_budget(session_id="session-1")
+
+        self.assertEqual(result["session"]["budget_usd"], 5)
+        self.assertNotIn("default_session_budget_usd", result)
+        self.assertNotIn("session_budget_overrides", result)
+        self.assertNotIn("lower bound", result["caveat"])
+
+    def test_agent_budget_caveat_marks_partial_family_spend_as_lower_bound(self):
+        source = {"id": "ses_root", "provider": "opencode", "client": "OpenCode"}
+        state = {"total_cost": 1.0, "availability": {"cost": True}}
+        family = [
+            {"id": "ses_root", "provider": "opencode", "cost": 1.0,
+             "availability": {"cost": True}},
+            {"id": "ses_child", "provider": "opencode", "cost": 0.0,
+             "is_child_session": True, "root_session_id": "ses_root",
+             "availability": {"cost": False}},
+        ]
+        settings = meter.normalize_budget_settings({})
+        with mock.patch.object(meter, "resolve_agent_source", return_value=(source, "explicit")), \
+                mock.patch.object(meter, "recompute", return_value=state), \
+                mock.patch.object(meter, "budget_settings", return_value=settings), \
+                mock.patch.dict(meter._xsess, {"sessions": family}):
+            result = meter.agent_budget(session_id="ses_root")
+
+        self.assertTrue(result["session"]["cost_partial"])
+        self.assertIn("Spend is a lower bound", result["caveat"])
+
+    def test_session_override_compare_and_set_rejects_a_stale_budget(self):
+        """A delayed agent must not silently replace a newer session cap."""
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            first = meter.set_session_budget_override(
+                "session-1", 12, expected_current_budget_usd=10, path=str(path),
+            )
+            stale = meter.set_session_budget_override(
+                "session-1", 15, expected_current_budget_usd=10, path=str(path),
+            )
+            effective, source = meter.effective_session_budget(
+                "session-1", meter.budget_settings(str(path)),
+            )
+
+        self.assertTrue(first["ok"])
+        self.assertFalse(stale["ok"])
+        self.assertIn("changed", stale["error"])
+        self.assertEqual((effective, source), (12.0, "session_override"))
+
+    def test_missing_default_session_budget_migrates_to_ten(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({
+                "budgets": {
+                    "currency": "USD",
+                    "allocations": {},
+                    "thresholds": [80, 90, 100],
+                    "native_notifications": True,
+                },
+            }))
+
+            loaded = meter.budget_settings(str(path))
+
+        self.assertEqual(loaded.get("default_session_budget"), 10)
+
+    def test_default_session_budget_is_validated_and_persisted(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"model_pricing": {"claude": {}}}))
+            too_small = meter.set_budget_settings({
+                "default_session_budget": 0,
+                "allocations": {},
+                "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            }, str(path))
+            result = meter.set_budget_settings({
+                "default_session_budget": 25.5,
+                "allocations": {},
+                "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            }, str(path))
+            stored = json.loads(path.read_text())
+
+        self.assertFalse(too_small["ok"])
+        self.assertIn("Default session budget", too_small["error"])
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["budgets"]["default_session_budget"], 25.5)
+        self.assertEqual(stored["budgets"]["default_session_budget"], 25.5)
+        self.assertIn("model_pricing", stored)
+
+    def test_settings_derive_total_from_allocations_and_preserve_other_machine_settings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"model_pricing": {"claude": {}}}))
+            invalid = meter.set_budget_settings({
+                "allocations": {"claude": 60_000_000, "codex": 50_000_000},
+                "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            }, str(path))
+            result = meter.set_budget_settings({
+                "allocations": {"claude": 50, "codex": 30, "cursor": 0},
+                "thresholds": [75, 90, 100],
+                "native_notifications": False,
+            }, str(path))
+            stored = json.loads(path.read_text())
+        self.assertFalse(invalid["ok"])
+        self.assertTrue(result["ok"])
+        self.assertEqual(stored["budgets"]["monthly_total"], 80)
+        self.assertEqual(
+            stored["budgets"]["allocations"],
+            {"claude": 50, "codex": 30, "cursor": 0, "opencode": 0, "kiro": 0, "pi": 0, "hermes": 0, "agy": 0},
+        )
+        self.assertIn("model_pricing", stored)
+
+    def test_missing_runtime_budgets_default_to_zero_and_explicit_values_are_preserved(self):
+        legacy = {
+            "currency": "USD",
+            "monthly_total": 100,
+            "allocations": {},
+            "thresholds": [80, 90, 100],
+            "native_notifications": True,
+        }
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"budgets": legacy}))
+            loaded = meter.budget_settings(str(path))
+            saved = meter.set_budget_settings({
+                "allocations": {"claude": 0, "codex": 1490, "cursor": 0},
+                "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            }, str(path))
+        self.assertEqual(loaded["monthly_total"], 0)
+        self.assertEqual(
+            loaded["allocations"],
+            {"claude": 0, "codex": 0, "cursor": 0, "opencode": 0, "kiro": 0, "pi": 0, "hermes": 0, "agy": 0},
+        )
+        self.assertTrue(saved["ok"])
+        self.assertEqual(saved["budgets"]["monthly_total"], 1490)
+        self.assertEqual(
+            saved["budgets"]["allocations"],
+            {"claude": 0, "codex": 1490, "cursor": 0, "opencode": 0, "kiro": 0, "pi": 0, "hermes": 0, "agy": 0},
+        )
+
+    def test_monthly_rollup_keeps_runtime_costs_and_partial_coverage(self):
+        sessions = [
+            {
+                "id": "reported", "provider": "claude",
+                "_day_cost": {"2026-07-01": 20, "2026-07-03": 10},
+                "_model_daily": [{"day": "2026-07-01"}],
+                "availability": {"cost": True},
+            },
+            {
+                "id": "estimated", "provider": "cursor", "token_estimate": True,
+                "_day_cost": {"2026-07-02": 5},
+                "_model_daily": [{"day": "2026-07-02"}],
+                "availability": {"cost": True},
+            },
+            {
+                "id": "missing", "provider": "codex",
+                "_model_daily": [{"day": "2026-07-04"}],
+                "availability": {"cost": False},
+            },
+        ]
+        rows = meter.monthly_summaries(sessions)
+        self.assertEqual(rows[0]["month"], "2026-07")
+        self.assertEqual(rows[0]["cost"], 35)
+        self.assertEqual(rows[0]["active_days"], 3)
+        self.assertEqual(rows[0]["sessions"], 3)
+        self.assertFalse(rows[0]["coverage"]["cost"]["complete"])
+        self.assertEqual(rows[0]["provenance"]["estimated_cost"], 5)
+        self.assertEqual(
+            {row["provider"]: row["cost"] for row in rows[0]["providers"]},
+            {"claude": 30, "cursor": 5, "codex": 0},
+        )
+
+    def test_budget_status_projects_after_three_spend_days_and_marks_lower_bound(self):
+        months = [{
+            "month": "2026-07", "cost": 60, "active_days": 3, "observed_days": 4,
+            "providers": [
+                {"provider": "claude", "cost": 40},
+                {"provider": "codex", "cost": 20},
+            ],
+            "coverage": {"cost": {
+                "covered_sessions": 2, "total_sessions": 3, "complete": False,
+            }},
+            "provenance": {
+                "estimated_sessions": 0, "estimated_cost": 0,
+                "usage_basis": "reported",
+            },
+        }]
+        status = meter.monthly_budget_status(months, {
+            "allocations": {"claude": 50, "codex": 30, "cursor": 0},
+            "thresholds": [50, 80, 100],
+            "native_notifications": True,
+        }, now=meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc))
+        self.assertEqual(status["spend"], 60)
+        self.assertEqual(status["budget"], 80)
+        self.assertEqual(status["remaining"], 20)
+        self.assertEqual(status["unallocated"], 0)
+        self.assertAlmostEqual(status["projected_spend"], 186)
+        self.assertTrue(status["lower_bound"])
+        self.assertEqual(status["thresholds_crossed"], [50])
+        self.assertEqual(status["next_threshold"], 80)
+        claude = next(row for row in status["runtimes"] if row["provider"] == "claude")
+        self.assertEqual(claude["percent"], 0.8)
+
+    def test_antigravity_character_estimates_are_shown_but_do_not_drive_alerts(self):
+        def month(agy_estimated_cost):
+            return [{
+                "month": "2026-07", "cost": 110, "active_days": 4,
+                "providers": [
+                    {"provider": "agy", "cost": 90,
+                     "provenance": {"estimated_sessions": 1, "estimated_cost": agy_estimated_cost}},
+                    {"provider": "codex", "cost": 20, "provenance": {"estimated_sessions": 0}},
+                ],
+                "coverage": {"cost": {"covered_sessions": 2, "total_sessions": 2, "complete": True}},
+                "provenance": {"estimated_sessions": 1},
+            }]
+
+        settings = {
+            "allocations": {"agy": 50, "codex": 50},
+            "thresholds": [50, 80, 100],
+            "native_notifications": True,
+        }
+        now = meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc)
+        estimated = meter.monthly_budget_status(month(80), settings, now=now)
+        measured = meter.monthly_budget_status(month(0), settings, now=now)
+
+        # The budget card shows the full spend, estimates included.
+        self.assertEqual(estimated["spend"], 110)
+        self.assertAlmostEqual(estimated["percent"], 1.1)
+        agy = next(row for row in estimated["runtimes"] if row["provider"] == "agy")
+        self.assertEqual(agy["spend"], 90)
+        # Alerts are measured without the character estimates.
+        self.assertEqual(estimated["alert_excluded_spend"], 80)
+        self.assertAlmostEqual(estimated["alert_percent"], 0.3)
+        self.assertAlmostEqual(agy["alert_percent"], 0.2)
+        self.assertEqual(estimated["thresholds_crossed"], [])
+        # Everything on the card follows the full spend shown.
+        self.assertEqual(estimated["state"], "over")
+        self.assertIsNone(estimated["next_threshold"])
+        self.assertEqual([row["provider"] for row in estimated["exceeded_runtimes"]], ["agy"])
+        self.assertEqual(measured["alert_excluded_spend"], 0)
+        self.assertAlmostEqual(measured["alert_percent"], 1.1)
+        self.assertEqual(measured["thresholds_crossed"], [50, 80, 100])
+
+    def test_shown_spend_drives_the_warning_state_while_notifications_wait(self):
+        months = [{
+            "month": "2026-07", "cost": 60, "active_days": 4,
+            "providers": [
+                {"provider": "agy", "cost": 40,
+                 "provenance": {"estimated_sessions": 1, "estimated_cost": 40}},
+                {"provider": "codex", "cost": 20, "provenance": {"estimated_sessions": 0}},
+            ],
+            "coverage": {"cost": {"covered_sessions": 2, "total_sessions": 2, "complete": True}},
+            "provenance": {"estimated_sessions": 1},
+        }]
+        status = meter.monthly_budget_status(months, {
+            "allocations": {"agy": 50, "codex": 50},
+            "thresholds": [50, 80, 100],
+            "native_notifications": True,
+        }, now=meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc))
+
+        self.assertEqual(status["state"], "warning")
+        self.assertEqual(status["thresholds_crossed"], [])
+        self.assertEqual(status["next_threshold"], 80)
+
+    def test_runtime_overrun_is_reported_while_overall_budget_is_on_track(self):
+        months = [{
+            "month": "2026-07", "cost": 1501, "active_days": 4,
+            "providers": [{"provider": "codex", "cost": 1501}],
+            "coverage": {"cost": {
+                "covered_sessions": 1, "total_sessions": 1, "complete": True,
+            }},
+            "provenance": {"estimated_sessions": 0},
+        }]
+        status = meter.monthly_budget_status(months, {
+            "allocations": {"claude": 1000, "codex": 1490, "cursor": 1000},
+            "thresholds": [80, 90, 100],
+            "native_notifications": True,
+        }, now=meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc))
+        self.assertEqual(status["state"], "on_track")
+        self.assertTrue(status["runtime_exceeded"])
+        self.assertTrue(status["attention"])
+        self.assertEqual(len(status["exceeded_runtimes"]), 1)
+        self.assertEqual(status["exceeded_runtimes"][0]["provider"], "codex")
+        self.assertEqual(status["exceeded_runtimes"][0]["over_by"], 11)
+        codex = next(row for row in status["runtimes"] if row["provider"] == "codex")
+        self.assertTrue(codex["exceeded"])
+
+
+class McpDocumentationContractTests(unittest.TestCase):
+    def test_maintained_docs_describe_the_read_only_query_surface(self):
+        root = Path(__file__).resolve().parents[1]
+        documents = {
+            path: (root / path).read_text()
+            for path in (
+                "README.md",
+                "specs/USER_GUIDE.md",
+                "specs/ARCHITECTURE.md",
+                "specs/SECURITY.md",
+            )
+        }
+        for path, content in documents.items():
+            with self.subTest(path=path):
+                self.assertIn("read-only", content.lower())
+                for tool in ("sessions", "trace", "stats", "schema"):
+                    self.assertIn(tool, content)
+                self.assertIn("not raw trace content", content.lower())
+
+        combined = "\n".join(documents.values()).lower()
+        for prohibited_claim in (
+            "returns raw prompts",
+            "returns raw responses",
+            "raw tool payloads are available",
+            "trace paths are available",
+        ):
+            self.assertNotIn(prohibited_claim, combined)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_contracts.py b/tests/test_dashboard_contracts.py
new file mode 100644
index 00000000..3de8777d
--- /dev/null
+++ b/tests/test_dashboard_contracts.py
@@ -0,0 +1,705 @@
+import unittest
+import datetime
+import http.client
+import json
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+
+
+class ToolUsageEvidenceRealityTests(unittest.TestCase):
+    """Tools-tab usage evidence must match what the raw traces contain."""
+
+    @staticmethod
+    def inventory(waste, *, codex_mcp=None, claude_mcp=None, skills=None):
+        with mock.patch.object(meter, "codex_mcp_states", return_value=codex_mcp or {}), \
+                mock.patch.object(meter, "claude_mcp_states", return_value=claude_mcp or {}), \
+                mock.patch.object(meter, "discovered_skills",
+                                  side_effect=lambda usage=None: [dict(row) for row in (skills or [])]), \
+                mock.patch.object(meter, "claude_desktop_index", return_value={}), \
+                mock.patch.object(meter, "claude_local_agent_sources", return_value=[]):
+            return meter.capability_inventory(waste)
+
+    @staticmethod
+    def codex_exec(code, call_id="exec-1"):
+        return {"timestamp": "2026-10-01T00:00:00.000Z", "payload": {
+            "type": "custom_tool_call", "name": "exec", "call_id": call_id, "input": code,
+        }}
+
+    def test_codex_exec_records_nested_mcp_and_app_tool_calls(self):
+        code = (
+            "const a = await tools.mcp__sharepoint__search({q: 'x'});\n"
+            "await tools.mcp__sharepoint__search({q: 'y'});\n"
+            "await tools.codex_app__load_workspace_dependencies({});\n"
+            "await tools.exec_command({cmd: 'ls'});\n"
+            "await tools.web__run({q: 'z'});\n"
+        )
+        calls = meter.codex_tool_call_evidence([self.codex_exec(code)])
+        nested = {row["name"]: row for row in calls if row.get("nested")}
+        self.assertEqual(
+            set(nested),
+            {"mcp__sharepoint__search", "mcp__codex_app__load_workspace_dependencies"},
+        )
+        self.assertEqual(nested["mcp__sharepoint__search"]["kind"], "mcp")
+        self.assertEqual(nested["mcp__sharepoint__search"]["namespace"], "sharepoint")
+        evidence = meter.summarize_tool_evidence(calls)
+        rows = {row["name"]: row for row in evidence["tools"]}
+        self.assertEqual(rows["mcp__sharepoint__search"]["calls"], 2)
+        self.assertEqual(rows["exec"]["calls"], 1)
+        self.assertEqual(evidence["total_calls"], 1)
+
+    def test_codex_app_namespace_keeps_one_canonical_identity(self):
+        from token_meter.runtimes.codex import codex_mcp_tool_name
+        self.assertEqual(
+            codex_mcp_tool_name("read_thread", "codex_app"), "mcp__codex_app__read_thread",
+        )
+        self.assertEqual(
+            codex_mcp_tool_name("read_thread", "mcp__codex_app"), "mcp__codex_app__read_thread",
+        )
+        for builtin in ("collaboration", "clock", "web", "multi_agent_v1"):
+            self.assertEqual(codex_mcp_tool_name("wait_agent", builtin), "wait_agent")
+
+    def test_codex_dynamic_catalog_matches_code_mode_calls(self):
+        from token_meter.runtimes.codex import _catalog
+        catalog = _catalog([
+            {"name": "codex_app", "tools": [
+                {"name": "wait_threads", "description": "wait"},
+                {"name": "share_thread", "description": "share"},
+            ]},
+            {"name": "exec_command", "description": "flat"},
+        ])
+        names = {row["name"]: row for row in catalog}
+        normalized = meter.normalize_dynamic_tools([
+            {"name": "codex_app", "tools": [{"name": "wait_threads"}]},
+            {"name": "exec_command"},
+        ])
+        self.assertEqual(
+            [(row["name"], row["kind"]) for row in normalized],
+            [("mcp__codex_app__wait_threads", "mcp"), ("exec_command", "tool")],
+        )
+        self.assertIn("mcp__codex_app__wait_threads", names)
+        self.assertEqual(names["mcp__codex_app__wait_threads"]["kind"], "mcp")
+        self.assertEqual(names["mcp__codex_app__wait_threads"]["namespace"], "codex_app")
+        self.assertIn("exec_command", names)
+        calls = meter.codex_tool_call_evidence([
+            self.codex_exec("await tools.mcp__codex_app__wait_threads({});"),
+        ])
+        evidence = meter.summarize_tool_evidence(calls, catalog)
+        share = names["mcp__codex_app__share_thread"]["definition_tokens"]
+        flat = names["exec_command"]["definition_tokens"]
+        self.assertEqual(evidence["unused_eager_definition_tokens"], share + flat)
+
+    def test_duplicated_claude_transcript_copies_count_each_tool_once(self):
+        def assistant(block_id, name="mcp__workspace__bash"):
+            return {
+                "type": "assistant", "timestamp": "2026-10-01T00:00:00Z",
+                "message": {"id": "msg-1", "usage": {"output_tokens": 5}, "content": [
+                    {"type": "tool_use", "id": block_id, "name": name, "input": {}},
+                ]},
+            }
+        objs = [assistant("tool-1"), assistant("tool-1"), assistant("tool-2")]
+        calls = meter.claude_tool_call_evidence(objs)
+        self.assertEqual(len(calls), 2)
+
+    def test_claude_tool_rows_keep_their_own_runtime(self):
+        call = {**meter.tool_identity("Bash"), "output_tokens": 1, "ts": 100,
+                "args_fingerprint": "x", "error": False}
+        rows = [
+            {"id": "a", "provider": "claude", "runtime": "Claude-3P", "project": "/r",
+             "_tool_evidence": meter.summarize_tool_evidence([call])},
+            {"id": "b", "provider": "claude", "runtime": "Claude Code", "project": "/r",
+             "_tool_evidence": meter.summarize_tool_evidence([call, call])},
+        ]
+        waste = meter.global_tool_waste(rows)
+        bash = {row["runtime"]: row["calls"] for row in waste["inventory_tools"]
+                if row["name"] == "Bash"}
+        self.assertEqual(bash, {"Claude-3P": 1, "Claude Code": 2})
+
+    def test_desktop_code_tab_sessions_cover_claude_plugin_packs(self):
+        skill = {
+            "id": "skill:claude:custom@personal:custom", "name": "custom",
+            "runtime": "Claude", "source": "User-installed plugin",
+            "plugin_id": "custom@personal", "mutable": True, "enabled": True,
+            "used": False, "reviewable": True, "measurement": "measurable",
+            "unmeasurable": False, "activations": 0, "last_used": "Never",
+            "setting_path": "~/.claude/settings.json",
+        }
+        code_tab = os.path.join(meter.CLAUDE_PROJECTS, "-repo", "session.jsonl")
+        cowork = "/tmp/Claude-3p/local-agent-mode-sessions/x/.claude/projects/s/a.jsonl"
+        waste = meter.global_tool_waste([
+            {"id": "tab", "provider": "claude", "runtime": "Claude-3P",
+             "path": code_tab, "project": "/r", "_tool_evidence": {}},
+            {"id": "cli", "provider": "claude", "runtime": "Claude Code",
+             "path": code_tab.replace("session", "cli"), "project": "/r", "_tool_evidence": {}},
+            {"id": "cowork", "provider": "claude", "runtime": "Claude-3P",
+             "path": cowork, "project": "/r", "_tool_evidence": {}},
+        ])
+        capabilities = self.inventory(waste, skills=[skill])
+        self.assertEqual(capabilities["control_groups"][0]["scanned_sessions"], 2)
+
+    def test_skill_activations_stay_with_the_runtime_that_used_them(self):
+        evidence = meter.summarize_tool_evidence([{
+            **meter.tool_identity("exec"), "output_tokens": 0, "ts": 100,
+            "args_fingerprint": "x", "error": False, "skills": ["brainstorming"],
+        }])
+        cowork = "/tmp/Claude-3p/local-agent-mode-sessions/x/.claude/projects/s/a.jsonl"
+        waste = meter.global_tool_waste([
+            {"id": "codex", "provider": "codex", "runtime": "Codex", "project": "/r",
+             "path": "/tmp/codex.jsonl", "_tool_evidence": evidence},
+            {"id": "cowork", "provider": "claude", "runtime": "Claude-3P", "project": "/r",
+             "path": cowork, "_tool_evidence": evidence},
+        ])
+        rows = [
+            {"name": "brainstorming", "runtime": "Codex", "measurement": "measurable"},
+            {"name": "brainstorming", "runtime": "Claude", "measurement": "measurable"},
+            {"name": "brainstorming", "runtime": "Claude Desktop", "measurement": "measurable"},
+        ]
+        meter.invalidate_discovered_skill_cache()
+        try:
+            with mock.patch.object(meter, "_scan_discovered_skills", return_value=rows):
+                skills = meter.discovered_skills(waste["skills"])
+        finally:
+            meter.invalidate_discovered_skill_cache()
+        used = {row["runtime"]: row["activations"] for row in skills}
+        self.assertEqual(used, {"Codex": 1, "Claude": 0, "Claude Desktop": 1})
+
+    def test_skill_usage_is_not_truncated_and_rejects_template_names(self):
+        self.assertEqual(
+            meter.skill_names_from_value(
+                "cat skills/${n}/SKILL.md skills/{name}/SKILL.md "
+                "skills/token-meter-*/SKILL.md skills/docx/SKILL.md"
+            ),
+            ["docx"],
+        )
+        calls = [{**meter.tool_identity("exec"), "output_tokens": 0, "ts": 100,
+                  "args_fingerprint": str(index), "error": False,
+                  "skills": [f"skill-{index:03d}"]} for index in range(120)]
+        waste = meter.global_tool_waste([{
+            "id": "codex", "provider": "codex", "runtime": "Codex", "project": "/r",
+            "_tool_evidence": meter.summarize_tool_evidence(calls),
+        }])
+        self.assertEqual(len(waste["skills"]), 120)
+
+    def test_mcp_without_configuration_is_not_reported_disabled(self):
+        waste = {"inventory_tools": [{
+            "id": "mcp__workspace__bash", "name": "mcp__workspace__bash",
+            "display": "bash", "kind": "mcp", "namespace": "workspace",
+            "mcp_server": "workspace", "runtime": "Claude-3P", "providers": ["claude"],
+            "calls": 9, "output_tokens": 10, "last_ts": 100, "last_used": "2026-10-01",
+        }]}
+        row = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
+        self.assertEqual(row["configuration"], "Not in config")
+        self.assertEqual(row["state"], "Not in config")
+        self.assertIsNone(row["enabled"])
+        self.assertEqual(row["runtime"], "Claude")
+
+    def test_codex_host_tool_groups_are_not_mcp_disable_candidates(self):
+        from token_meter.domain.tools import session_capabilities
+        catalog = meter.normalize_dynamic_tools([
+            {"name": "codex_app", "tools": [{"name": "navigate_to_codex_page"}]},
+            {"name": "plugin_management", "tools": [{"name": "uninstall_plugin"}]},
+        ])
+        self.assertTrue(all(row.get("host_provided") for row in catalog))
+        rows = [{
+            "id": f"s{index}", "provider": "codex", "runtime": "Codex", "project": "/r",
+            "path": f"/tmp/s{index}.jsonl",
+            "_tool_evidence": meter.summarize_tool_evidence([], catalog),
+        } for index in range(6)]
+        waste = meter.global_tool_waste(rows)
+        self.assertEqual(
+            [row["name"] for row in waste["inventory_tools"] if row["recommendation"] == "disable"],
+            [],
+        )
+        self.assertNotIn("MCP disable candidate", [row.get("title") for row in waste["insights"]])
+        self.assertEqual(
+            session_capabilities(rows[0]["_tool_evidence"])["mcp_servers"],
+            {"loaded": None, "used": 0},
+        )
+        items = self.inventory(waste)["items"]
+        self.assertEqual([row["name"] for row in items if row["type"] == "mcp"], [])
+        tools = {row["identity"]: row for row in items if row["type"] == "tool"}
+        self.assertEqual(tools["mcp__codex_app__navigate_to_codex_page"]["runtime"], "Codex")
+
+    def test_codex_host_tool_group_calls_are_host_provided(self):
+        calls = meter.codex_tool_call_evidence([
+            self.codex_exec("await tools.mcp__codex_app__wait_threads({});"),
+            {"timestamp": "2026-10-01T00:00:01Z", "payload": {
+                "type": "function_call", "name": "read_thread", "namespace": "codex_app",
+                "call_id": "c2", "arguments": "{}",
+            }},
+        ])
+        hosted = {row["name"]: row.get("host_provided") for row in calls if row["kind"] == "mcp"}
+        self.assertEqual(hosted, {
+            "mcp__codex_app__wait_threads": True, "mcp__codex_app__read_thread": True,
+        })
+
+    def test_advertised_only_mcp_has_runtime_and_no_call_claim(self):
+        catalog = [{"name": "mcp__jira__search", "namespace": "jira", "kind": "mcp",
+                    "defer_loading": True, "definition_tokens": 10}]
+        waste = meter.global_tool_waste([{
+            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
+            "_tool_evidence": meter.summarize_tool_evidence([], catalog),
+        }])
+        row = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
+        self.assertEqual((row["name"], row["runtime"], row["calls"]), ("jira", "Codex", 0))
+        script = Path(DASHBOARD_PAGE).read_text()
+        self.assertIn("Advertised in traces; not in Codex or Claude config", script)
+
+    def test_nested_calls_are_daily_and_labelled_as_call_sites(self):
+        calls = meter.codex_tool_call_evidence([
+            self.codex_exec("await tools.mcp__sharepoint__search({});"),
+        ])
+        evidence = meter.summarize_tool_evidence(calls)
+        row = next(item for item in evidence["tools"] if item["name"] == "mcp__sharepoint__search")
+        self.assertEqual(row["nested_calls"], 1)
+        self.assertEqual([day["calls"] for day in row["daily"]], [1])
+        waste = meter.global_tool_waste([{
+            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
+            "_tool_evidence": evidence,
+        }])
+        mcp = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
+        self.assertEqual(mcp["nested_calls"], 1)
+        script = Path(DASHBOARD_PAGE).read_text()
+        self.assertIn("code-mode call site", script)
+
+    def test_host_tools_keep_non_disable_advice(self):
+        call = {**meter.tool_identity("mcp__codex_app__read_thread"), "output_tokens": 30000,
+                "ts": 100, "args_fingerprint": "x", "error": False, "host_provided": True}
+        waste = meter.global_tool_waste([{
+            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
+            "_tool_evidence": meter.summarize_tool_evidence([call]),
+        }])
+        row = next(item for item in waste["inventory_tools"]
+                   if item["name"] == "mcp__codex_app__read_thread")
+        self.assertEqual(row["recommendation"], "narrow_results")
+
+    def test_host_tools_get_no_project_scope_advice(self):
+        def call(index):
+            return {**meter.tool_identity("mcp__codex_app__wait_threads"), "output_tokens": 1,
+                    "ts": 100 + index, "args_fingerprint": str(index), "error": False,
+                    "host_provided": True}
+        waste = meter.global_tool_waste([{
+            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
+            "_tool_evidence": meter.summarize_tool_evidence([call(i) for i in range(6)]),
+        }])
+        row = next(item for item in waste["inventory_tools"]
+                   if item["name"] == "mcp__codex_app__wait_threads")
+        self.assertEqual(row["recommendation"], "keep")
+        self.assertEqual(row["reason"], "Provided by the runtime itself; not a configurable MCP server.")
+
+    def test_session_catalog_host_groups_are_not_used_mcp_servers(self):
+        from token_meter.domain.tools import session_capabilities
+        catalog = meter.normalize_dynamic_tools([
+            {"name": "newapp", "tools": [{"name": "open"}]},
+        ])
+        evidence = meter.summarize_tool_evidence(meter.codex_tool_call_evidence([
+            self.codex_exec("await tools.mcp__newapp__open({});"),
+        ]), catalog)
+        self.assertEqual(
+            session_capabilities(evidence)["mcp_servers"], {"loaded": None, "used": 0},
+        )
+
+    def test_builder_recap_tool_total_excludes_code_mode_call_sites(self):
+        from token_meter.domain.builder_recap import _period_rollup
+        evidence = meter.summarize_tool_evidence(meter.codex_tool_call_evidence([
+            self.codex_exec("await tools.mcp__sharepoint__search({});"),
+        ]))
+        day = datetime.date.fromtimestamp(evidence["tools"][0]["last_ts"] or 1790812800)
+        rollup = _period_rollup([{
+            "id": "s", "provider": "codex", "runtime": "Codex", "_tool_evidence": evidence,
+        }], day, day)
+        self.assertEqual(rollup["tool_calls"], 1)
+        self.assertEqual(sorted(rollup["tools"].values()), [1, 1])
+
+    def test_codex_multi_part_mcp_namespace_keeps_server(self):
+        from token_meter.runtimes.codex import codex_mcp_tool_name
+        self.assertEqual(codex_mcp_tool_name("x", "mcp__a__b"), "mcp__a__x")
+        self.assertEqual(codex_mcp_tool_name("x", "foo__bar"), "x")
+
+    def test_tools_page_renders_unconfigured_mcp_without_off_claims(self):
+        script = Path(DASHBOARD_PAGE).read_text()
+        start = script.index("function capabilityConfigurationText(row){")
+        body = script[start:script.index("\n}", start)]
+        self.assertNotIn("row.enabled?'Enabled':'Disabled'", body.replace(" ", ""))
+        self.assertIn("row.configured===false", script)
+        for handler in ("$('c-type-filter').onclick", "$('c-state-filter').onclick"):
+            line = script[script.index(handler):].split("\n", 1)[0]
+            self.assertIn("paintCapabilityFilters()", line)
+
+    def test_codex_sanitized_mcp_names_match_configured_server(self):
+        waste = {"inventory_tools": [{
+            "id": "mcp__ghost_mcp_proxy__slack", "name": "mcp__ghost_mcp_proxy__slack",
+            "display": "slack", "kind": "mcp", "namespace": "ghost_mcp_proxy",
+            "mcp_server": "ghost_mcp_proxy", "runtime": "Codex", "providers": ["codex"],
+            "calls": 4, "output_tokens": 0, "last_ts": 100, "last_used": "2026-10-01",
+        }]}
+        items = self.inventory(waste, codex_mcp={"ghost-mcp-proxy": True})["items"]
+        mcps = {row["name"]: row for row in items if row["type"] == "mcp"}
+        self.assertEqual(set(mcps), {"ghost-mcp-proxy"})
+        self.assertEqual(mcps["ghost-mcp-proxy"]["calls"], 4)
+        self.assertTrue(mcps["ghost-mcp-proxy"]["used"])
+        self.assertEqual(mcps["ghost-mcp-proxy"]["configuration"], "Enabled")
+
+
+class DashboardThemeTests(unittest.TestCase):
+    """Theme choice is a browser preference applied before first paint and offered in Settings and ⌘K."""
+
+    def setUp(self):
+        self.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
+
+    def run_boot(self, stored, throws=False):
+        boot = re.search(r"<script id=theme-boot>(.*?)</script>", self.page, re.S).group(1)
+        script = (
+            "const document={documentElement:{dataset:{theme:'classic'}}};const window={};"
+            f"const localStorage={{getItem(){{if({json.dumps(throws)})throw new Error('blocked');return {json.dumps(stored)};}}}};"
+            f"{boot};console.log(document.documentElement.dataset.theme);"
+        )
+        return subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout.strip()
+
+    def test_boot_script_applies_only_known_stored_themes(self):
+        self.assertIn("<html lang=en data-theme=classic>", self.page)
+        self.assertLess(self.page.index("<script id=theme-boot>"), self.page.index("<style>"))
+        self.assertEqual(self.run_boot("voltage"), "voltage")
+        self.assertEqual(self.run_boot("monolith"), "monolith")
+        self.assertEqual(self.run_boot("nebula"), "nebula")
+        self.assertEqual(self.run_boot("not-a-theme"), "classic")
+        self.assertEqual(self.run_boot(None), "classic")
+        self.assertEqual(self.run_boot("voltage", throws=True), "classic")
+
+    def test_random_theme_is_retired_and_stored_value_falls_back_to_classic(self):
+        self.assertEqual(self.run_boot("random"), "classic")
+        self.assertNotIn("THEME_RANDOM", self.page)
+        self.assertNotIn("theme-random", self.page)
+        self.assertNotIn("Randomize daily", self.page)
+
+    def test_every_registered_theme_boots_and_the_picker_uses_a_four_column_grid(self):
+        for theme in ("classic", "nebula", "monolith", "voltage", "phosphor", "omarchy", "jadehorse", "ferrous", "afterglow"):
+            self.assertEqual(self.run_boot(theme), theme)
+        self.assertIn(".themePicker{display:grid;grid-template-columns:repeat(4,minmax(0,1fr))", self.page)
+
+    def test_theme_registry_normalizes_and_feeds_the_palette(self):
+        start = self.page.index("const THEMES=[")
+        registry = self.page[start:self.page.index("let activeTheme=", start)]
+        script = registry + (
+            "console.log(JSON.stringify({ids:THEMES.map(t=>t.id),bad:normalizeThemeId('x'),ok:normalizeThemeId('voltage'),"
+            "label:themeLabel('monolith'),key:THEME_STORAGE_KEY,random:normalizeThemeId('random')}));"
+        )
+        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
+        self.assertEqual(result, {"ids": ["classic", "nebula", "monolith", "voltage", "phosphor", "omarchy", "jadehorse", "ferrous", "afterglow"], "bad": "classic", "ok": "voltage",
+                                  "label": "Monolith", "key": "tm_theme", "random": "classic"})
+        self.assertIn("...THEMES.map(theme=>({id:`theme-${theme.id}`,label:`Theme · ${theme.label}`", self.page)
+        self.assertIn("if(command.action==='theme'){setTheme(command.theme);return;}", self.page)
+        self.assertIn("route:'settings-appearance'", self.page)
+
+    def test_rapid_theme_changes_keep_page_and_storage_in_sync(self):
+        start = self.page.index("function setTheme(")
+        body = self.page[start:self.page.index("\n}\n", start) + 2]
+        script = (
+            "const THEMES=[{id:'nebula'},{id:'monolith'},{id:'voltage'}];"
+            "const normalizeThemeId=v=>THEMES.some(t=>t.id===v)?v:'nebula';const THEME_STORAGE_KEY='tm_theme';"
+            "const resolveTheme=v=>v;let themePreference='nebula';"
+            "let stored=null,repaints=0,queued=[];const localStorage={setItem(k,v){stored=v;}};"
+            "const pageSignalReducedMotionQuery={matches:false};"
+            "const document={documentElement:{dataset:{theme:'nebula'}},startViewTransition(cb){queued.push(cb);return {};}};"
+            "function paintThemePicker(){}function repaintThemedSurfaces(){repaints++;}"
+            "let activeTheme='nebula';" + body +
+            "setTheme('voltage');setTheme('monolith');setTheme('nebula');queued.forEach(cb=>cb());"
+            "console.log(JSON.stringify({page:document.documentElement.dataset.theme,stored,active:activeTheme,repaints}));"
+        )
+        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
+        self.assertEqual(result["page"], "nebula")
+        self.assertEqual(result["stored"], "nebula")
+        self.assertEqual(result["active"], "nebula")
+        self.assertGreaterEqual(result["repaints"], 1)
+
+    def test_performance_page_follows_the_dashboard_theme(self):
+        perf = Path(__file__).resolve().parents[1].joinpath("performance.html").read_text(encoding="utf-8")
+        boot = re.compile(r"<script id=theme-boot>.*?</script>", re.S)
+        self.assertEqual(boot.search(perf).group(0), boot.search(self.page).group(0))
+        self.assertIn("<html lang=en data-theme=classic>", perf)
+        block = re.compile(r"\n((?::root,)?\[data-theme=(\w+)\])\{([^{}]*)\}")
+        dashboard = {m.group(2): dict(re.findall(r"--([\w-]+):([^;]+);", m.group(3))) for m in block.finditer(self.page)}
+        performance = {m.group(2): dict(re.findall(r"--([\w-]+):([^;]+);", m.group(3))) for m in block.finditer(perf)}
+        self.assertEqual(sorted(performance), sorted(dashboard))
+        self.assertIn(":root,[data-theme=classic]{", perf)
+        for theme, tokens in performance.items():
+            with self.subTest(theme=theme):
+                self.assertTrue(tokens)
+                shared = {k: v for k, v in tokens.items() if not k.startswith("card-")}
+                self.assertEqual(shared, {k: dashboard[theme][k] for k in shared})
+                card = sorted(k for k in tokens if k.startswith("card-"))
+                self.assertEqual(card, ["card-a-rgb", "card-b-rgb", "card-c-rgb", "card-foot", "card-glow-rgb",
+                                        "card-hero", "card-hi-rgb", "card-idle-rgb", "card-paper-a-rgb",
+                                        "card-paper-b-rgb"])
+        style = perf[perf.index("<style>"):perf.index("</style>")]
+        chrome = block.sub("", style)
+        self.assertNotIn("#00bceb", chrome)
+        self.assertNotIn("rgba(0,188,235", chrome)
+        script = perf[perf.index("<script>"):perf.rindex("</script>")]
+        draw = script[script.index("function cardPalette("):script.index("function setStatus(")]
+        draw = draw.replace(draw[draw.index("const CLASSIC_CARD="):draw.index("\n", draw.index("const CLASSIC_CARD="))], "")
+        for literal in ("#00bceb", "#4054d6", "#8ee9f2", "#8f6ce6", "rgba(0,188,235", "rgba(64,84,214", "rgba(127,219,242", "#0d2c3d"):
+            with self.subTest(card_literal=literal):
+                self.assertNotIn(literal, draw)
+        self.assertIn("window.addEventListener('storage',event=>{", script)
+
+    def test_performance_rail_lists_the_same_destinations_as_the_dashboard(self):
+        perf = Path(__file__).resolve().parents[1].joinpath("performance.html").read_text(encoding="utf-8")
+        def groups(source, primary, secondary, label):
+            top = source[source.index(f"<div class={primary}>"):source.index(f"<div class={secondary}>")]
+            bottom = source[source.index(f"<div class={secondary}>"):source.index("</nav>", source.index(f"<div class={secondary}>"))]
+            return re.findall(label, top), re.findall(label, bottom)
+        dashboard = groups(self.page, "navPrimary", "navSecondary", r'class="?tab[^>]*data-label=(\w+)')
+        performance = groups(perf, "railPrimary", "railSecondary", r"<span class=railLabel>(\w+)</span>")
+        self.assertEqual(performance, dashboard)
+        self.assertEqual(dashboard[1][0], "Read")
+        tokenomics = re.search(r"const TOKENOMICS_SEARCH_URL='([^']+)'", self.page).group(1)
+        self.assertIn(f'id=tab-read href="{tokenomics}" target=_blank rel="noopener noreferrer"', perf)
+
+    def test_appearance_settings_section_and_route(self):
+        self.assertIn('<nav class="card settingsMap" aria-label="Settings sections">\n    <button type=button data-settings-target=appearance-settings><b>Appearance</b></button>', self.page)
+        content = self.page.index("<div class=settingsPageContent>")
+        self.assertEqual(self.page.index("<section", content), self.page.index('<section class="card pad appearanceSettings"', content))
+        self.assertIn('<section class="card pad appearanceSettings" id=appearance-settings>', self.page)
+        self.assertIn("<div class=themePicker id=theme-picker role=group aria-labelledby=appearance-title></div>", self.page)
+        self.assertIn("h==='settings-appearance'", self.page)
+        self.assertIn("option.setAttribute('aria-pressed',String(option.dataset.themeOption===themePreference));", self.page)
+        self.assertIn("window.addEventListener('storage',event=>{if(event.key===THEME_STORAGE_KEY)", self.page)
+
+    def test_theme_switch_repaints_token_driven_surfaces(self):
+        start = self.page.index("function repaintThemedSurfaces(){")
+        body = self.page[start:self.page.index("\n}", start)]
+        for marker in ("readChartTokens();", "drawIO(", "renderModelStats(", "renderEfficiency(",
+                       "drawSpendScatter(", "drawDeliveryChart(", "syncActivePageSignalEffects();", "meta[name=theme-color]"):
+            with self.subTest(marker=marker):
+                self.assertIn(marker, body)
+        effects = Path(__file__).resolve().parents[1].joinpath("assets", "session-effects.js").read_text(encoding="utf-8")
+        self.assertIn("getComputedStyle(element)", effects)
+        for token in ("--fx-front-rgb", "--fx-back-rgb", "--fx-edge-a-rgb", "--fx-edge-b-rgb"):
+            self.assertIn(f'"{token}"', effects)
+
+    def motion_source(self, start, end):
+        return self.page[self.page.index(start):self.page.index(end)]
+
+    def test_readouts_count_only_meaningful_numeric_changes(self):
+        source = self.motion_source("const READOUT_PATTERN=", "// Readouts count toward")
+        script = (
+            "let clock=0;const performance={now:()=>clock};const frames=[];const requestAnimationFrame=cb=>frames.push(cb);"
+            "const cssVar=()=>'480ms';" + source +
+            "const el={textContent:''};const ran=(a,b)=>{frames.length=0;tweenReadout(el,a,b);return frames.length>0;};"
+            "const out={placeholder:ran('—','$4.20'),word:ran('Sonnet 3.7','Sonnet 4.5'),suffix:ran('12K','3M'),"
+            "tiny:ran('$100.00','$100.40'),real:ran('$100.00','$140.00')};clock=2000;out.quiet=ran('$140.00','$200.00');"
+            "clock=20000;out.later=ran('$140.00','$200.00');"
+            "const other={textContent:''};frames.length=0;tweenReadout(other,'$1,000','$2,000');clock=50000;frames.shift()(clock);out.final=other.textContent;"
+            "console.log(JSON.stringify(out));"
+        )
+        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
+        self.assertEqual(result, {"placeholder": False, "word": False, "suffix": False, "tiny": False, "real": True,
+                                  "quiet": False, "later": True, "final": "$2,000"})
+
+    def test_no_glow_follows_the_cursor(self):
+        # A highlight moving behind text under the pointer made cards hard to read, so cards stay still.
+        self.assertNotIn("isSpotlit", self.page)
+        self.assertNotIn("--spot", self.page)
+        self.assertNotIn("spotlight", self.page.lower().replace("spotlights", ""))
+
+    def test_chart_reveal_runs_once_per_route_change(self):
+        source = self.motion_source("const chartsRevealedThisVisit=", "const READOUT_SELECTOR=")
+        script = (
+            "let animations=0;const svg={id:'iochart',childElementCount:3,getClientRects:()=>[1],animate(){animations++;}};"
+            "const $=()=>svg;const motionAllowed=()=>true;const cssVar=()=>'ease';const CHART_REVEAL_IDS=['iochart'];"
+            "class MutationObserver{observe(){}}" + source +
+            "const session={dataset:{entered:'1'},children:[]},spend={dataset:{entered:'1'},children:[]};"
+            "playRouteMotion(session);playRouteMotion(session);revealChart(svg);playRouteMotion(spend);playRouteMotion(session);"
+            "console.log(animations);"
+        )
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout.strip()
+        self.assertEqual(result, "3")
+
+
+class LocalServerBindTests(unittest.TestCase):
+    def test_binding_the_local_server_skips_reverse_dns(self):
+        # A stalled resolver must not delay listen(): http.server would call
+        # socket.getfqdn here, which can block for ~35s on some networks.
+        with mock.patch("socket.getfqdn", side_effect=AssertionError("reverse DNS on bind")):
+            server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
+        try:
+            self.assertEqual(server.server_name, "127.0.0.1")
+            self.assertEqual(server.server_port, server.server_address[1])
+        finally:
+            server.server_close()
+
+
+class DeclutterCopyContractTests(unittest.TestCase):
+    """Copy moved out of view keeps its behavior: notes appear only when they say something."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.page = Path(DASHBOARD_PAGE).read_text()
+
+    def run_node(self, script):
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        return json.loads(result.stdout)
+
+    def statement(self, start, end=";\n"):
+        return start + self.page.split(start, 1)[1].split(end, 1)[0] + ";"
+
+    def test_scatter_missing_note_is_hidden_until_points_are_missing(self):
+        self.assertIn(".spendScatterLegend span[hidden]{display:none}", self.page)
+        self.assertIn("<span id=s-scatter-missing hidden>Requires active-time and selected-metric evidence.</span>", self.page)
+        self.assertIn("$('s-scatter-missing').hidden=points.length>=(rows||[]).length;", self.page)
+
+    def test_session_budget_shows_saved_briefly_after_a_successful_save(self):
+        self.assertIn("<span id=session-budget-status role=status aria-live=polite></span>", self.page)
+        self.assertNotIn("Saved for this session on this device", self.page)
+        body = self.page.split("let sessionBudgetStatusTimer=0;\n", 1)[1].split("\n}\n", 1)[0] + "\n}"
+        script = """
+const nodes={'session-budget-status':{textContent:''}};const $=id=>nodes[id];
+let CURRENT={id:'s'};const timers=[];function setTimeout(fn,ms){timers.push([fn,ms]);return timers.length;}function clearTimeout(){}
+function syncSessionBudgetControls(){}function showAppToast(){}
+async function queueSessionBudget(){return true;}
+let sessionBudgetStatusTimer=0;
+""" + body + """
+(async()=>{saveBudgetForSession('12');await new Promise(r=>setImmediate(r));
+const saved=nodes['session-budget-status'].textContent,delay=timers[0][1];timers[0][0]();
+process.stdout.write(JSON.stringify({saved,delay,after:nodes['session-budget-status'].textContent}));})();
+"""
+        self.assertEqual(self.run_node(script), {"saved": "Saved", "delay": 2500, "after": ""})
+
+    def test_agent_activity_coverage_is_empty_when_complete_and_lists_gaps(self):
+        statement = self.statement("$('agent-activity-coverage').textContent=")
+        script = """
+const nodes={'agent-activity-coverage':{textContent:'x'}};const $=id=>nodes[id];const f=n=>String(n);
+const run=(coverage,hidden)=>{""" + statement + """return nodes['agent-activity-coverage'].textContent;};
+process.stdout.write(JSON.stringify([
+ run({relationships:'complete',cost:'estimated',tokens:'complete'},0),
+ run({relationships:'complete',cost:'complete',tokens:'complete'},0),
+ run({relationships:'partial',cost:'partial',tokens:'unavailable'},3),
+]));
+"""
+        self.assertEqual(self.run_node(script), [
+            "", "", "Relationships partial · cost partial · tokens unavailable · 3 hidden (limit 100)",
+        ])
+
+    def test_model_spend_note_marks_unpriced_runtimes_as_excluded_not_zero(self):
+        body = "function renderModelSpend(" + self.page.split("function renderModelSpend(", 1)[1].split("\nfunction ", 1)[0]
+        script = """
+const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const nodes={};const $=id=>nodes[id]||(nodes[id]={textContent:'',innerHTML:''});
+const setLogHtml=(el,html)=>{el.innerHTML=html;};const f=n=>String(n);const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
+const money=n=>'$'+Number(n).toFixed(2);const pct=n=>Math.round(n*100)+'%';const modelRangeLabel=()=>'30 days';let modelRange='30';
+const metricPartial=()=>false;const modelRankedColors=()=>new Map();const MODEL_OTHER_COLOR='x';
+const modelBoardValue=(group,key)=>group.window.cost==null?null:group.window.cost;
+""" + body + """
+const groups=[{key:'a',model:'a',runtime:'Codex',ids:['a'],window:{cost:2}},{key:'b',model:'b',runtime:'Codex',ids:['b'],window:{cost:null}},{key:'c',model:'c',runtime:'Codex',ids:['c'],window:{cost:null}}];
+renderModelSpend(groups,groups,[groups[0]],true);
+process.stdout.write(JSON.stringify(nodes['m-spend-note'].innerHTML));
+"""
+        html = self.run_node(script)
+        self.assertIn("<span class=fieldtip tabindex=0", html)
+        self.assertIn('data-tip="2 model runtimes without cost data are excluded, not counted as $0."', html)
+        self.assertIn('aria-description="2 model runtimes without cost data are excluded, not counted as $0."', html)
+        self.assertIn(">2 unpriced, excluded</span>", html)
+
+    NODE_EXTRACT = r"""
+const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
+function extract(name){let start=page.indexOf(`async function ${name}(`);if(start<0)start=page.indexOf(`function ${name}(`);if(start<0)throw new Error('missing '+name);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
+const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const f=n=>Number(n||0).toLocaleString('en-US');const money=n=>'$'+Number(n||0).toFixed(2);
+class Node{constructor(){this.textContent='';this.innerHTML='';this.hidden=false;this.dataset={};this.options=[];this.classList={add(){},remove(){},toggle(){}};this.style={setProperty(){}};this.body=null;}
+ querySelector(sel){if(sel==='tbody'){return this.body||(this.body=new Node());}return null;}querySelectorAll(){return [];}setAttribute(){}removeAttribute(){}}
+const nodes={};const $=id=>nodes[id]||(nodes[id]=new Node());
+"""
+
+    def run_page_node(self, script):
+        page = str(Path(DASHBOARD_PAGE))
+        result = subprocess.run(["node", "-e", self.NODE_EXTRACT + script, page],
+                                capture_output=True, text=True)
+        if result.returncode:
+            errors = [line for line in result.stderr.splitlines() if "Error" in line]
+            self.fail(errors[0] if errors else result.stderr.strip() or "node failed")
+        return json.loads(result.stdout)
+
+    def test_today_cards_say_unavailable_only_when_daily_rows_are_missing(self):
+        out = self.run_page_node(r"""
+const localDayKey=(d=new Date())=>d.toISOString().slice(0,10);const metricAvailable=()=>true,metricPartial=()=>false,hasLocalEstimate=()=>false;
+const setCostValue=(id,text)=>{$(id).textContent=text;};const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
+const dailyDeltaLabel=()=>'+0%';const renderTrendDelta=()=>'';
+eval(extract('renderCurrentDaySummary'));
+const ids=['current-day-spend-note','current-day-sessions-note','current-day-vs-yesterday-note'];const notes=()=>ids.map(id=>$(id).textContent);
+renderCurrentDaySummary(undefined);const loading=notes();
+renderCurrentDaySummary({current_sessions:[]});const missing=notes();
+renderCurrentDaySummary({daily:[{day:localDayKey(),cost:1.5,sessions:2}]});const arrived=notes();
+process.stdout.write(JSON.stringify({loading,missing,arrived}));
+""")
+        self.assertEqual(out["loading"], ["", "", ""])
+        self.assertEqual(out["missing"], ["Unavailable", "Unavailable", "Unavailable"])
+        self.assertNotIn("Unavailable", out["arrived"])
+        self.assertTrue(all(out["arrived"]))
+
+    def test_git_load_failure_marks_both_tables_unavailable_and_success_replaces_them(self):
+        out = self.run_page_node(r"""
+let deliveryRequest=0,deliveryRange='30',deliveryProject='',deliveryLastLoadedAt=0,deliveryRetryTimer=0,deliveryLoadRetries=0;
+let deliveryEvidenceFilter='all',deliverySort={key:'covered_cost',direction:'desc'},deliveryModelSort={key:'covered_cost',direction:'desc'};
+const modelEffortLabel=row=>row?.effort||'';const clearTimeout=()=>{};const setTimeout=()=>0;const setDeliveryEvidenceRatio=()=>{};const DELIVERY_EVIDENCE_FILTERS=['all','comparable','spend_only','git_only','unavailable'];const deliveryEvidenceFilterLabel=()=>'';
+eval(['loadDelivery','renderDeliveryTable','renderDeliveryModelTable','sortedDeliveryModelRows','deliveryModelSortValue','deliveryFilteredProjectRows','sortedDeliveryRows'].map(extract).join('\n'));
+function renderDelivery(payload){renderDeliveryModelTable(payload.model_rows,payload.model_coverage);renderDeliveryTable(payload.project_rows);}
+let respond;globalThis.fetch=async()=>respond();
+(async()=>{
+ $('d-model-note').textContent='120 / 300 lines attributed';
+ respond=()=>{throw new Error('offline');};await loadDelivery();
+ const failed={note:$('d-model-note').textContent,model:$('d-model-table').querySelector('tbody').innerHTML,project:$('d-project-table').querySelector('tbody').innerHTML};
+ respond=()=>({ok:true,json:async()=>({coverage:{last_checked:1},model_coverage:{available:true,comparable_lines:10,attributed_lines:10},model_rows:[{model:'gpt-x',runtime:'Codex',covered_cost:1,attributed_lines:10}],project_rows:[]})});
+ await loadDelivery();
+ const ok={note:$('d-model-note').textContent,model:$('d-model-table').querySelector('tbody').innerHTML,project:$('d-project-table').querySelector('tbody').innerHTML};
+ process.stdout.write(JSON.stringify({failed,ok}));
+})();
+""")
+        failed, ok = out["failed"], out["ok"]
+        self.assertEqual(failed["note"], "")
+        self.assertIn("<td colspan=5><div class=\"deliveryEmpty emptyState\">Git evidence unavailable.</div>", failed["model"])
+        self.assertIn("<td colspan=4><div class=\"deliveryEmpty emptyState\">Git evidence unavailable.</div>", failed["project"])
+        self.assertEqual(ok["note"], "10 / 10 lines attributed")
+        self.assertIn("gpt-x", ok["model"])
+        self.assertNotIn("Git evidence unavailable.", ok["model"] + ok["project"])
+        self.assertIn("No projects match this filter.", ok["project"])
+
+    def test_scatter_missing_note_follows_plotted_points(self):
+        out = self.run_page_node(r"""
+let spendScatterMetric='cost';const CHART={lbl:'l',grid:'g'};const tint=()=>'t';const hideSpendScatterTip=()=>{};
+const sessionRowKey=row=>row.id;const spendRuntimeKey=p=>p;const spendInsightMetricFormat=v=>String(v);const sessionRoute=id=>'#'+id;
+const providerColor=()=>'c';const waitFmt=v=>String(v);const svgTextPx=(svg,w,h,px)=>px;const SPEND_RUNTIME_COLORS=new Proxy({},{get:()=>'c'});
+$('s-scatter-svg').clientWidth=1040;$('s-scatter-svg').clientHeight=340;$('s-scatter-metric');
+eval(['drawSpendScatter','spendScatterRows','spendSessionMetricValue'].map(extract).join('\n'));
+const analytics={distributions:{active:{median:0},cost:{median:0}},concentration:{top_count:0}};
+const row=(id,timed)=>({id,provider:'codex',title:id,cost:1,availability:{cost:true},duration_available:timed,duration_s:60});
+drawSpendScatter([row('a',true),row('b',false)],analytics);const partial=$('s-scatter-missing').hidden;
+drawSpendScatter([row('a',true),row('b',true)],analytics);const complete=$('s-scatter-missing').hidden;
+process.stdout.write(JSON.stringify({partial,complete,coverage:$('s-scatter-coverage').textContent}));
+""")
+        self.assertEqual(out, {"partial": False, "complete": True, "coverage": "2 of 2 sessions plotted"})
+
+    def test_work_breakdown_footnote_is_a_short_count_with_the_reason_in_a_tooltip(self):
+        start = " const excludedDetail="
+        block = start + self.page.split(start, 1)[1].split("\n}\n", 1)[0]
+        script = """
+const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const nodes={'w-breakdown-foot':{innerHTML:'x'}};const $=id=>nodes[id];const count=n=>String(n);
+const run=(unanswered,unjudged)=>{const overall={requests:10,tasks:8};""" + block + """;return nodes['w-breakdown-foot'].innerHTML;};
+process.stdout.write(JSON.stringify([run(3,2),run(0,0)]));
+"""
+        both, none = self.run_node(script)
+        self.assertEqual(none, "")
+        self.assertIn("<span class=fieldtip tabindex=0", both)
+        self.assertIn(">· 3 requests, 2 tasks excluded</span>", both)
+        self.assertIn("3 of 10 requests come from apps that don&#39;t split model calls by request", both)
+        self.assertIn("2 of 8 tasks had no labeled follow-up", both)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_efficiency.py b/tests/test_dashboard_efficiency.py
new file mode 100644
index 00000000..f6abed38
--- /dev/null
+++ b/tests/test_dashboard_efficiency.py
@@ -0,0 +1,1063 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardEfficiencyLayoutTests(DashboardLayoutCase):
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_bridges_gaps_marks_isolated_days_and_never_plots_zero(self):
+        payload = self.run_chart_gap_harness(r"""
+load(['chartGapRuns','chartGapBridge','efficiencyChartPointerIndex','efficiencyChartKeyIndex','efficiencyChartMetricPresentation','efficiencyChartInspection','efficiencyChartAnnouncement','efficiencyChartSmoothPath','renderEfficiencyChart']);
+class AttrNode{constructor(){this.attrs={};}setAttribute(name,value){this.attrs[name]=String(value);}}
+class InspectNode extends AttrNode{constructor(){super();this.line=new AttrNode();this.dot=new AttrNode();}querySelector(selector){return selector==='line'?this.line:this.dot;}}
+class SvgNode extends AttrNode{constructor(parent){super();this.parentElement=parent;this.dataset={};this.inspect=null;}set innerHTML(value){this.html=value;this.inspect=new InspectNode();}get innerHTML(){return this.html;}querySelector(selector){return selector==='.efficiencyChartInspect'?this.inspect:null;}getBoundingClientRect(){return {left:0,width:520};}matches(){return false;}}
+const tip={hidden:true,textContent:'',style:{}},status={textContent:''};
+const svg=new SvgNode({querySelector(selector){return selector==='.efficiencyChartTip'?tip:status;}});
+globalThis.$=()=>svg;globalThis.esc=value=>String(value);globalThis.pct=value=>`${Math.round(value*100)}%`;globalThis.compactNumber=value=>String(Math.round(value));
+const values=[null,10,20,null,15,null,30,25,null];
+const trend=values.map((value,index)=>({day:`2026-08-${String(index+1).padStart(2,'0')}`,metrics:{output_per_dollar:value}}));
+renderEfficiencyChart('chart',trend,'output_per_dollar','Output per covered dollar');
+const html=svg.innerHTML,x=index=>9+index*502/8,y=value=>10+70-(value/30)*70;
+svg.onfocus();svg.onkeydown({key:'Home',preventDefault(){}});const leading=tip.textContent;
+['ArrowRight','ArrowRight','ArrowRight'].forEach(key=>svg.onkeydown({key,preventDefault(){}}));const gap=tip.textContent;
+process.stdout.write(JSON.stringify({
+ bridges:attrs(html,'line','chartGapBridge'),
+ expectedBridges:[[x(2),y(20),x(4),y(15)],[x(4),y(15),x(6),y(30)]].map(row=>row.map(value=>value.toFixed(1))),
+ dots:attrs(html,'circle','efficiencyChartDot').map(dot=>[dot.cx,dot.cy]),
+ expectedIsolated:[x(4).toFixed(1),y(15).toFixed(1)],
+ lines:attrs(html,'path','efficiencyChartLine').map(path=>path.d),
+ baseline:(10+70).toFixed(1),
+ missingX:[0,3,5,8].map(index=>x(index).toFixed(1)),
+ leading,gap,
+}));
+""")
+        self.assertEqual(
+            [[b["x1"], b["y1"], b["x2"], b["y2"]] for b in payload["bridges"]],
+            payload["expectedBridges"],
+        )
+        self.assertIn(payload["expectedIsolated"], payload["dots"])
+        self.assertEqual(len(payload["lines"]), 2, "only multi-day runs draw a solid line")
+        for path in payload["lines"]:
+            coordinates = re.findall(r"(-?\d+\.\d)\s(-?\d+\.\d)", path)
+            self.assertNotIn(payload["baseline"], [y for _, y in coordinates])
+            for missing_x in payload["missingX"]:
+                self.assertNotIn(missing_x, [x for x, _ in coordinates])
+        self.assertEqual(payload["leading"], "Aug 1 · No data")
+        self.assertEqual(payload["gap"], "Aug 4 · No data")
+
+    def test_efficiency_is_the_only_top_level_name_and_route(self):
+        for marker in (
+            "id=tab-efficiency", "id=view-efficiency", "data-page-signal=efficiency",
+            "id=e-project", "id=e-model-picker", "id=e-model-options", "id=e-model-summary",
+            "id=e-range", "id=e-output-dollar", "id=e-reasoning-ratio",
+            "id=e-output-dollar-chart", "id=e-reasoning-chart",
+            "id=e-context-load", "id=e-cache-hit", "id=e-model-table",
+            "data-efficiency-sort=cache_hit_ratio",
+            "data-efficiency-sort=cost", "data-efficiency-sort=output_per_dollar",
+            "function renderEfficiency", "function efficiencyMetrics",
+            "function renderEfficiencyChart", "function sortEfficiencyRows",
+            "y2=\"${pad.top}\"", "r=\"3.5\"",
+            "$('tab-efficiency').onclick=()=>openTopLevelRoute('efficiency')",
+            "if(h==='efficiency')", "renderActiveEfficiency()",
+            "tm_efficiency_range",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertRegex(
+            self.page,
+            r"id=tab-efficiency[^>]*>.*?<span class=tabLabel>Efficiency</span>",
+        )
+        nav_ids = [
+            "tab-session", "tab-daily", "tab-models", "tab-efficiency",
+            "tab-learn", "tab-capabilities", "tab-settings",
+        ]
+        positions = [self.page.index(f"id={tab_id}") for tab_id in nav_ids]
+        self.assertEqual(positions, sorted(positions))
+        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
+            "<div class=view id=view-learn>", 1
+        )[0]
+        self.assertIn("Output / $", efficiency)
+        self.assertIn("Reasoning ratio", efficiency)
+        self.assertIn("Cache hit ratio", efficiency)
+        self.assertNotIn("Output / exec", efficiency)
+        self.assertNotIn("output_per_execution", self.page)
+        self.assertIn("Mechanical efficiency", efficiency)
+        self.assertIn("Spend", efficiency)
+        self.assertNotIn("Cache leverage", efficiency)
+        self.assertNotIn("Retry waste", efficiency)
+        self.assertNotIn("Efficiency score", efficiency)
+        self.assertNotIn("recommendation", efficiency.lower())
+        for stale in (
+            "id=tab-insights", "id=view-insights", "route:'insights'",
+            "tm_insights_range", "function renderInsights",
+        ):
+            self.assertNotIn(stale, self.page)
+
+    def test_efficiency_table_keeps_model_app_and_effort_as_columns(self):
+        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
+            "<div class=view id=view-learn>", 1
+        )[0]
+        for header in (">Model<", ">App<", ">Reasoning effort<"):
+            self.assertIn(header, efficiency)
+        self.assertIn(
+            "<td><div class=modelName title=\"${esc(row.model)}\">${esc(row.model)}</div></td><td>${esc(row.runtime)}",
+            self.page,
+        )
+
+    def test_selected_session_has_a_compact_two_metric_efficiency_module(self):
+        summary = self.page.split('<div class="session-panel on" id=panel-summary>', 1)[1].split(
+            '<details class=usageDetails', 1
+        )[0]
+        for marker in (
+            "id=session-efficiency", "id=session-output-dollar",
+            "id=session-output-dollar-note", "id=session-reasoning-ratio",
+            "id=session-reasoning-ratio-note", "function renderSessionEfficiency",
+            "function sessionEfficiencySource", "aggregateModelDays(source.model_stats||[])",
+            "id=preview-run-efficiency-slot",
+            "mountCurrentModule('preview-run-efficiency-slot','session-efficiency')",
+            "['session-efficiency-home','session-efficiency']",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertLess(summary.index("id=session-efficiency"), summary.index("id=session-budget-home"))
+        session_efficiency = summary.split("id=session-efficiency", 1)[1].split(
+            "id=session-budget-home", 1
+        )[0]
+        self.assertEqual(session_efficiency.count('class="sessionEfficiencyMetric metric"'), 2)
+        self.assertIn("Output / $", session_efficiency)
+        self.assertIn("Reasoning ratio", session_efficiency)
+        self.assertNotIn("<svg", session_efficiency)
+        self.assertNotIn("By model", session_efficiency)
+
+    def test_selected_session_efficiency_is_inside_the_run_status_card(self):
+        run_surface = self.page.split('id=preview-surface-run', 1)[1].split(
+            '<div class=previewKpis', 1
+        )[0]
+        status_card = run_surface.split('id=preview-status-card', 1)[1].split(
+            '</section>', 1
+        )[0]
+        self.assertIn('id=preview-run-efficiency-slot', status_card)
+        self.assertLess(
+            status_card.index('id=preview-run-efficiency-slot'),
+            status_card.index('class=previewPressure'),
+        )
+        self.assertIn(
+            ".previewStatus .previewRunEfficiencySlot .sessionEfficiency{grid-template-columns:repeat(2",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_efficiency_uses_the_matching_cross_session_summary(self):
+        match = re.search(
+            r"function sessionEfficiencySource\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match)
+        script = r"""
+const stateSessionId=state=>state?.source?.id||null;
+""" + match.group(0) + r"""
+const matched={source:{id:'selected',key:'tright'},model_stats:[],xsession:{sessions:[
+  {id:'other',key:'tother',model_stats:[{model:'wrong-id'}]},
+  {id:'selected',key:'twrong',model_stats:[{model:'wrong-trace'}]},
+  {id:'selected',key:'tright',model_stats:[{model:'right'}],usage_basis:'reported'},
+]}};
+const direct={source:{id:'direct'},model_stats:[{model:'fallback'}],xsession:{sessions:[]}};
+const stale={source:{id:'selected',key:'tmissing'},model_stats:[{model:'fail-closed'}],xsession:{sessions:[
+  {id:'selected',key:'twrong',model_stats:[{model:'wrong-trace'}]},
+]}};
+const attached={source:{id:'selected',key:'tright'},selected_stats:{model_stats:[{model:'attached-exact'}],usage_basis:'reported'},xsession:{sessions:[
+  {id:'selected',key:'tright',model_stats:[{model:'stale-cross'}]},
+]}};
+console.log(JSON.stringify({matched:sessionEfficiencySource(matched),direct:sessionEfficiencySource(direct),stale:sessionEfficiencySource(stale),attached:sessionEfficiencySource(attached)}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["matched"]["model_stats"][0]["model"], "right")
+        self.assertEqual(payload["matched"]["usage_basis"], "reported")
+        self.assertEqual(payload["direct"]["model_stats"][0]["model"], "fallback")
+        self.assertEqual(payload["stale"]["model_stats"][0]["model"], "fail-closed")
+        self.assertEqual(payload["attached"]["model_stats"][0]["model"], "attached-exact")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_efficiency_recovers_explicit_reasoning_coverage_from_summary_counts(self):
+        match = re.search(
+            r"function normalizeSessionEfficiencyAggregate\(.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(match)
+        script = match.group(0) + r"""
+console.log(JSON.stringify({
+  exact:normalizeSessionEfficiencyAggregate({
+    executions:10,reasoning_executions:8,reasoning_tokens:30,
+    reasoning_output_tokens:80,availability:{reasoning_tokens:false},
+  }),
+  structural:normalizeSessionEfficiencyAggregate({
+    executions:10,reasoning_executions:0,reasoning_tokens:0,
+    reasoning_output_tokens:0,thinking_executions:4,availability:{},
+  }),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertTrue(payload["exact"]["availability"]["reasoning_tokens"])
+        self.assertFalse(payload["structural"]["availability"]["reasoning_tokens"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_metrics_are_bounded_and_keep_unavailable_evidence_null(self):
+        match = re.search(
+            r"function efficiencyMetrics\(row\)\{.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs one shared efficiency formula")
+        script = match.group(0) + r"""
+const complete = efficiencyMetrics({
+  input_tokens:1000, output_tokens:200, cost:2, executions:2,
+  token_covered_executions:2, io_covered_executions:2,
+  cost_covered_output_tokens:200, cost_covered_cost:2,
+  cache_read_tokens:500, reasoning_tokens:50, reasoning_output_tokens:100,
+  reasoning_executions:1, reasoning_unavailable_executions:1,
+  attempts:4, retries:1, failed_attempts:1, attempt_samples:1,
+  availability:{tokens:true,cost:true,cache:true,reasoning_tokens:true,attempts:true},
+});
+const missing = efficiencyMetrics({
+  input_tokens:100, output_tokens:20, cost:0, executions:0,
+  availability:{tokens:true,cost:false,cache:false,reasoning_tokens:false,attempts:false},
+});
+const partial = efficiencyMetrics({
+  input_tokens:110, output_tokens:110, cost:.1, executions:3,
+  token_covered_executions:2, io_covered_executions:1,
+  cost_covered_output_tokens:10, cost_covered_cost:.1,
+  coverage:{tokens:{complete:false}},
+  availability:{tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
+});
+const coveredZero = efficiencyMetrics({
+  input_tokens:10, output_tokens:0, cost:1, executions:1,
+  token_covered_executions:1, io_covered_executions:1,
+  cost_covered_executions:1, cost_covered_output_tokens:0,
+  cost_covered_cost:1,
+  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
+});
+const inputOnly = efficiencyMetrics({
+  input_tokens:10, output_tokens:0, cost:1, executions:1,
+  token_covered_executions:0, io_covered_executions:0,
+  cost_covered_executions:0,
+  cost_covered_output_tokens:0,
+  availability:{tokens:true,input_tokens:true,output_tokens:false,cost:true,cache:false,reasoning_tokens:false,attempts:false},
+});
+const zeroInput = efficiencyMetrics({
+  input_tokens:0, output_tokens:10, cost:1, executions:1,
+  token_covered_executions:1, io_covered_executions:1,
+  cost_covered_executions:1, cost_covered_output_tokens:10,
+  cost_covered_cost:1,
+  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
+});
+const partialPaired = efficiencyMetrics({
+  input_tokens:600, output_tokens:15, cost:.1, executions:3,
+  token_covered_executions:3, io_covered_executions:2,
+  io_covered_input_tokens:100, io_covered_output_tokens:10,
+  coverage:{tokens:{complete:false}},
+  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
+});
+const noPaired = efficiencyMetrics({
+  input_tokens:600, output_tokens:15, cost:.1, executions:3,
+  token_covered_executions:3, io_covered_executions:0,
+  io_covered_input_tokens:0, io_covered_output_tokens:0,
+  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
+});
+console.log(JSON.stringify({complete,missing,partial,coveredZero,inputOnly,zeroInput,partialPaired,noPaired}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["complete"], {
+            "output_per_dollar": 100,
+            "reasoning_ratio": 0.5,
+            "context_load": 5,
+            "cache_hit_ratio": 0.5,
+            "retry_waste": 0.25,
+            "failure_rate": 0.25,
+        })
+        self.assertEqual(payload["missing"], {
+            "output_per_dollar": None,
+            "reasoning_ratio": None,
+            "context_load": 5,
+            "cache_hit_ratio": None,
+            "retry_waste": None,
+            "failure_rate": None,
+        })
+        self.assertEqual(payload["partial"]["output_per_dollar"], 100)
+        self.assertIsNone(payload["partial"]["context_load"])
+        self.assertEqual(payload["coveredZero"]["output_per_dollar"], 0)
+        self.assertIsNone(payload["inputOnly"]["output_per_dollar"])
+        self.assertEqual(payload["zeroInput"]["context_load"], 0)
+        self.assertEqual(payload["partialPaired"]["context_load"], 10)
+        self.assertIsNone(payload["noPaired"]["context_load"])
+
+    def test_efficiency_uses_one_range_for_overall_and_per_model_statistics(self):
+        for marker in (
+            "const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all']",
+            "tm_efficiency_range", "tm_efficiency_project", "efficiencyRangeWindow", "efficiencyModelRows",
+            "aggregateModelDays(efficiencyModelRows", "efficiencyMetrics(overall)",
+            "efficiencyMetrics(row.window)", "efficiencyTrendDays",
+            "Thinking / reasoning coverage", "thinking_executions",
+            "token ratio unavailable", "e-reasoning-chart",
+            "includes local estimates", "token_covered_executions",
+            "Compare similar work · no quality judgment.",
+        ):
+            self.assertIn(marker, self.page)
+
+        self.assertIn(
+            "metric.output_per_dollar===null?'unavailable':data.coverage?.cost?.complete?'covered':'partial'",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_model_filters_keep_runtime_identities_distinct(self):
+        match = re.search(
+            r"function filterEfficiencyModels\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match, "Efficiency needs to filter by model-runtime ID")
+        script = match.group(0) + r"""
+const rows=[
+  {id:'gpt-5.6::Codex',model:'gpt-5.6',runtime:'Codex'},
+  {id:'gpt-5.6::Cursor',model:'gpt-5.6',runtime:'Cursor'},
+  {id:'claude-opus::Claude Code',model:'claude-opus',runtime:'Claude Code'},
+];
+console.log(JSON.stringify({
+  all:filterEfficiencyModels(rows,[]).map(row=>row.id),
+  selected:filterEfficiencyModels(rows,['gpt-5.6::Cursor']).map(row=>row.id),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "all": ["gpt-5.6::Codex", "gpt-5.6::Cursor", "claude-opus::Claude Code"],
+            "selected": ["gpt-5.6::Cursor"],
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_model_toggle_waits_for_the_selected_project_scope(self):
+        match = re.search(
+            r"function rerenderActiveEfficiency\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match, "Efficiency needs to avoid rendering stale project stats")
+        script = match.group(0) + r"""
+let activeEfficiencyStats={models:['all-projects']};
+let activeEfficiencyScope='';
+let efficiencyProject='project-b';
+let rendered=0,requested=0;
+function renderEfficiency(){rendered++;}
+function renderActiveEfficiency(){requested++;}
+rerenderActiveEfficiency();
+activeEfficiencyScope='project-b';
+rerenderActiveEfficiency();
+console.log(JSON.stringify({rendered,requested}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {"rendered": 1, "requested": 1})
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_effort_reads_default_only_for_apps_that_record_effort(self):
+        script = "\n".join(re.search(rf"function {name}\(.*?\n\}}", self.page, re.DOTALL).group(0)
+                           for name in ("modelEffortLabel", "efficiencyEffortLabel")) + r"""
+console.log(JSON.stringify([
+  efficiencyEffortLabel({reasoning_effort:'xhigh',providers:['codex']}),
+  efficiencyEffortLabel({providers:['claude'],thinking_executions:9}),
+  efficiencyEffortLabel({providers:['codex']}),
+  efficiencyEffortLabel({providers:['cursor']}),
+  efficiencyEffortLabel({providers:['claude','cursor']}),
+]));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        self.assertEqual(json.loads(result.stdout), ["xhigh", "default", "default", "unavailable", "unavailable"])
+        self.assertIn("effort=efficiencyEffortLabel(row)", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_delta_compares_latest_two_covered_days(self):
+        match = re.search(r"function efficiencyTrendDelta\(.*?\n\}", self.page, re.DOTALL)
+        self.assertIsNotNone(match, "Efficiency charts need a comparable-day delta helper")
+        script = match.group(0) + r"""
+console.log(JSON.stringify({
+  up:efficiencyTrendDelta([
+    {metrics:{output_per_dollar:100}}, {metrics:{output_per_dollar:null}},
+    {metrics:{output_per_dollar:125}},
+  ],'output_per_dollar'),
+  down:efficiencyTrendDelta([
+    {metrics:{reasoning_ratio:.5}}, {metrics:{reasoning_ratio:.4}},
+  ],'reasoning_ratio'),
+  unavailable:efficiencyTrendDelta([
+    {metrics:{output_per_dollar:0}}, {metrics:{output_per_dollar:25}},
+  ],'output_per_dollar'),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "up": {"text": "↑ 25.0% vs prior covered day", "direction": "up"},
+            "down": {"text": "↓ 20.0% vs prior covered day", "direction": "down"},
+            "unavailable": {"text": "No comparable prior day", "direction": ""},
+        })
+        self.assertIn('id=e-output-dollar-change', self.page)
+        self.assertIn('id=e-reasoning-change', self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_charts_smooth_daily_segments_and_default_to_thirty_days(self):
+        match = re.search(
+            r"function efficiencyChartSmoothPath\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(
+            match, "Efficiency charts need a smooth path helper for daily segments",
+        )
+        script = match.group(0) + r"""
+const rows=[
+  {index:0,value:50}, {index:1,value:30}, {index:2,value:10},
+];
+console.log(JSON.stringify({
+  smooth:efficiencyChartSmoothPath(rows,row=>row.index*10,value=>value),
+  pair:efficiencyChartSmoothPath(rows.slice(0,2),row=>row.index*10,value=>value),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "smooth": "M0.0 50.0 C3.3 43.3 6.7 36.7 10.0 30.0 C13.3 23.3 16.7 16.7 20.0 10.0",
+            "pair": "M0.0 50.0 L10.0 30.0",
+        })
+        self.assertIn("let efficiencyRange=localStorage.getItem('tm_efficiency_range')||'30';", self.page)
+        self.assertIn("if(!EFFICIENCY_RANGES.includes(efficiencyRange))efficiencyRange='30';", self.page)
+        efficiency_range = self.page.split('id=e-range aria-label="Efficiency history range">', 1)[1].split("</select>", 1)[0]
+        self.assertIn('<option value=30 selected>30 days</option>', efficiency_range)
+        self.assertNotIn('<option value=7 selected>', efficiency_range)
+        self.assertIn(
+            "renderTrendDelta('e-reasoning-change',reasoningDelta,'down',!comparison);",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_period_comparison_matches_today_yesterday_and_range_windows(self):
+        date_key = re.search(r"function dateKeyAgo\(.*\n", self.page)
+        self.assertIsNotNone(date_key, "Efficiency windows need date-key arithmetic")
+        functions = ["function localDateKey(date){return String(date.getFullYear())+'-'+String(date.getMonth()+1).padStart(2,'0')+'-'+String(date.getDate()).padStart(2,'0');}", date_key.group(0)]
+        for name in (
+            "calendarMonthWindow", "monthToDateWindow", "modelRangeWindow",
+            "efficiencyComparisonWindows", "efficiencyPeriodDelta",
+        ):
+            match = re.search(rf"function {name}\(.*?\n\}}", self.page, re.DOTALL)
+            self.assertIsNotNone(match, f"Efficiency needs {name} for matched comparisons")
+            functions.append(match.group(0))
+        script = "\n".join(functions) + r"""
+const now=new Date(2026,8,1,15,20,0);
+const today=efficiencyComparisonWindows('today',now);
+const yesterday=efficiencyComparisonWindows('yesterday',now);
+const seven=efficiencyComparisonWindows('7',now);
+const lastMonth=efficiencyComparisonWindows('last_month',new Date(2026,2,15,9,0,0));
+const month=efficiencyComparisonWindows('month',new Date(2026,2,15,9,0,0));
+console.log(JSON.stringify({
+  month:{first:month.current.days[0],last:month.current.days.at(-1),count:month.current.days.length,priorFirst:month.prior.days[0],priorLast:month.prior.days.at(-1),label:month.label},
+  lastMonth:{first:lastMonth.current.days[0],last:lastMonth.current.days.at(-1),count:lastMonth.current.days.length,priorFirst:lastMonth.prior.days[0],priorLast:lastMonth.prior.days.at(-1),label:lastMonth.label},
+  all:efficiencyComparisonWindows('all',now),
+  today:{current:today.current.days,prior:today.prior.days,label:today.label},
+  yesterday:{current:yesterday.current.days,prior:yesterday.prior.days,label:yesterday.label},
+  seven:{current:seven.current.days,prior:seven.prior.days,label:seven.label},
+  increase:efficiencyPeriodDelta({output_per_dollar:125},{output_per_dollar:100},'output_per_dollar','yesterday'),
+  unavailable:efficiencyPeriodDelta({output_per_dollar:25},{output_per_dollar:0},'output_per_dollar','yesterday'),
+  currentMissing:efficiencyPeriodDelta({context_load:null},{context_load:254},'context_load','prior 7 days'),
+  priorMissing:efficiencyPeriodDelta({context_load:12},{context_load:null},'context_load','prior 7 days'),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "month": {
+                "first": "2026-03-01", "last": "2026-03-15", "count": 15,
+                "priorFirst": "2026-02-01", "priorLast": "2026-02-28",
+                "label": "last month",
+            },
+            "lastMonth": {
+                "first": "2026-02-01", "last": "2026-02-28", "count": 28,
+                "priorFirst": "2026-01-01", "priorLast": "2026-01-31",
+                "label": "the month before",
+            },
+            "all": None,
+            "today": {
+                "current": ["2026-09-01"], "prior": ["2026-08-31"],
+                "label": "yesterday",
+            },
+            "yesterday": {
+                "current": ["2026-08-31"], "prior": ["2026-08-30"],
+                "label": "the day before",
+            },
+            "seven": {
+                "current": ["2026-08-26", "2026-08-27", "2026-08-28", "2026-08-29", "2026-08-30", "2026-08-31", "2026-09-01"],
+                "prior": ["2026-08-19", "2026-08-20", "2026-08-21", "2026-08-22", "2026-08-23", "2026-08-24", "2026-08-25"],
+                "label": "prior 7 days",
+            },
+            "increase": {"text": "↑ 25.0% vs yesterday", "direction": "up"},
+            "unavailable": {"text": "No comparable prior period", "direction": ""},
+            "currentMissing": {"text": "No comparable prior period", "direction": ""},
+            "priorMissing": {"text": "No comparable prior period", "direction": ""},
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_comparison_badge_hides_without_a_matching_period(self):
+        tone_match = re.search(
+            r"function trendTone\(.*?\n\}", self.page, re.DOTALL,
+        )
+        render_match = re.search(
+            r"function renderTrendDelta\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(tone_match)
+        self.assertIsNotNone(render_match)
+        script = tone_match.group(0) + "\n" + render_match.group(0) + r"""
+const badge={hidden:false,dataset:{},primary:{textContent:''},secondary:{textContent:''},querySelector(selector){return selector==='strong'?this.primary:this.secondary;}};
+const $=id=>badge;
+renderTrendDelta('e-output-dollar-change',{text:'No comparable prior period',direction:''},'up',true);
+console.log(JSON.stringify({hidden:badge.hidden,direction:badge.dataset.direction}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {"hidden": True, "direction": ""})
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_comparison_badge_keeps_the_prior_day_relation(self):
+        tone_match = re.search(
+            r"function trendTone\(.*?\n\}", self.page, re.DOTALL,
+        )
+        match = re.search(
+            r"function renderTrendDelta\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(tone_match)
+        self.assertIsNotNone(match, "Efficiency badges need one renderer for comparison copy")
+        script = tone_match.group(0) + "\n" + match.group(0) + r"""
+const badge={dataset:{},primary:{textContent:''},secondary:{textContent:''},querySelector(selector){return selector==='strong'?this.primary:this.secondary;}};
+const $=id=>badge;
+renderTrendDelta('e-output-dollar-change',{text:'↓ 7.5% vs prior covered day',direction:'down'});
+const available={primary:badge.primary.textContent,secondary:badge.secondary.textContent,direction:badge.dataset.direction};
+renderTrendDelta('e-output-dollar-change',{text:'No comparable prior day',direction:''});
+console.log(JSON.stringify({available,unavailable:{primary:badge.primary.textContent,secondary:badge.secondary.textContent,direction:badge.dataset.direction}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "available": {
+                "primary": "↓ 7.5%",
+                "secondary": "vs prior covered day",
+                "direction": "down",
+            },
+            "unavailable": {
+                "primary": "No comparable prior day",
+                "secondary": "",
+                "direction": "",
+            },
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_comparison_tone_respects_each_metric_direction(self):
+        match = re.search(
+            r"function trendTone\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match, "Efficiency badges need an explicit metric direction rule")
+        script = match.group(0) + r"""
+console.log(JSON.stringify({
+  outputUp:trendTone({direction:'up'},'up'),
+  outputDown:trendTone({direction:'down'},'up'),
+  contextDown:trendTone({direction:'down'},'down'),
+  contextUp:trendTone({direction:'up'},'down'),
+  unavailable:trendTone({direction:''},'up'),
+  neutral:trendTone({direction:'up'},''),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "outputUp": "improving",
+            "outputDown": "degrading",
+            "contextDown": "improving",
+            "contextUp": "degrading",
+            "unavailable": "",
+            "neutral": "",
+        })
+
+    def test_efficiency_comparisons_sit_beside_each_value_without_a_box(self):
+        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
+            "<div class=view id=view-learn>", 1,
+        )[0]
+        for value_id, comparison_id in (
+            ("e-output-dollar", "e-output-dollar-change"),
+            ("e-reasoning-ratio", "e-reasoning-change"),
+            ("e-context-load", "e-context-load-change"),
+            ("e-cache-hit", "e-cache-hit-change"),
+        ):
+            self.assertRegex(
+                efficiency,
+                rf'<div class="v mono" id={value_id}>.*?</div><div class=trendDelta id={comparison_id}[^>]*>',
+            )
+        self.assertEqual(efficiency.count('valueWithDelta"><div class="v mono"'), 4)
+        self.assertIn(":where(.valueWithDelta){display:flex;flex-wrap:wrap;align-items:center", self.page)
+        self.assertIn(":where(.trendDelta>strong){font-family:var(--font-mono);font-size:var(--fs-20)", self.page)
+        self.assertNotIn("efficiencySupportDelta", self.page)
+        self.assertNotRegex(self.page, r"\.efficiencyTrendDelta[^{]*\{")
+        self.assertIn(":where(.trendDelta){display:grid", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_presentation_labels_each_metric(self):
+        match = re.search(
+            r"function efficiencyChartMetricPresentation\(.*?\n\}", self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(
+            match, "Efficiency charts need metric-specific visible labels",
+        )
+        script = r"""
+function compactNumber(value){return value>=1000?(value/1000).toFixed(1).replace(/\.0$/,'')+'K':String(value);}
+function pct(value){return (value*100).toFixed(1)+'%';}
+function efficiencyDecimal(value){return String(value)+'x';}
+""" + match.group(0) + r"""
+console.log(JSON.stringify({
+  dollar:efficiencyChartMetricPresentation(5200,'output_per_dollar'),
+  reasoning:efficiencyChartMetricPresentation(.34,'reasoning_ratio'),
+  context:efficiencyChartMetricPresentation(256,'context_load'),
+  cache:efficiencyChartMetricPresentation(.87,'cache_hit_ratio'),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "dollar": {"axis": "5.2K", "detail": "5,200 output tokens / $"},
+            "reasoning": {"axis": "34.0%", "detail": "34.0% reasoning"},
+            "context": {"axis": "256x", "detail": "256x context / output"},
+            "cache": {"axis": "87.0%", "detail": "87.0% input from cache"},
+        })
+
+    def test_efficiency_support_cards_include_compact_daily_charts(self):
+        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
+            "<div class=view id=view-learn>", 1,
+        )[0]
+        for metric, label in (
+            ("context-load", "Daily context load"),
+            ("cache-hit", "Daily cache hit ratio"),
+        ):
+            self.assertIn(
+                f'id=e-{metric}-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="{label}"',
+                efficiency,
+            )
+        self.assertIn(".efficiencySupportItem .efficiencyChart{height:56px}", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_range_aggregation_keeps_only_efforts_in_range(self):
+        match = re.search(
+            r"function aggregateModelDays\(rows\)\{.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match, "Efficiency needs range-scoped model aggregation")
+        script = r"""
+const MODEL_COUNTER_KEYS=[],MODEL_ARRAY_KEYS=[];
+const metricAvailable=()=>false,metricPartial=()=>false,hasLocalEstimate=()=>false;
+const usageBasis=()=> 'reported',modelWaitDistribution=()=>({median_wait_s:0,p95_wait_s:0});
+const modelMedian=()=>0;
+""" + match.group(0) + r"""
+console.log(JSON.stringify(aggregateModelDays([
+  {reasoning_efforts:['high']}, {reasoning_efforts:['xhigh', 'high']},
+]).reasoning_efforts));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), ["high", "xhigh"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_inspection_reports_exact_values_and_missing_days(self):
+        index_match = re.search(
+            r"function efficiencyChartPointerIndex\(.*?\n\}", self.page, re.DOTALL,
+        )
+        detail_match = re.search(
+            r"function efficiencyChartInspection\(.*?\n\}", self.page, re.DOTALL,
+        )
+        presentation_match = re.search(
+            r"function efficiencyChartMetricPresentation\(.*?\n\}", self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(index_match)
+        self.assertIsNotNone(detail_match)
+        self.assertIsNotNone(presentation_match)
+        script = "\n".join((
+            "function compactNumber(value){return String(Math.round(value));}",
+            "function pct(value){return (value*100).toFixed(1)+'%';}",
+            "function efficiencyDecimal(value){return String(value)+'x';}",
+            index_match.group(0), presentation_match.group(0), detail_match.group(0), r"""
+const samples=[
+  {day:'2026-08-25',index:0,value:5143.4},
+  {day:'2026-08-26',index:1,value:null},
+  {day:'2026-08-27',index:2,value:.3421},
+];
+const rect={left:100,width:520};
+console.log(JSON.stringify({
+  first:efficiencyChartPointerIndex(109,rect,3),
+  middle:efficiencyChartPointerIndex(360,rect,3),
+  last:efficiencyChartPointerIndex(611,rect,3),
+  output:efficiencyChartInspection(samples[0],'output_per_dollar'),
+  missing:efficiencyChartInspection(samples[1],'output_per_dollar'),
+  reasoning:efficiencyChartInspection(samples[2],'reasoning_ratio'),
+}));
+""",
+        ))
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "first": 0,
+            "middle": 1,
+            "last": 2,
+            "output": {
+                "date": "Aug 25",
+                "value": "5,143 output tokens / $",
+            },
+            "missing": {"date": "Aug 26", "value": "No data"},
+            "reasoning": {"date": "Aug 27", "value": "34.2% reasoning"},
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_hover_survives_live_refresh(self):
+        names = (
+            "efficiencyChartPointerIndex",
+            "efficiencyChartMetricPresentation",
+            "efficiencyChartInspection",
+            "efficiencyChartAnnouncement",
+            "chartGapRuns",
+            "chartGapBridge",
+            "efficiencyChartSmoothPath",
+            "renderEfficiencyChart",
+        )
+        functions = []
+        for name in names:
+            match = re.search(
+                rf"function {name}\(.*?\n\}}", self.page, re.DOTALL,
+            )
+            self.assertIsNotNone(match)
+            functions.append(match.group(0))
+        script = "\n".join((*functions, r"""
+class AttrNode {
+  constructor(){this.attrs={};}
+  setAttribute(name,value){this.attrs[name]=String(value);}
+}
+class InspectNode extends AttrNode {
+  constructor(){super();this.line=new AttrNode();this.dot=new AttrNode();}
+  querySelector(selector){return selector==='line'?this.line:this.dot;}
+}
+class SvgNode extends AttrNode {
+  constructor(parent){super();this.parentElement=parent;this.dataset={};this.hovered=false;this.inspect=null;}
+  set innerHTML(value){this.html=value;this.inspect=new InspectNode();}
+  get innerHTML(){return this.html;}
+  querySelector(selector){return selector==='.efficiencyChartInspect'?this.inspect:null;}
+  getBoundingClientRect(){return {left:0,width:520};}
+  matches(selector){return selector===':hover'&&this.hovered;}
+}
+const tip={hidden:true,textContent:'',style:{}},status={textContent:''};
+const parent={querySelector(selector){return selector==='.efficiencyChartTip'?tip:status;}};
+const svg=new SvgNode(parent),$=()=>svg,esc=value=>String(value);
+const pct=value=>`${Math.round(value*100)}%`,compactNumber=value=>String(Math.round(value));
+const trend=[
+  {day:'2026-08-25',metrics:{output_per_dollar:5143.4}},
+  {day:'2026-08-26',metrics:{output_per_dollar:7777}},
+  {day:'2026-08-27',metrics:{output_per_dollar:9123}},
+];
+renderEfficiencyChart('chart',trend,'output_per_dollar','Output per covered dollar');
+svg.hovered=true;
+svg.onpointermove({clientX:260});
+const first={hidden:tip.hidden,text:tip.textContent,ratio:svg.dataset.efficiencyHoverRatio};
+renderEfficiencyChart('chart',trend,'output_per_dollar','Output per covered dollar');
+const rerender={hidden:tip.hidden,text:tip.textContent,visibility:svg.inspect.attrs.visibility};
+svg.onpointermove({clientX:510});
+const moved={hidden:tip.hidden,text:tip.textContent};
+svg.hovered=false;
+svg.onpointerleave();
+const left={hidden:tip.hidden,ratio:svg.dataset.efficiencyHoverRatio||null,visibility:svg.inspect.attrs.visibility};
+svg.hovered=true;
+svg.dataset.efficiencyHoverRatio='0.5';
+renderEfficiencyChart('chart',[],'output_per_dollar','Output per covered dollar');
+const empty={hidden:tip.hidden,ratio:svg.dataset.efficiencyHoverRatio||null};
+console.log(JSON.stringify({first,rerender,moved,left,empty}));
+"""))
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "first": {
+                "hidden": False,
+                "text": "Aug 26 · 7,777 output tokens / $",
+                "ratio": "0.5",
+            },
+            "rerender": {
+                "hidden": False,
+                "text": "Aug 26 · 7,777 output tokens / $",
+                "visibility": "visible",
+            },
+            "moved": {
+                "hidden": False,
+                "text": "Aug 27 · 9,123 output tokens / $",
+            },
+            "left": {"hidden": True, "ratio": None, "visibility": "hidden"},
+            "empty": {"hidden": True, "ratio": None},
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_inspection_is_keyboard_accessible(self):
+        match = re.search(
+            r"function efficiencyChartKeyIndex\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match)
+        script = match.group(0) + r"""
+console.log(JSON.stringify({
+  left:efficiencyChartKeyIndex('ArrowLeft',2,5),
+  leftBound:efficiencyChartKeyIndex('ArrowLeft',0,5),
+  right:efficiencyChartKeyIndex('ArrowRight',2,5),
+  rightBound:efficiencyChartKeyIndex('ArrowRight',4,5),
+  home:efficiencyChartKeyIndex('Home',3,5),
+  end:efficiencyChartKeyIndex('End',1,5),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "left": 1,
+            "leftBound": 0,
+            "right": 3,
+            "rightBound": 4,
+            "home": 0,
+            "end": 4,
+        })
+        for marker in (
+            "tabindex=0",
+            "aria-live=polite",
+            "svg.onfocus",
+            "svg.onkeydown",
+            "svg.onblur",
+            "Use Left and Right arrow keys to inspect daily values.",
+        ):
+            self.assertIn(marker, self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_chart_accessibility_uses_one_fresh_announcement_path(self):
+        match = re.search(
+            r"function efficiencyChartAnnouncement\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match)
+        script = match.group(0) + r"""
+const detail={date:'Aug 26',value:'No data'};
+console.log(JSON.stringify({
+  keyboard:efficiencyChartAnnouncement(detail,true),
+  pointer:efficiencyChartAnnouncement(detail,false),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "keyboard": "Aug 26 · No data",
+            "pointer": "",
+        })
+        self.assertNotIn("aria-describedby=e-output-dollar-status", self.page)
+        self.assertNotIn("aria-describedby=e-reasoning-status", self.page)
+        self.assertIn(
+            "status.textContent=efficiencyChartAnnouncement(detail,announce)",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_reasoning_cell_falls_back_to_measured_thinking_share(self):
+        match = re.search(
+            r"function efficiencyReasoningPresentation\(.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(match)
+        script = r"""
+const f=value=>Math.round(value||0).toLocaleString('en-US');
+const pct=value=>Math.round((value||0)*100)+'%';
+""" + match.group(0) + r"""
+console.log(JSON.stringify({
+  exact:efficiencyReasoningPresentation(
+    {executions:10,reasoning_executions:8,thinking_executions:8},
+    {reasoning_ratio:.375}
+  ),
+  thinking:efficiencyReasoningPresentation(
+    {executions:960,reasoning_executions:0,thinking_executions:402},
+    {reasoning_ratio:null}
+  ),
+  missing:efficiencyReasoningPresentation(
+    {executions:4,reasoning_executions:0,thinking_executions:0},
+    {reasoning_ratio:null}
+  ),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "exact": {"value": "38%", "note": "8 / 10 exec"},
+            "thinking": {
+                "value": "42% thinking execs",
+                "note": "token ratio unavailable",
+            },
+            "missing": {"value": "--", "note": "unavailable"},
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_efficiency_presentation_preserves_coverage_and_thinking_fallback(self):
+        metric_match = re.search(
+            r"function efficiencyMetrics\(row\)\{.*?\n\}", self.page, re.DOTALL,
+        )
+        reasoning_match = re.search(
+            r"function efficiencyReasoningPresentation\(.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        summary_match = re.search(
+            r"function efficiencySummaryPresentation\(.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(metric_match)
+        self.assertIsNotNone(reasoning_match)
+        self.assertIsNotNone(summary_match)
+        script = r"""
+const f=value=>Math.round(value||0).toLocaleString('en-US');
+const pct=value=>Math.round((value||0)*100)+'%';
+const compactNumber=value=>Math.round(value||0).toLocaleString('en-US');
+const hasLocalEstimate=row=>Boolean(row?.estimated);
+""" + "\n".join((
+            metric_match.group(0), reasoning_match.group(0), summary_match.group(0),
+        )) + r"""
+const exact=efficiencySummaryPresentation({
+  output_tokens:200,cost:2,executions:10,token_covered_executions:10,
+  cost_covered_executions:10,cost_covered_output_tokens:200,cost_covered_cost:2,
+  reasoning_tokens:30,reasoning_output_tokens:80,reasoning_executions:8,
+  thinking_executions:8,availability:{tokens:true,output_tokens:true,cost:true,reasoning_tokens:true},
+  coverage:{cost:{complete:true}},
+});
+const thinking=efficiencySummaryPresentation({
+  output_tokens:100,cost:1,executions:10,token_covered_executions:10,
+  cost_covered_executions:8,cost_covered_output_tokens:80,cost_covered_cost:1,
+  reasoning_executions:0,thinking_executions:4,
+  availability:{tokens:true,output_tokens:true,cost:true,reasoning_tokens:false},
+  coverage:{cost:{complete:false}},estimated:true,
+});
+const missing=efficiencySummaryPresentation({
+  executions:2,availability:{tokens:false,output_tokens:false,cost:false,reasoning_tokens:false},
+});
+console.log(JSON.stringify({exact,thinking,missing}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "exact": {
+                "output": {"value": "100 / $", "note": "covered"},
+                "reasoning": {"value": "38%", "note": "8 / 10 exec"},
+            },
+            "thinking": {
+                "output": {"value": "80 / $", "note": "partial · local est"},
+                "reasoning": {
+                    "value": "40% thinking execs",
+                    "note": "token ratio unavailable · local est",
+                },
+            },
+            "missing": {
+                "output": {"value": "--", "note": "unavailable"},
+                "reasoning": {"value": "--", "note": "unavailable"},
+            },
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_only_marks_thinking_token_splits_unavailable_when_uncovered(self):
+        match = re.search(
+            r"function thinkingUnavailableExecutions\(row\)\{.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(match)
+        script = match.group(0) + r"""
+console.log(JSON.stringify({
+  unavailable:thinkingUnavailableExecutions({thinking_executions:2,thinking_covered_executions:0,reasoning_executions:0}),
+  partial:thinkingUnavailableExecutions({thinking_executions:3,thinking_covered_executions:1,reasoning_executions:1}),
+  exact:thinkingUnavailableExecutions({thinking_executions:1,thinking_covered_executions:1,reasoning_executions:1}),
+  unrelated:thinkingUnavailableExecutions({thinking_executions:1,thinking_covered_executions:0,reasoning_executions:4}),
+  codexOnly:thinkingUnavailableExecutions({thinking_executions:0,thinking_covered_executions:0,reasoning_executions:4}),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "unavailable": 2,
+            "partial": 2,
+            "exact": 0,
+            "unrelated": 1,
+            "codexOnly": 0,
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_efficiency_model_table_defaults_to_spend_descending_and_sorts_nulls_last(self):
+        metric_match = re.search(
+            r"function efficiencyMetrics\(row\)\{.*?\n\}", self.page, re.DOTALL,
+        )
+        value_match = re.search(
+            r"function efficiencySortValue\(row,key\)\{.*?\n\}", self.page, re.DOTALL,
+        )
+        sort_match = re.search(
+            r"function sortEfficiencyRows\(rows,sort=efficiencySort\)\{.*?\n\}",
+            self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(metric_match)
+        self.assertIsNotNone(value_match)
+        self.assertIsNotNone(sort_match)
+        script = "\n".join((
+            metric_match.group(0),
+            "const modelRuntimeLabel=row=>`${row.model} · ${row.runtime}`;",
+            "const efficiencySort={key:'cost',direction:'desc'};",
+            value_match.group(0), sort_match.group(0),
+            r"""
+const rows=[
+  {model:'low',runtime:'Claude Code',window:{cost:1,availability:{cost:true}}},
+  {model:'missing',runtime:'Claude Code',window:{cost:0,availability:{cost:false}}},
+  {model:'high',runtime:'Codex',window:{cost:4,availability:{cost:true}}},
+];
+console.log(JSON.stringify({
+  spend:sortEfficiencyRows(rows).map(row=>row.model),
+  efficiency:sortEfficiencyRows(rows,{key:'output_per_dollar',direction:'desc'}).map(row=>row.model),
+}));
+""",
+        ))
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["spend"], ["high", "low", "missing"])
+        self.assertEqual(payload["efficiency"][-1], "missing")
+
+    def test_efficiency_model_filter_stacks_above_its_chart(self):
+        self.assertIn(
+            ".spectrumPageHeadFrame:has(.modelControls){z-index:10}",
+            self.page,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_models.py b/tests/test_dashboard_models.py
new file mode 100644
index 00000000..a792537b
--- /dev/null
+++ b/tests/test_dashboard_models.py
@@ -0,0 +1,877 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardModelsLayoutTests(DashboardLayoutCase):
+    def test_model_stats_is_a_first_class_top_level_route(self):
+        for marker in ("id=tab-models", "id=view-models", "id=m-speed", "id=m-chart",
+                       "id=m-table", "renderModelStats", "aggregateModelDays"):
+            self.assertIn(marker, self.page)
+        self.assertRegex(self.page, r"id=tab-models[^>]*>.*?<span class=tabLabel>Models</span>")
+        self.assertIn("if(routedSessionId()&&history.pushState)", self.page)
+        self.assertIn("$('tab-models').onclick=()=>openTopLevelRoute('models')", self.page)
+        self.assertIn("if(h==='models'||h==='frustration')", self.page)
+        self.assertLess(self.page.index("id=tab-session"), self.page.index("id=tab-models"))
+        self.assertNotIn("Timing evidence", self.page)
+        diagnostics = self.page.split("id=m-diagnostics", 1)[1].split("</details>", 1)[0]
+        self.assertIn("cross-runtime output pace remains diagnostic rather than a model verdict.", diagnostics)
+        self.assertIn("<summary><span>Speed &amp; timing diagnostics</span></summary>", diagnostics)
+        self.assertIn("<tr><td colspan=10><div class=\"modelEmpty emptyState\">No model activity in this window</div>", self.page)
+
+    def test_models_page_is_a_ranked_spend_leaderboard(self):
+        models = self.page.split("id=view-models", 1)[1].split("id=view-daily", 1)[0]
+        order = [models.index(marker) for marker in (
+            "id=m-spend", "id=m-mix", "id=m-speedchart", "id=m-table", "id=m-diagnostics",
+        )]
+        self.assertEqual(order, sorted(order))
+        for marker in (
+            "Where your spend goes", "Model mix over time", "data-model-mix=cost",
+            "data-model-mix=output", "data-model-mix=executions",
+            "Speed &amp; timing diagnostics",
+        ):
+            self.assertIn(marker, models)
+        diagnostics = models.split("id=m-diagnostics", 1)[1]
+        speed_block = diagnostics.split("id=m-change-label", 1)[0]
+        self.assertIn("id=m-speed-label", speed_block)
+        self.assertIn("cross-runtime output pace remains diagnostic rather than a model verdict.", speed_block)
+        for marker in ("id=m-speed", "id=m-change", "id=m-wait", "id=m-chart", "id=m-metric"):
+            self.assertIn(marker, diagnostics)
+        self.assertNotIn("id=m-input", models)
+        self.assertNotIn("Logs (all)", models)
+        table_head = models.split("id=m-table><thead>", 1)[1].split("</thead>", 1)[0]
+        self.assertEqual(table_head.count("<th"), 10)
+        self.assertEqual(
+            [key for key in ("model", "cost", "cost_per_exec", "cache", "executions", "output", "speed", "wait", "pushback")
+             if f"data-model-sort={key} data-tip=" in table_head],
+            ["model", "cost", "cost_per_exec", "cache", "executions", "output", "speed", "wait", "pushback"],
+        )
+        self.assertIn("does not change with the History filter", table_head)
+        self.assertNotIn("<span class=\"fieldtip modelHelp\" tabindex=0", table_head)
+        self.assertEqual(table_head.count('<button class="modelSortBtn fieldtip modelHelp" type=button'), 9)
+        for marker in (
+            "const MODEL_SORT_KEYS=['model','cost','cost_per_exec','cache','executions','output','speed','wait','pushback'];",
+            "localStorage.setItem('tm_model_speed_models',JSON.stringify(modelSpeedSelection))",
+            "localStorage.removeItem('tm_model_speed_models')",
+            "renderModelSpeedChart(groups,ranking,top,rangeWindow);",
+            "localStorage.setItem('tm_model_sort',JSON.stringify(modelSort))",
+            "localStorage.setItem('tm_model_mix_metric',metric)",
+            "localStorage.setItem('tm_model_diagnostics_open'",
+            "without cost data ${uncosted===1?'is':'are'} excluded, not counted as $0.",
+            "th.setAttribute('aria-sort'",
+            "aria-expanded=${expanded}",
+            "data-model-clear",
+            "setLogHtml($('m-table').querySelector('tbody'),",
+            "const focus=modelFocusKey();", "restoreModelFocus(focus);",
+            "perExecPartial?'*':''",
+            '<div class=modelSpendBar id=m-spend-bar role=group',
+        ):
+            self.assertIn(marker, self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_models_leaderboard_groups_variants_and_never_counts_missing_cost_as_zero(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+function constLine(name){{const start=page.indexOf(`const ${{name}}=`);if(start<0)throw Error(`missing ${{name}}`);return page.slice(start,page.indexOf('\\n',start));}}
+['MODEL_COUNTER_KEYS','MODEL_ARRAY_KEYS','metricAvailable','metricPartial','usageProvenance','usageBasis','hasLocalEstimate'].forEach(name=>eval(constLine(name).replace(/^const /,'globalThis.')));
+['modelWaitDistribution','modelMedian','modelDayInRange','aggregateModelDays','efficiencyMetrics','modelGroupKey','modelGroupRows','modelBoardValue','sortModelBoard','modelSpendRanking'].forEach(name=>eval(`globalThis.${{name}}=${{extract(name)}}`));
+globalThis.modelSort={{key:'cost',direction:'desc'}};
+const day=(d,extra)=>({{day:d,availability:{{tokens:true,cost:true,cache:true}},executions:10,output_tokens:100,input_tokens:1000,cache_read_tokens:800,cache_covered_input_tokens:1000,wait_samples:1,wait_seconds:5,wait_durations_s:[5],...extra}});
+const models=[
+ {{id:'sol::Codex::high',model:'sol',runtime:'Codex',reasoning_effort:'high',logs:3,daily:[day('2026-09-30',{{cost:6}}),day('2026-01-01',{{cost:100}})]}},
+ {{id:'sol::Codex::xhigh',model:'sol',runtime:'Codex',reasoning_effort:'xhigh',logs:2,daily:[day('2026-09-30',{{cost:4}})]}},
+ {{id:'sol::Cursor',model:'sol',runtime:'Cursor',logs:1,daily:[day('2026-09-30',{{cost:0,availability:{{tokens:true,cost:false}}}})]}},
+ {{id:'opus::Claude-3P',model:'opus',runtime:'Claude-3P',logs:5,daily:[day('2026-09-30',{{cost:7,executions:2}})]}},
+ {{id:'part::Codex',model:'part',runtime:'Codex',logs:1,daily:[day('2026-09-30',{{cost:6,executions:10,cost_covered_executions:6,cost_covered_cost:6}})]}},
+ {{id:'big::Cursor',model:'big',runtime:'Cursor',logs:1,daily:[day('2026-09-30',{{output_tokens:999999,availability:{{tokens:true,cost:false}}}})]}},
+];
+const window={{days:['2026-09-30'],daySet:new Set(['2026-09-30'])}};
+const groups=modelGroupRows(models,window),byKey=Object.fromEntries(groups.map(g=>[g.key,g]));
+const ranking=modelSpendRanking(groups);
+process.stdout.write(JSON.stringify({{
+ keys:groups.map(g=>g.key).sort(),
+ solVariants:byKey['sol::Codex'].variants.length,
+ solCost:modelBoardValue(byKey['sol::Codex'],'cost'),
+ cursorCost:modelBoardValue(byKey['sol::Cursor'],'cost'),
+ opusPerExec:modelBoardValue(byKey['opus::Claude-3P'],'cost_per_exec'),
+ partialPerExec:modelBoardValue(byKey['part::Codex'],'cost_per_exec'),
+ speedNone:modelBoardValue(byKey['sol::Codex'],'speed'),
+ solCache:modelBoardValue(byKey['sol::Codex'],'cache'),
+ ranking:ranking.map(g=>g.key),
+ byExecAsc:sortModelBoard(groups,{{key:'executions',direction:'asc'}}).map(g=>g.key),
+ byCostAsc:sortModelBoard(groups,{{key:'cost',direction:'asc'}}).map(g=>g.key),
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload["keys"], ["big::Cursor", "opus::Claude-3P", "part::Codex", "sol::Codex", "sol::Cursor"])
+        self.assertEqual(payload["solVariants"], 2)
+        self.assertEqual(payload["solCost"], 10)
+        self.assertIsNone(payload["cursorCost"])
+        self.assertEqual(payload["opusPerExec"], 3.5)
+        self.assertAlmostEqual(payload["solCache"], 0.8)
+        self.assertEqual(payload["partialPerExec"], 1.0)
+        self.assertIsNone(payload["speedNone"])
+        self.assertEqual(payload["ranking"], ["sol::Codex", "opus::Claude-3P", "part::Codex", "big::Cursor", "sol::Cursor"])
+        self.assertEqual(payload["byExecAsc"][0], "opus::Claude-3P")
+        self.assertEqual(set(payload["byCostAsc"][-2:]), {"sol::Cursor", "big::Cursor"})
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_models_speed_series_is_time_weighted_smoothed_and_defaults_to_timed_top_five(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+['localDateKey','modelCalendarDays','modelSpeedBasis','modelSpeedSeries','modelSpeedDefaultKeys','modelSmoothPath'].forEach(name=>eval(`globalThis.${{name}}=${{extract(name)}}`));
+const days=['d1','d2','d3','d4','d5'];
+const daily=[
+ {{day:'d1',timed_output_tokens:100,timed_seconds:10,timed_samples:1}},
+ {{day:'d2',timed_output_tokens:900,timed_seconds:30,timed_samples:3}},
+ {{day:'d4',timed_output_tokens:50,timed_seconds:5,timed_samples:1,tool_free_output_tokens:40,tool_free_seconds:2,tool_free_samples:1}},
+ {{day:'d5',timed_output_tokens:0,timed_seconds:0,timed_samples:0}},
+];
+const series=modelSpeedSeries(daily,days,'timed');
+const toolFree=modelSpeedSeries(daily,days,'tool_free');
+const ranking=[1,2,3,4,5,6,7].map(n=>({{key:'g'+n,window:{{available:n!==2}}}}));
+const path=modelSmoothPath([[0,10],[50,20],[100,15]]);
+process.stdout.write(JSON.stringify({{
+ series,toolFree,
+ basisTimed:modelSpeedBasis({{tool_free_samples:0,tool_free_seconds:0}}),
+ basisTool:modelSpeedBasis({{tool_free_samples:2,tool_free_seconds:4}}),
+ defaults:modelSpeedDefaultKeys(ranking),
+ path,single:modelSmoothPath([[0,1]]),
+ calendar:modelCalendarDays(['2026-05-03','2026-05-01','bad','2026-05-01']),
+ sparse:modelSpeedSeries([{{day:'2026-05-01',timed_output_tokens:100,timed_seconds:10}},{{day:'2026-05-03',timed_output_tokens:900,timed_seconds:30}}],modelCalendarDays(['2026-05-01','2026-05-03']),'timed'),
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual([point["day"] for point in payload["series"]], ["d1", "d2", "d4"])
+        d1, d2, d4 = payload["series"]
+        self.assertAlmostEqual(d1["value"], 1000 / 40)
+        self.assertAlmostEqual(d2["value"], 1000 / 40)
+        self.assertAlmostEqual(d4["value"], 50 / 5)
+        self.assertAlmostEqual(d2["raw"], 30)
+        self.assertEqual(d2["samples"], 3)
+        self.assertEqual([point["day"] for point in payload["toolFree"]], ["d4"])
+        self.assertAlmostEqual(payload["toolFree"][0]["value"], 20)
+        self.assertEqual(payload["basisTimed"], "timed")
+        self.assertEqual(payload["basisTool"], "tool_free")
+        self.assertEqual(payload["defaults"], ["g1", "g3", "g4", "g5", "g6"])
+        self.assertTrue(payload["path"].startswith("M0.0,10.0 C"))
+        self.assertEqual(payload["path"].count(" C"), 2)
+        self.assertEqual(payload["single"], "")
+        self.assertEqual(payload["calendar"], ["2026-05-01", "2026-05-02", "2026-05-03"])
+        self.assertEqual([round(point["value"], 6) for point in payload["sparse"]], [10.0, 30.0])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_chart_gap_runs_split_daily_points_and_bridge_only_interior_gaps(self):
+        payload = self.run_chart_gap_harness(r"""
+load(['chartGapRuns','chartGapBridge']);
+const runs=chartGapRuns([{index:1},{index:2},{index:4},{index:6},{index:7}]);
+process.stdout.write(JSON.stringify({
+ segments:runs.segments.map(run=>run.map(point=>point.index)),
+ bridges:runs.bridges.map(pair=>pair.map(point=>point.index)),
+ edges:chartGapRuns([{index:3},{index:4}]),
+ empty:chartGapRuns([]),
+ bridge:chartGapBridge(1,2.25,30,40),
+}));
+""")
+        self.assertEqual(payload["segments"], [[1, 2], [4], [6, 7]])
+        self.assertEqual(payload["bridges"], [[2, 4], [4, 6]])
+        self.assertEqual(payload["edges"]["bridges"], [])
+        self.assertEqual(len(payload["edges"]["segments"]), 1)
+        self.assertEqual(payload["empty"], {"segments": [], "bridges": []})
+        self.assertEqual(
+            payload["bridge"],
+            '<line class=chartGapBridge x1="1.0" y1="2.3" x2="30.0" y2="40.0"/>',
+        )
+        self.assertIn(":where(.chartGapBridge){", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_model_speed_and_trend_charts_bridge_gaps_instead_of_smoothing_through_them(self):
+        payload = self.run_chart_gap_harness(r"""
+load(['chartGapRuns','chartGapBridge','modelSpeedSeries','modelSpeedBasis','modelSpeedDefaultKeys','modelSmoothPath','renderModelSpeedChart','modelTrendRowHasUsage','modelTrendPaint','modelTokensPerExecution','drawModelTrend']);
+eval(page.slice(page.indexOf('const metricAvailable='),page.indexOf('\n',page.indexOf('const metricAvailable='))).replace(/^const /,'globalThis.'));
+const nodes={};
+function node(id){return nodes[id]||(nodes[id]={id,style:{},dataset:{},textContent:'',innerHTML:'',offsetWidth:100,offsetHeight:40,setAttribute(){},parentElement:{getBoundingClientRect(){return {left:0,top:0,width:1040};}},querySelectorAll:()=>[]});}
+Object.assign(globalThis,{$:node,esc:value=>String(value),f:value=>String(value),countWord:(n,word)=>word,setLogHtml(){},speedFmt:value=>value.toFixed(1),waitFmt:String,compactNumber:value=>String(Math.round(value)),modelScopeLabel:()=>'all',modelRangeLabel:()=>'8 days',modelRange:'8',modelSpeedSelection:null,MODEL_SPEED_MAX_SERIES:8,MODEL_SPEED_EXTRA_COLORS:['c2'],modelRankedColors:top=>new Map(top.map(group=>[group.key,'c1'])),CHART:{lbl:'lbl',grid:'grid',ink:'ink'},svgTextPx:()=>12,MODEL_OUTPUT_BAR_FILL:'bar',MODEL_OUTPUT_BAR_STROKE:'barStroke',modelTrendMetric:'speed'});
+const start=page.indexOf('const MODEL_TREND_METRICS=');eval('globalThis.MODEL_TREND_METRICS='+page.slice(start+'const MODEL_TREND_METRICS='.length,page.indexOf('\n};',start)+3));
+const days=['d0','d1','d2','d3','d4','d5','d6','d7'],timed=[1,2,4,6];
+const daily=timed.map(index=>({day:days[index],timed_output_tokens:100*(index+1),timed_seconds:10,timed_samples:1}));
+const group={key:'g',model:'m',runtime:'Codex',estimated:false,daily,window:{available:true,output_tps:10}};
+const speedHits=[];node('m-speedchart-svg').querySelectorAll=()=>days.map((_,index)=>{const hit={dataset:{speedDay:String(index)}};speedHits.push(hit);return hit;});
+renderModelSpeedChart([group],[group],[group],{days});
+const speed=node('m-speedchart-svg').innerHTML,speedTip=node('m-speedchart-tip');
+speedHits[3].onpointerenter({clientX:10,clientY:10});const speedGapTip=speedTip.style.display==='block'?speedTip.innerHTML:'hidden';
+const trendHits=[];node('m-chart').querySelectorAll=()=>days.map(()=>{const hit={};trendHits.push(hit);return hit;});
+const point=index=>timed.includes(index)?{day:days[index],executions:1,output_tokens:100,availability:{tokens:true},perf:{available:true,output_tps:index+1}}:{day:days[index],perf:{available:false}};
+drawModelTrend({days,series:[{id:'g',model:'m · Codex',color:'c1',estimated:false,points:days.map((_,index)=>point(index))}]});
+const trend=node('m-chart').innerHTML,trendTip=node('m-chart-tip');
+trendHits[0].onpointerenter({clientX:10,clientY:10});const trendGapTip=trendTip.style.display==='block'?trendTip.innerHTML:'hidden';
+process.stdout.write(JSON.stringify({
+ speedBridges:attrs(speed,'line','chartGapBridge').length,
+ speedCurves:(speed.match(/<path d="M[^"]*"/g)||[]).map(path=>(path.match(/ C/g)||[]).length),
+ speedDots:(speed.match(/<circle /g)||[]).length,
+ speedGapTip,
+ trendBridges:attrs(trend,'line','chartGapBridge').length,
+ trendLines:(trend.match(/<path d="M[^"]*"/g)||[]).map(path=>(path.match(/ L/g)||[]).length),
+ trendDots:(trend.match(/<circle /g)||[]).length,
+ trendGapTip,
+}));
+""")
+        self.assertEqual(payload["speedBridges"], 2)
+        self.assertEqual(payload["speedCurves"], [1], "only the d1-d2 run is a solid curve")
+        self.assertEqual(payload["speedDots"], 2, "isolated d4 and d6 render as dots")
+        self.assertIn("No data", payload["speedGapTip"])
+        self.assertIn("d3", payload["speedGapTip"])
+        self.assertEqual(payload["trendBridges"], 2)
+        self.assertEqual(payload["trendLines"], [1])
+        self.assertEqual(payload["trendDots"], 4)
+        self.assertIn("No data", payload["trendGapTip"])
+        self.assertIn("d0", payload["trendGapTip"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_models_focus_restore_keeps_the_focused_control_and_scopes_to_its_container(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const start=page.indexOf('const MODEL_FOCUS_KEYS=');eval('globalThis.MODEL_FOCUS_KEYS='+page.slice(start+'const MODEL_FOCUS_KEYS='.length,page.indexOf(';',start)));
+eval('globalThis.modelFocusKey='+extract('modelFocusKey'));eval('globalThis.restoreModelFocus='+extract('restoreModelFocus'));
+function node(id,dataset,parent){{const el={{id,dataset:dataset||{{}},parent,children:[],isConnected:true,label:id,
+ contains(other){{for(let cur=other;cur;cur=cur.parent)if(cur===this)return true;return false;}},
+ closest(sel){{const ids=sel.split(',').map(x=>x.trim().slice(1));for(let cur=this;cur;cur=cur.parent)if(ids.includes(cur.id))return cur;return null;}},
+ querySelectorAll(sel){{const attr=sel.slice(1,-1),key=attr.slice(5).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());const out=[];const walk=n=>{{n.children.forEach(c=>{{if(key in c.dataset)out.push(c);walk(c);}});}};walk(this);return out;}},
+ focus(){{document.activeElement=this;}}}};if(parent)parent.children.push(el);byId[id]=el;return el;}}
+const byId={{}};globalThis.document={{activeElement:null}};globalThis.$=id=>byId[id]||null;
+const view=node('view-models');const bar=node('m-spend-bar',{{}},view),legend=node('m-spend-legend',{{}},view),table=node('m-table',{{}},view);
+const seg=node('seg',{{modelIds:'a::Codex::high\\na::Codex::xhigh'}},bar),chip=node('chip',{{modelIds:'a::Codex::high\\na::Codex::xhigh'}},legend);
+const expand=node('expand-old',{{modelExpand:'a::Codex'}},table);
+const results={{}};
+chip.focus();let focus=modelFocusKey();restoreModelFocus(focus);results.chipUnchanged=document.activeElement.label;
+focus=modelFocusKey();chip.isConnected=false;legend.children=[];const chip2=node('chip-new',{{modelIds:chip.dataset.modelIds}},legend);restoreModelFocus(focus);results.chipRebuilt=document.activeElement.label;
+expand.focus();focus=modelFocusKey();expand.isConnected=false;table.children=[];node('expand-new',{{modelExpand:'a::Codex'}},table);restoreModelFocus(focus);results.expandRebuilt=document.activeElement.label;
+const outside=node('outside',{{modelIds:'x'}},null);outside.focus();results.outsideKey=modelFocusKey();
+process.stdout.write(JSON.stringify(results));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload["chipUnchanged"], "chip")
+        self.assertEqual(payload["chipRebuilt"], "chip-new")
+        self.assertEqual(payload["expandRebuilt"], "expand-new")
+        self.assertIsNone(payload["outsideKey"])
+
+    def test_models_table_labels_effort_qualified_runtime_rows(self):
+        self.assertIn(
+            "`${modelEffortLabel(only)} · ${f(only.logs)} ${countWord(only.logs,'log')}`",
+            self.page,
+        )
+        self.assertIn("<div class=modelVariantName>${esc(modelEffortLabel(variant))}<small>${f(variant.logs)} ${countWord(variant.logs,'log')}</small>", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_legacy_model_runtime_filter_expands_to_effort_rows(self):
+        match = re.search(
+            r"function migrateModelRuntimeFilters\(.*?\n\}", self.page, re.DOTALL,
+        )
+        self.assertIsNotNone(match, "Legacy model filters need effort-row migration")
+        script = match.group(0) + r"""
+const rows=[
+  {id:'gpt-5.6::Codex::high',model:'gpt-5.6',runtime:'Codex'},
+  {id:'gpt-5.6::Codex::xhigh',model:'gpt-5.6',runtime:'Codex'},
+  {id:'gpt-5.6::Codex::unavailable',model:'gpt-5.6',runtime:'Codex'},
+  {id:'gpt-5.6::Cursor::unavailable',model:'gpt-5.6',runtime:'Cursor'},
+];
+console.log(JSON.stringify({
+  legacy:migrateModelRuntimeFilters(['gpt-5.6::Codex'],rows),
+  unavailable:migrateModelRuntimeFilters(['gpt-5.6::Codex::unavailable'],rows),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "legacy": [
+                "gpt-5.6::Codex::high", "gpt-5.6::Codex::xhigh",
+                "gpt-5.6::Codex::unavailable",
+            ],
+            "unavailable": ["gpt-5.6::Codex::unavailable"],
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_model_effort_label_keeps_known_and_unavailable_budgets_separate(self):
+        match = re.search(r"function modelEffortLabel\(.*?\n\}", self.page, re.DOTALL)
+        self.assertIsNotNone(match, "Model rows need an explicit effort-group label")
+        script = match.group(0) + r"""
+console.log(JSON.stringify({
+  known:modelEffortLabel({reasoning_effort:'xhigh'}),
+  opus:modelEffortLabel({thinking_executions:2}),
+  missing:modelEffortLabel({}),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "known": "xhigh",
+            "opus": "thinking unavailable",
+            "missing": "unavailable",
+        })
+
+    def test_model_day_merge_preserves_partial_source_coverage(self):
+        merge_match = re.search(
+            r"function mergeModelDays\(models,window\)\{.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        aggregate_match = re.search(
+            r"function aggregateModelDays\(rows\)\{.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(merge_match, "dashboard needs the shared day merge")
+        self.assertIsNotNone(aggregate_match, "dashboard needs the shared day aggregate")
+        script = r"""
+const MODEL_COUNTER_KEYS=['cost','input_tokens','output_tokens','executions'];
+const MODEL_ARRAY_KEYS=[];
+const modelDayInRange=()=>true;
+const metricAvailable=(row,key)=>row.availability?.[key]===true;
+const metricPartial=(row,key)=>row.coverage?.[key]?.complete===false;
+const hasLocalEstimate=()=>false;
+const usageBasis=()=> 'reported';
+const modelWaitDistribution=()=>({median_wait_s:0,p95_wait_s:0});
+const modelMedian=()=>0;
+""" + aggregate_match.group(0) + "\n" + merge_match.group(0) + r"""
+const rows=mergeModelDays([{daily:[{
+  day:'2026-08-27',cost:1,input_tokens:10,output_tokens:2,executions:2,
+  availability:{tokens:true,input_tokens:true,output_tokens:false,cost:true,cache:true},
+  coverage:{
+    tokens:{complete:false},cost:{complete:false},cache:{complete:false},
+  },
+}]}],{});
+const selectedSession=aggregateModelDays([{
+  cost:1,input_tokens:10,output_tokens:4,executions:2,
+  cost_covered_executions:1,cost_covered_output_tokens:2,cost_covered_cost:.5,
+  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false},
+}]);
+console.log(JSON.stringify({merged:rows[0],total:aggregateModelDays(rows),selectedSession}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        coverage = payload["merged"]["coverage"]
+        self.assertFalse(coverage["tokens"]["complete"])
+        self.assertFalse(coverage["cost"]["complete"])
+        self.assertFalse(coverage["cache"]["complete"])
+        self.assertTrue(payload["merged"]["availability"]["input_tokens"])
+        self.assertFalse(payload["merged"]["availability"]["output_tokens"])
+        self.assertTrue(payload["total"]["availability"]["input_tokens"])
+        self.assertFalse(payload["total"]["availability"]["output_tokens"])
+        self.assertFalse(payload["selectedSession"]["coverage"]["cost"]["complete"])
+
+    def test_model_stats_supports_multi_model_comparison(self):
+        for marker in (
+            "id=m-model-picker", "id=m-model-options", "id=m-model-summary",
+            "tm_model_filters", "MODEL_COLORS", "buildModelTrend",
+            "bars show output", "observed tok/s",
+            "modelTipMetrics",
+            "Typical wait", "median wait", "human pause excluded",
+            "modelWaitDistribution", "wait_durations_s", "p95_wait_s",
+            "Matched pace", "renderMatchedPace", "modelRuntimeLabel",
+            "migrateModelRuntimeFilters", "Typical workload (approximate shape, not semantic difficulty)", "median_peak_input_tokens",
+            "95% CI", "Select 2 models", "TTFT unavailable",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn('id=m-model aria-label="Models filter"', self.page)
+        self.assertNotIn("Speed change", self.page)
+
+    def test_model_colors_encode_runtime_family_and_keep_volume_neutral(self):
+        """Flattening runtime families or recoloring volume bars breaks chart meaning."""
+        start = self.page.find("// model-color-logic-start")
+        end = self.page.find("// model-color-logic-end")
+        logic = self.page[start:end] if start >= 0 and end > start else ""
+        script = logic + """
+const names = [
+  'gpt-5.6-sol::Codex',
+  'gpt-5.6-terra::Codex',
+  'codex-auto-review::Codex',
+  'gpt-5.6-luna::Codex',
+  'claude-opus-4-8::Claude Code',
+  'claude-sonnet-5::Claude Code',
+  'claude-haiku-4-5::Claude-3P',
+  'claude-opus-4-8::Claude-3P',
+  'claude-sonnet-5::Claude-3P',
+  'composer-2.5::Cursor',
+  'claude-sonnet-4-6::Kiro',
+  'qwen3::OpenCode',
+  'other::Unknown',
+];
+console.log(JSON.stringify({
+  codex: [modelColor(names[2], names), modelColor(names[3], names), modelColor(names[0], names), modelColor(names[1], names)],
+  claude: [modelColor(names[4], names), modelColor(names[5], names)],
+  thirdParty: [modelColor(names[6], names), modelColor(names[7], names), modelColor(names[8], names)],
+  cursor: modelColor(names[9], names),
+  kiro: modelColor(names[10], names),
+  openCode: modelColor(names[11], names),
+  fallback: modelColor(names[12], names),
+  stable: modelColor(names[0], names) === modelColor(names[0], [...names].reverse()),
+  paint: modelTrendPaint('#FFAA64'),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), {
+            "codex": ["#6F9CFF", "#8EC5FF", "#4C86F0", "#B6CFFF"],
+            "claude": ["#E3825C", "#F4A26E"],
+            "thirdParty": ["#A46AF4", "#AD88F0", "#7459F0"],
+            "cursor": "#3CC6C0",
+            "kiro": "#E3CC5C",
+            "openCode": "#FF8FB8",
+            "fallback": "#A9B8C7",
+            "stable": True,
+            "paint": {
+                "barFill": "#536879",
+                "barStroke": "#7890A3",
+                "line": "#FFAA64",
+            },
+        })
+
+    def test_ranked_model_groups_get_distinct_family_shades(self):
+        """Top-ranked groups of one runtime must not share a color in Models charts."""
+        start = self.page.find("// model-color-logic-start")
+        end = self.page.find("// model-color-logic-end")
+        logic = self.page[start:end] if start >= 0 and end > start else ""
+        script = logic + """
+const groups = [
+  {key: 'a', ids: ['gpt-5.6-sol::Codex']},
+  {key: 'b', ids: ['claude-opus-4-8::Claude Code']},
+  {key: 'c', ids: ['gpt-5.6-terra::Codex']},
+  {key: 'd', ids: ['gpt-5.6-luna::Codex']},
+  {key: 'e', ids: ['gpt-6-sol::Codex']},
+];
+const colors = modelRankedColors(groups);
+console.log(JSON.stringify(groups.map(group => colors.get(group.key))));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        colors = json.loads(result.stdout)
+        self.assertEqual(colors, ["#6F9CFF", "#E3825C", "#8EC5FF", "#4C86F0", "#B6CFFF"])
+        self.assertEqual(len(set(colors)), 5)
+        single_runtime = logic + """
+const groups = ['a', 'b', 'c', 'd', 'e'].map(key => ({key, ids: [`model-${key}::Claude Code`]}));
+const colors = modelRankedColors(groups);
+console.log(JSON.stringify(groups.map(group => colors.get(group.key))));
+"""
+        result = subprocess.run(["node", "-e", single_runtime], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        colors = json.loads(result.stdout)
+        self.assertEqual(colors[0], "#E3825C")
+        self.assertEqual(len(set(colors)), 5)
+
+    def test_model_trend_omits_legend_and_limits_hover_to_relevant_metrics(self):
+        self.assertNotIn("id=m-legend", self.page)
+        self.assertNotIn("$('m-legend')", self.page)
+        for marker in (
+            "function modelTrendRowHasUsage(row)",
+            "Number(row?.input_tokens||0)>0",
+            "Number(row?.output_tokens||0)>0",
+            "Number(row?.executions||0)>0",
+            ".filter(item=>modelTrendRowHasUsage(item.row))",
+            "(rows.length?'':'<div class=r><span>No data</span></div>')",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn(
+            '<div class=modelTipName title="${esc(item.model)}"><i class=modelSwatch '
+            'style="background:${item.color}"></i>${esc(item.model)}</div>',
+            self.page,
+        )
+        model_trend = self.page.split("function drawModelTrend(chart){", 1)[1].split(
+            "function renderMatchedPace", 1
+        )[0]
+        for marker in (
+            "const outputAvailable=metricAvailable(item.row,'tokens')",
+            "const selectedAvailable=metric.available(item.row)",
+            "<small>output</small>", "<small>${esc(metric.note)}</small>",
+            "${outputAvailable?compactNumber(item.row.output_tokens||0):'--'}",
+            "${selectedAvailable?metric.format(metric.value(item.row)):'--'}",
+        ):
+            self.assertIn(marker, model_trend)
+        for marker in (
+            "<small>input</small>", "<small>executions</small>",
+            "<small>avg input</small>", "<small>avg output</small>",
+            "<small>tok/s</small>", "<small>typical wait</small>",
+        ):
+            self.assertNotIn(marker, model_trend)
+
+    def test_model_stats_supports_project_scoped_average_io_trends(self):
+        for marker in (
+            "id=m-project", "tm_model_project", "tm_model_project_filters",
+            "/model-stats?project=", "renderActiveModelStats",
+            "modelProjectRequest", "modelProjectLoadingKey",
+            "data-model-metric=avg_input", "data-model-metric=avg_output",
+            "MODEL_TREND_METRICS", "modelTokensPerExecution",
+            "Model trends", "avg input / execution", "avg output / execution",
+            "input / exec", "output / exec",
+            "Daily model ${metric.note} and output token volume",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("modelProjectCache.set(key,payload.model_stats)", self.page)
+        self.assertIn("request!==modelProjectRequest||project!==modelProject", self.page)
+        self.assertNotIn(
+            "$('m-trend-title').textContent=modelTrendMetric==='wait'",
+            self.page,
+        )
+
+    def test_model_filter_menus_stay_stable_during_live_refreshes(self):
+        for marker in (
+            "setLogSelectOptions(projectSelect,projectOptions,modelProject)",
+            "setLogHtml($('m-model-options'),modelPickerOptions)",
+            "function positionModelPickerMenu()",
+            "picker.classList.toggle('opensUp',opensUp)",
+            "$('m-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionModelPickerMenu))",
+            ":is(.modelHead,.efficiencyHead).spectrumPageHead{overflow:hidden;z-index:2}",
+            ".spectrumPageHeadFrame:has(.modelControls){z-index:10}",
+            ".modelPicker.opensUp .modelPickerMenu{top:auto;bottom:calc(100% + 6px)}",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_model_project_background_refresh_does_not_shift_the_page(self):
+        for marker in (
+            "function setModelProjectLoading(loading)",
+            "projectSelect.setAttribute('aria-busy','true')",
+            "setModelProjectLoading(false);",
+            "$('m-project-status').textContent='';",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("Loading ${project}", self.page)
+
+    def test_model_trend_hover_panel_is_scrollable_and_pointer_stable(self):
+        model_trend = self.page.split("function drawModelTrend(chart){", 1)[1].split(
+            "function renderMatchedPace", 1
+        )[0]
+        for marker in (
+            '#m-chart-tip{pointer-events:auto;overscroll-behavior:contain;',
+            "scrollbar-gutter:stable",
+            '#m-chart-tip .h{position:sticky;top:0',
+            'id=m-chart-tip tabindex=0 aria-label="Model details for hovered day"',
+            "const scheduleTipHide=()=>",
+            "setTimeout(hideTip,180)",
+            "hit.onpointerleave=scheduleTipHide",
+            "tip.onpointerenter=cancelTipHide",
+            "tip.onpointerleave=scheduleTipHide",
+            "rightX+tip.offsetWidth<=rect.width-8",
+            "if(dayChanged)tip.scrollTop=0",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("hit.onpointerleave=()=>tip.style.display='none'", model_trend)
+
+    def test_wait_time_is_first_class_across_current_logs_and_models(self):
+        for marker in (
+            "data-chart=wait", "drawWaitChart", "data-gsort=wait",
+            "id=lf-wait", "id=m-wait", "id=m-metric", "data-model-metric=wait",
+            "Prompt-to-completed-response", "lower is better",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("wait_time?.total_s", self.page)
+        self.assertIn("CURRENT?.wait_time?.samples", self.page)
+
+    def test_models_history_supports_exact_local_days(self):
+        history = self.page.split(
+            'id=m-range aria-label="Models history range"', 1
+        )[1].split("</select>", 1)[0]
+        expected = (
+            '<option value=today>Today</option>',
+            '<option value=yesterday>Yesterday</option>',
+            '<option value=7>7 days</option>',
+            '<option value=30 selected>30 days</option>',
+            '<option value=90>90 days</option>',
+            '<option value=month>Month</option>',
+            '<option value=last_month>Last month</option>',
+            '<option value=all>All history</option>',
+        )
+        for option in expected:
+            self.assertIn(option, history)
+        self.assertEqual([history.index(option) for option in expected], sorted(
+            history.index(option) for option in expected
+        ))
+        for marker in (
+            "const MODEL_RANGES=['today','yesterday','7','30','90','month','last_month','all'];",
+            "const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all'];",
+            "const DELIVERY_RANGES=['today','yesterday','7','30','90','month','last_month'];",
+            "let deliveryRange=localStorage.getItem('tm_delivery_range')||'30';",
+            "if(!DELIVERY_RANGES.includes(deliveryRange)){deliveryRange='30';localStorage.setItem('tm_delivery_range',deliveryRange);}",
+            "if(!MODEL_RANGES.includes(modelRange))",
+            "function modelRangeWindow(range,now=new Date())",
+            "if(range==='today'||range==='yesterday')",
+            "function modelDayInRange(day,window)",
+            "mergeModelDays(selected,rangeWindow)",
+            "buildModelTrend(selected,rangeWindow,names)",
+            ".filter(day=>modelDayInRange(day.day,rangeWindow))",
+            "modelRangeLabel(modelRange)",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_model_pricing_is_editable_and_supports_new_models_in_settings(self):
+        for marker in (
+            "id=model-pricing-settings", "id=model-pricing-rows",
+            "id=model-price-scope", "id=model-price-scope-from-now",
+            "id=model-price-scope-from-date", "id=model-price-scope-all-history",
+            "value=from_now", "value=from_date", "value=all_history",
+            "id=model-price-effective-from", "id=model-price-scope-note",
+            "id=model-pricing-reviewed", "id=model-pricing-sources",
+            "id=model-price-add-form", "id=model-price-provider",
+            "id=model-price-model", "id=model-price-input",
+            "id=model-price-output", "id=model-price-cache-write",
+            "id=model-price-cache-read", "id=model-price-save-changes",
+            "id=model-price-save-changes type=button disabled",
+            "data-model-price-select", "data-model-price-lifecycle",
+            "function renderModelPricing",
+            "function modelPriceEffectiveFrom", "function updateModelPriceScope",
+            "function confirmModelPriceHistory",
+            "function saveModelPriceChanges", "/settings/model-pricing",
+            "apply_to_all_history", "From now", "From date", "All history",
+            "Save models", "Restore built-in price", "Remove custom model",
+            "changes",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("USD per 1 million tokens", self.page)
+        self.assertIn("By default, a change starts now and older sessions retain their earlier prices.", self.page)
+        self.assertIn("<span id=model-price-scope-note></span>", self.page)
+        self.assertIn("Choose the date", self.page)
+        self.assertIn("older session estimates", self.page)
+        self.assertIn(".modelPriceScope.history", self.page)
+        self.assertIn("badge.hidden=!hasCustomPricing", self.page)
+        self.assertIn("source==='built-in'?'':source", self.page)
+        self.assertIn("sourceLabel?`<span class=modelPriceSource>", self.page)
+        self.assertIn("row.overridden", self.page)
+        self.assertIn("pricing.sources", self.page)
+        self.assertIn("pricing.reviewed_on", self.page)
+        self.assertIn("modelPriceSelectionState(modelPricingSelected.size)", self.page)
+        self.assertIn("@media(max-width:700px){.modelPriceTableWrap{overflow:visible", self.page)
+        self.assertIn(".modelPriceTable{display:block;min-width:0", self.page)
+        self.assertIn("data-label=", self.page)
+        self.assertNotIn("data-model-price-save", self.page)
+        self.assertNotIn("Built-in defaults", self.page)
+        self.assertLess(
+            self.page.index("id=model-pricing-settings"),
+            self.page.index("id=delivery-settings"),
+        )
+        self.assertNotIn("id=cursor-source-status", self.page)
+        self.assertNotIn("Local trace source", self.page)
+        self.assertNotIn("function renderCursorSourceStatus", self.page)
+        self.assertIn("h==='settings-budgets'||h==='budgets'", self.page)
+        self.assertIn("'model-pricing':'model-pricing-settings'", self.page)
+        self.assertIn("if(card)scrollToSettingsCard(card);", self.page)
+
+    def test_model_pricing_groups_rows_by_provider_tabs_in_a_bounded_scroll(self):
+        pricing = self.page.split("id=model-pricing-settings", 1)[1].split(
+            "id=delivery-settings", 1,
+        )[0]
+        self.assertIn('id=model-price-tabs role=tablist', pricing)
+        self.assertIn('id=model-price-table-wrap', pricing)
+        self.assertLess(
+            pricing.index("id=model-price-tabs"),
+            pricing.index("id=model-pricing-rows"),
+        )
+        for marker in (
+            "function renderModelPriceTabs",
+            "function applyModelPriceTab",
+            "function selectModelPriceTab",
+            'data-model-price-provider="${esc(row.provider)}"',
+            "root.dataset.modelPriceProvider!==modelPricingTab",
+            "modelPricingSelected.has(modelPriceKey(row.provider,row.model))",
+            "event.key==='ArrowRight'",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertRegex(
+            self.page,
+            r"\.modelPriceTableWrap\{overflow:auto;max-height:min\(460px,58vh\)",
+        )
+        self.assertIn(".modelPriceTable tr[hidden]{display:none!important}", self.page)
+
+    def test_model_pricing_uses_explicit_row_selection_without_an_actions_column(self):
+        pricing = self.page.split("id=model-pricing-settings", 1)[1].split(
+            "id=delivery-settings", 1,
+        )[0]
+        for marker in (
+            "Apply to selected models",
+            "id=model-price-selection-count",
+            "No models selected",
+        ):
+            self.assertIn(marker, pricing)
+        for marker in (
+            "data-model-price-select",
+            "data-model-price-lifecycle",
+            "function setModelPriceSelected",
+            "function updateModelPriceSelectionState",
+            "modelPricingSelected",
+            "setModelPriceSelected(root,true,false)",
+            "keys=[...modelPricingSelected]",
+            "Restore built-in price",
+            "Remove custom model",
+            "Select ${row.model} for price update",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("<th class=num>Actions</th>", pricing)
+        self.assertNotIn('data-label="Action"', pricing)
+        self.assertNotIn("class=modelPriceActions", self.page)
+        self.assertIn(
+            ".modelPriceTable tr{display:grid;grid-template-columns:repeat(2,minmax(0,1fr))",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_model_price_selection_copy_tracks_the_selected_count(self):
+        match = re.search(
+            r"function modelPriceSelectionState\(count\)\{.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs one selection-copy helper")
+        script = match.group(0) + """
+console.log(JSON.stringify([
+  modelPriceSelectionState(0),
+  modelPriceSelectionState(1),
+  modelPriceSelectionState(3),
+]));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), [
+            {"summary": "No models selected", "button": "Save models", "disabled": True},
+            {"summary": "1 model selected", "button": "Save 1 model", "disabled": False},
+            {"summary": "3 models selected", "button": "Save 3 models", "disabled": False},
+        ])
+
+    def test_models_and_git_keep_secondary_copy_in_accessible_help(self):
+        models = self.page.split("id=view-models", 1)[1].split("id=view-daily", 1)[0]
+        for marker in (
+            "id=m-change-label", "id=m-wait-label",
+            "function setModelKpiHelp(labelId,detail)",
+            "setModelKpiHelp('m-speed-label',speedDetail)",
+            "setModelKpiHelp('m-wait-label',waitDetail)",
+            ".modelCellTip.fieldtip{display:table-cell}",
+            "class=\"fieldtip modelCellTip modelNameCell\" tabindex=0 data-tip=\"${esc(tip)}\" aria-description=\"${esc(tip)}\"",
+        ):
+            self.assertIn(marker, self.page)
+
+        git = self.page.split("id=view-git", 1)[1].split("id=view-learn", 1)[0]
+        hover_copy = (
+            "Period-specific spend and Git coverage; unavailable is not zero.",
+            "Added + deleted text lines per day. Select a day for spend.",
+            "Conversion, typical days, and outliers. Statistics only · no quality judgment.",
+            "Local Git only: hashed keys and line counts, never filenames or messages. Spend is estimated. Few lines make ratios noisy. Not a quality score.",
+            "Ranked local Git and covered-spend observations.",
+            "Median, range, and high day · ratios require 50+ pushed lines.",
+        )
+        for copy in hover_copy:
+            self.assertIn(f'aria-description="{copy}"', git)
+            self.assertIn(f'data-tip="{copy}"', git)
+            self.assertNotIn(f"<p>{copy}</p>", git)
+        # The local-only, privacy, estimate, and noise caveats live once in header help.
+        self.assertNotIn("class=deliveryFoot", git)
+        self.assertIn('class="fieldtip" id=d-evidence-ratio tabindex=0', git)
+        self.assertIn("function setDeliveryEvidenceRatio(text,detail)", self.page)
+        self.assertIn(
+            "setDeliveryEvidenceRatio(selected?`${comparable} / ${selected} comparable`",
+            self.page,
+        )
+        self.assertIn("ratio.dataset.tip=detail", self.page)
+
+    def test_model_comparison_has_tooltips(self):
+        for marker in (
+            "modelHelp", "id=m-coverage", 'aria-label="Output timing coverage"',
+            "same model can appear more than once",
+            "A ratio above 1 favors the named faster runtime",
+            "The median is primary because the average can be pulled upward",
+            "95% confidence interval", "Matched pace",
+            "model runtime", "Observed output pace", "Typical workload (approximate shape, not semantic difficulty)",
+            "Typical wait", "semantic difficulty",
+            "The 95% confidence interval crosses 1.00",
+            "$('m-coverage').setAttribute('aria-valuenow'",
+            "stripNativeFieldTipTitles", "removeAttribute('title')",
+            "aria-description",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn('<div class=filterControl><span>Models</span>', self.page)
+        self.assertIn('<label class=filterControl><span>History</span>', self.page)
+        self.assertNotIn("Select model-runtime histories, not just model names.", self.page)
+        self.assertNotIn("Limits tokens, executions, workload summaries", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_model_board_pushback_reads_work_labels_for_the_same_window(self):
+        script = f"""
+const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const constLine=name=>page.slice(page.indexOf(`const ${{name}}=`),page.indexOf(';',page.indexOf(`const ${{name}}=`))+1);
+const esc=s=>String(s),f=v=>String(v),pct=v=>Math.round(v*100)+'%';
+let modelRange='30',modelProject='p1',LATEST=null,rerenders=0,urls=[],payload={{}};
+const rerenderActiveModelStats=()=>{{rerenders++;}};
+const fetch=async url=>{{urls.push(url);const status=globalThis.statusOverride||200;return {{ok:status<400,status,json:async()=>payload}};}};
+eval(constLine('MODEL_PUSHBACK_PERIODS').replace(/^const /,'var '));
+let modelPushback={{key:'',state:'idle',rates:new Map()}},modelPushbackRequest=0;
+eval(['modelPushbackKey','modelPushbackFor','modelPushbackCell','modelBoardValue'].map(extract).join('\\n')+'\\nasync '+extract('loadModelPushback'));
+const group=(model,runtime)=>({{model,runtime,variants:[{{}}],window:{{}}}});
+(async()=>{{
+ const out={{}};
+ payload={{ok:true,settings:{{enabled:true}},insights:{{rework:{{models:[{{model:'opus',runtime:'Claude Code',rate:.14,samples:409,few_samples:false}},{{model:'mini',runtime:'Codex',rate:.25,samples:8,few_samples:true}}]}}}}}};
+ LATEST={{}};await loadModelPushback();
+ out.url=urls[0];out.rerenders=rerenders;
+ out.ready=modelPushbackCell(group('opus','Claude Code'));
+ out.few=modelPushbackCell(group('mini','Codex'));
+ out.otherRuntime=modelPushbackCell(group('opus','Codex'));
+ out.variant=modelPushbackCell({{model:'opus',runtime:'Claude Code',window:{{}}}});
+ out.sortValue=modelBoardValue(group('opus','Claude Code'),'pushback');
+ await loadModelPushback();out.cached=urls.length;
+ modelRange='yesterday';await loadModelPushback();
+ out.unsupported=modelPushbackCell(group('opus','Claude Code'));out.unsupportedFetches=urls.length;
+ modelRange='90';payload={{ok:true,settings:{{enabled:false}},insights:{{rework:{{models:[]}}}}}};await loadModelPushback();
+ out.url90=urls[urls.length-1];out.off=modelPushbackCell(group('opus','Claude Code'));
+ // Turning Work insights on shows up after the cache expires instead of sticking.
+ payload={{ok:true,settings:{{enabled:true}},insights:{{rework:{{models:[{{model:'opus',runtime:'Claude Code',rate:.5,samples:40,few_samples:false}}]}}}}}};
+ await loadModelPushback();out.beforeExpiry=urls.length;
+ modelPushback.at-=MODEL_PUSHBACK_TTL_MS+1;await loadModelPushback();
+ out.afterExpiry=urls.length;out.refreshed=modelPushbackCell(group('opus','Claude Code'));
+ modelRange='30';modelProject='';modelPushback.key='';
+ payload={{ok:false,error:'Work insights are available on macOS only.'}};
+ globalThis.statusOverride=404;await loadModelPushback();out.unsupportedHost=modelPushbackCell(group('opus','Claude Code'));
+ process.stdout.write(JSON.stringify(out));
+}})();
+"""
+        out = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
+        self.assertEqual(out["url"], "/work?months=30d&project=p1")
+        self.assertEqual(out["rerenders"], 1)
+        self.assertEqual(out["ready"], '<td class="num mono" title="57 of 409 labeled follow-ups pushed back · local model estimate">14%</td>')
+        self.assertIn(">25%*</td>", out["few"])
+        self.assertIn("modelMuted", out["few"])
+        # Models are scoped by runtime: the same name in another client has its own history.
+        self.assertIn(">--</td>", out["otherRuntime"])
+        self.assertEqual(out["variant"], '<td class="num modelMuted"></td>')
+        self.assertEqual(out["sortValue"], 0.14)
+        self.assertEqual(out["cached"], 1)
+        self.assertEqual(out["unsupportedFetches"], 1)
+        self.assertIn("not available for Yesterday or Last month", out["unsupported"])
+        self.assertEqual(out["url90"], "/work?months=90d&project=p1")
+        self.assertIn("Turn on Work insights", out["off"])
+        self.assertEqual(out["afterExpiry"], out["beforeExpiry"] + 1)
+        self.assertIn(">50%</td>", out["refreshed"])
+        self.assertIn("not available on this system", out["unsupportedHost"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_sessions_1.py b/tests/test_dashboard_sessions_1.py
new file mode 100644
index 00000000..fc0958b1
--- /dev/null
+++ b/tests/test_dashboard_sessions_1.py
@@ -0,0 +1,1195 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardSessionsLayoutTests1(DashboardLayoutCase):
+    def test_current_detail_excludes_all_secondary_panels(self):
+        self.assertNotIn("data-panel=efficiency", self.page)
+        self.assertNotIn("id=panel-efficiency", self.page)
+        self.assertIn("const PANEL_KEYS=['summary'];", self.page)
+        self.assertNotIn("efficiency:'summary'", self.page)
+
+    def test_sessions_surfaces_include_agent_activity_and_usage_statistics(self):
+        for expected in (
+            "id=agent-activity",
+            "id=agent-activity-tree",
+            "id=agent-attention-detail",
+            "id=view-subagents",
+            "id=subagent-explorer",
+            "id=subagent-filter-status",
+            "id=subagent-filter-signal",
+            "id=subagent-view-tabs",
+            "id=subagent-compact-summary",
+            "id=subagent-workspace",
+            "id=subagent-results",
+            "id=subagent-inspector",
+            "renderAgentActivity(s);",
+            "renderSubagentExplorer(",
+            "Median / P95",
+            "groupSubagentSessions(",
+            "buildSubagentRoleRows(",
+        ):
+            self.assertIn(expected, self.page)
+        self.assertIn("Cost color compares children in this session", self.page)
+        self.assertIn("Cost and retry evidence", self.page)
+        self.assertIn("Work time", self.page)
+        self.assertIn("completed prompt-to-response time", self.page)
+        self.assertNotIn("<span>Elapsed</span>", self.page)
+        self.assertNotIn("evidenceMetric('Elapsed'", self.page)
+
+    def test_session_detail_back_control_markup_names_origin_list(self):
+        view = self.page.index("id=view-session")
+        back = self.page.index("id=session-back-row")
+        title = self.page.index("id=session-page-title")
+        self.assertLess(view, back)
+        self.assertLess(back, title)
+        self.assertIn(
+            '<div class=sessionBackRow id=session-back-row data-current-detail>'
+            '<button class="tbtn sessionBack" id=session-back type=button aria-label="Back to Current sessions">'
+            '<span aria-hidden=true>←</span><span id=session-back-label>Current sessions</span></button></div>',
+            self.page,
+        )
+        self.assertIn("$('session-back').onclick=openSessionBack;", self.page)
+        self.assertIn("if(!overview)renderSessionBack();", self.page)
+        self.assertIn(".sessionBackRow{display:flex;margin-bottom:10px}", self.page)
+        self.assertIn("sessionListBack:!replace&&sessionListBackAvailable(sessionReturnScope)", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_detail_back_returns_to_origin_list(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',start)+1,depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const SESSION_SCOPES=['current','all','compare','subagents'];
+const calls=[];
+let location={{pathname:'/',hash:'#sessions-all'}};
+const history={{state:null,back(){{calls.push(['back']);}},pushState(state,title,url){{this.state=state;const [path,hash]=String(url).split('#');location={{pathname:path||'/',hash:hash?'#'+hash:''}};calls.push(['push',url]);}},replaceState(state){{this.state=state;}}}};
+const elements={{}};
+const $=id=>elements[id]||(elements[id]={{textContent:'',attrs:{{}},setAttribute(name,value){{this.attrs[name]=value;}}}});
+let sessionScope='all',sessionReturnScope='current',sessionRequest=0,pinned=null;
+const applyHashRoute=()=>{{}},refreshSelectedSession=()=>Promise.resolve();
+const openSessionScope=scope=>calls.push(['scope',scope]);
+eval(['routedSessionId','sessionRoute','normalizeSessionScope','sessionScopeRoute','sessionScopeLabel','sessionListBackAvailable','renderSessionBack','openSessionBack','selectSession'].map(extract).join('\\n'));
+const result={{}};
+selectSession('abc',{{returnScope:'all'}});
+renderSessionBack();
+result.fromList={{state:history.state,label:$('session-back-label').textContent,aria:$('session-back').attrs['aria-label']}};
+openSessionBack();
+result.fromListCalls=calls.splice(0);
+location={{pathname:'/',hash:'#spend'}};
+selectSession('def');
+openSessionBack();
+result.fromSpend={{state:history.state,calls:calls.splice(0)}};
+selectSession('ghi',{{returnScope:'compare'}});
+result.sessionToSession=history.state;
+calls.splice(0);
+location={{pathname:'/sessions/deep#summary',hash:'#summary'}};
+history.state=null;sessionReturnScope='current';
+renderSessionBack();
+openSessionBack();
+result.deepLink={{label:$('session-back-label').textContent,aria:$('session-back').attrs['aria-label'],calls:calls.splice(0)}};
+result.labels=['current','all','compare','subagents','bogus'].map(sessionScopeLabel);
+eval(extract('applyLocationRoute'));
+elements['view-session']={{classList:{{contains:()=>true}}}};
+location={{pathname:'/sessions/xyz',hash:'#summary'}};
+history.state={{sessionScope:'compare',sessionListBack:true}};
+sessionScope='current';sessionReturnScope='current';
+applyLocationRoute();
+renderSessionBack();
+result.reload={{scope:sessionReturnScope,label:$('session-back-label').textContent}};
+openSessionBack();
+result.reloadCalls=calls.splice(0);
+process.stdout.write(JSON.stringify(result));
+"""
+        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        payload = json.loads(completed.stdout)
+
+        self.assertEqual(payload["fromList"]["state"], {"sessionScope": "all", "sessionListBack": True})
+        self.assertEqual(payload["reload"], {"scope": "compare", "label": "Compare"})
+        self.assertEqual(payload["reloadCalls"], [["back"]])
+        self.assertEqual(payload["fromList"]["label"], "All sessions")
+        self.assertEqual(payload["fromList"]["aria"], "Back to All sessions")
+        self.assertEqual(payload["fromListCalls"], [["push", "/sessions/abc#summary"], ["back"]])
+        self.assertEqual(payload["fromSpend"]["state"], {"sessionScope": "all", "sessionListBack": False})
+        self.assertEqual(payload["fromSpend"]["calls"], [["push", "/sessions/def#summary"], ["scope", "all"]])
+        self.assertEqual(payload["sessionToSession"], {"sessionScope": "compare", "sessionListBack": False})
+        self.assertEqual(payload["deepLink"]["label"], "Current sessions")
+        self.assertEqual(payload["deepLink"]["aria"], "Back to Current sessions")
+        self.assertEqual(payload["deepLink"]["calls"], [["scope", "current"]])
+        self.assertEqual(
+            payload["labels"],
+            ["Current sessions", "All sessions", "Compare", "Subagents", "Current sessions"],
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_compare_keys_forked_traces_and_routes_compare_scope(self):
+        self.assertIn("id=session-scope-compare", self.page)
+        self.assertIn("id=session-compare role=tabpanel", self.page)
+        self.assertIn("fetch(`/session/compare?ids=${encodeURIComponent(key)}`", self.page)
+        self.assertIn("{id:'compare-sessions',label:'Compare sessions'", self.page)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const SESSION_SCOPES=['current','all','compare','subagents'];
+eval(extract('normalizeSessionScope'));eval(extract('sessionScopeRoute'));eval(extract('compareKeyFor'));
+eval(extract('mergeAllSessionInventory'));eval(extract('compareDelta'));
+const parent={{id:'root',key:'tparent',title:'Same'}};
+const fork={{id:'root',key:'tfork',title:'Same'}};
+const merged=mergeAllSessionInventory([parent,fork],[{{...fork,cost:2}}]);
+process.stdout.write(JSON.stringify({{
+ route:sessionScopeRoute('compare'),
+ keys:[compareKeyFor(parent),compareKeyFor(fork),compareKeyFor({{id:'only'}}),compareKeyFor({{id:'o',key:'topencode'}}),compareKeyFor({{key:'tkiro'}}),compareKeyFor({{}}),compareKeyFor({{id:7}})],
+ merged:merged.length,
+ liveWins:merged.find(row=>row.key===fork.key).cost,
+ cheaper:compareDelta({{lower:true}},0.5,1),
+ costlier:compareDelta({{lower:true}},3,1),
+ neutral:compareDelta({{}},2.5,2),
+ points:compareDelta({{lower:false,points:true}},0.9,0.6),
+ missing:compareDelta({{lower:true}},null,1),
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload["route"], "sessions-compare")
+        self.assertEqual(payload["keys"], ["tparent", "tfork", "only", "topencode", "tkiro", "", "7"])
+        self.assertEqual(payload["merged"], 2)
+        self.assertEqual(payload["liveWins"], 2)
+        self.assertIn("better", payload["cheaper"])
+        self.assertIn("−50%", payload["cheaper"])
+        self.assertIn("worse", payload["costlier"])
+        self.assertIn("3.0×", payload["costlier"])
+        self.assertNotIn("better", payload["neutral"])
+        self.assertNotIn("worse", payload["neutral"])
+        self.assertIn("+30 pts", payload["points"])
+        self.assertIn("better", payload["points"])
+        self.assertEqual(payload["missing"], "")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_compare_clears_stale_missing_notice_when_selection_empties(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`async function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',start)+1,depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+let compareIds=[],compareData={{sessions:[]}},compareError='',compareNotice='1 selected session could not be loaded right now.',compareMissing=['tgone'],compareLoadedKey='tgone',compareLoading=false,compareRequestSeq=0,rendered=0;
+function renderComparison(){{rendered++;}}
+eval(extract('loadComparison'));
+loadComparison().then(()=>process.stdout.write(JSON.stringify({{compareNotice,compareMissing,compareData,rendered}})));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload, {"compareNotice": "", "compareMissing": [], "compareData": None, "rendered": 1})
+
+    def test_sessions_all_uses_exact_coverage_copy_without_ambiguous_suffixes(self):
+        start = self.page.index("function renderAllSessionStats(")
+        end = self.page.index("function currentSessionAge(", start)
+        block = self.page[start:end]
+        self.assertIn("sessionCoverageCopy", block)
+        self.assertNotIn("?' partial'", block)
+        self.assertNotIn(" incl. est", block)
+
+        start = self.page.index("function renderSubagentUsage(")
+        end = self.page.index("function renderAllSessions(", start)
+        subagent_block = self.page[start:end]
+        self.assertIn("group_cost_covered_sessions", subagent_block)
+        self.assertIn("parent sessions have complete group cost", subagent_block)
+        self.assertNotIn("group-cost coverage", subagent_block)
+
+    def test_current_output_card_shows_trace_backed_output_speed(self):
+        for marker in ("id=preview-speed", "s.throughput||{}", "speedFmt(throughput.output_tps)",
+                       "tool-free", "end-to-end", "reasoning and thinking output",
+                       "external tool-result tokens"):
+            self.assertIn(marker, self.page)
+        self.assertIn(".previewSpeed .v{color:var(--accent)", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_unavailable_cost_value_explains_why_it_is_not_zero(self):
+        match = re.search(
+            r"const COST_UNAVAILABLE_TIP=.*?^function setCostValue\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs an unavailable-cost helper")
+        script = """
+const element={classList:{values:new Set(),toggle(name,on){on?this.values.add(name):this.values.delete(name);}},attributes:{},setAttribute(name,value){this.attributes[name]=String(value);},removeAttribute(name){delete this.attributes[name];}};
+const $=id=>element;
+""" + match.group(0) + """
+setCostValue('cost','$1.25',true);
+const available={text:element.textContent,classes:[...element.classList.values],attributes:{...element.attributes}};
+setCostValue('cost','$1.25',false);
+console.log(JSON.stringify({available,unavailable:{text:element.textContent,classes:[...element.classList.values],attributes:{...element.attributes}}}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["available"], {
+            "text": "$1.25", "classes": [], "attributes": {},
+        })
+        self.assertEqual(rendered["unavailable"]["text"], "--")
+        self.assertEqual(rendered["unavailable"]["classes"], ["fieldtip"])
+        self.assertIn("not $0", rendered["unavailable"]["attributes"]["data-tip"])
+        self.assertIn("locally stored usage", rendered["unavailable"]["attributes"]["aria-description"])
+
+    def test_cross_session_cost_placeholders_share_the_unavailable_cost_explanation(self):
+        for renderer, helper in (
+            ("function logRowContent(s){", "costValueHtml("),
+            ("function renderAllSessionStats(sessions){", "costValueHtml("),
+            ("function renderCurrentDaySummary(xs){", "setCostValue("),
+            ("function renderSpend(xs){", "setCostValue("),
+            ("function renderCurrentSessions(state=LATEST){", "costValueHtml("),
+        ):
+            section = self.page.split(renderer, 1)[1].split("\nfunction ", 1)[0]
+            self.assertIn(helper, section, renderer)
+
+    def test_current_session_cost_tooltip_does_not_add_a_nested_tab_stop(self):
+        session_cards = self.page.split("function renderCurrentSessions(state=LATEST){", 1)[1].split(
+            "const currentSessionGrid=$('current-session-grid');", 1
+        )[0]
+        self.assertIn("costValueHtml(money(row.cost)+(estimate?' est':''),costAvailable,false),costLabel=costPartial?'Cost, at least':'Cost'", session_cards)
+        self.assertIn("const costTipAttrs=costAvailable?'':costUnavailableAttrs();", session_cards)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_active_session_surfaces_prefer_live_throughput(self):
+        match = re.search(
+            r"function sessionDisplayThroughput\(session\)\{.*?\n\}",
+            self.page,
+            re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs one shared speed selector")
+        script = match.group(0) + """
+const completed = {throughput:{available:true,output_tps:85.4},live_throughput:{available:false}};
+const active = {throughput:{available:true,output_tps:85.4},live_throughput:{available:true,output_tps:41.2}};
+console.log(JSON.stringify({
+  completed: sessionDisplayThroughput(completed).output_tps,
+  active: sessionDisplayThroughput(active).output_tps,
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "completed": 85.4,
+            "active": 41.2,
+        })
+        self.assertGreaterEqual(self.page.count("sessionDisplayThroughput(s)"), 2)
+        self.assertIn("sessionDisplayThroughput(row)", self.page)
+
+    def test_session_detail_is_one_run_surface_without_subtabs(self):
+        for marker in (
+            "id=current-tabs", "data-current-panel=", "id=preview-surface-activity",
+            "id=preview-surface-tools", "id=preview-surface-insights",
+            "id=preview-surface-alerts", "id=panel-activity", "id=panel-tools",
+            "id=panel-insights", "id=panel-alerts", "function renderTrace(",
+            "function renderTools(",
+        ):
+            self.assertNotIn(marker, self.page)
+        self.assertIn("const PANEL_KEYS=['summary'];", self.page)
+        self.assertIn("const CURRENT_PANEL_KEYS=['sessions','run'];", self.page)
+        for removed_route in ("activity", "tools", "alerts"):
+            self.assertIn(f"{removed_route}:'summary'", self.page)
+        self.assertNotIn("insights:'summary'", self.page)
+        self.assertNotIn("efficiency:'summary'", self.page)
+
+    def test_codex_session_detail_links_to_the_desktop_thread(self):
+        for marker in (
+            'id=session-desktop-link',
+            'aria-label="Open this session in the Codex desktop app"',
+            'function desktopSessionTarget(session)',
+            "provider==='codex'",
+            'codex://threads/${encodeURIComponent(id)}',
+            'function renderDesktopSessionLink(session)',
+            'link.hidden=!target',
+            "link.removeAttribute('href')",
+            'renderDesktopSessionLink(s);',
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_claude_sessions_link_to_the_desktop_code_session(self):
+        for marker in (
+            "provider==='claude'",
+            "/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i",
+            'claude://resume?session=${encodeURIComponent(resume)}',
+            "label:'Open in Claude'",
+            "label:'Open in Codex'",
+            'link.textContent=target.label',
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_current_session_cards_offer_a_sibling_desktop_link(self):
+        render = self.page[self.page.index("function renderCurrentSessions("):]
+        render = render[:render.index("\nfunction ")]
+        self.assertIn("desktopSessionTarget(row)", render)
+        self.assertIn('<div class=currentSessionSlot', render)
+        self.assertIn('class=currentSessionDesktop', render)
+        self.assertIn('draggable=false', render)
+        self.assertIn("</button>${desktopLink}</div>", render)
+        self.assertIn(".currentSessionSlot{", self.page)
+        self.assertIn(".currentSessionDesktop{", self.page)
+
+    def test_old_current_summary_is_only_a_hidden_renderer_depot(self):
+        for marker in (
+            "id=session-depot hidden", "id=usage-details", "tm_usage_details_open",
+            "id=cost", "id=input-tok", "id=output-tok", "id=output-tps",
+            "id=ov-duration", "id=ov-context",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("class=view id=session-depot", self.page)
+        self.assertNotIn("class=\"view on\" id=session-depot", self.page)
+
+    def test_execution_chart_marks_a_single_observed_value(self):
+        chart = self.page[
+            self.page.index("function drawIO(series)"):
+            self.page.index("function renderOverview(s)")
+        ]
+        self.assertIn("const validPoints=[]", chart)
+        self.assertIn("validPoints.length===1", chart)
+        self.assertIn("const singlePoint=", chart)
+
+    def test_builder_recap_is_a_separate_document(self):
+        primary = self.page.split("<div class=navPrimary>", 1)[1].split("</div>", 1)[0]
+        performance = re.search(
+            r'<a[^>]+id=tab-performance[^>]*>.*?</a>', primary, re.S
+        )
+        self.assertIsNotNone(performance)
+        anchor = performance.group(0)
+        for marker in (
+            "class=tab", "href=/performance", "data-label=Performance",
+            "aria-label=Performance", "<span class=tabLabel>Performance</span>",
+        ):
+            self.assertIn(marker, anchor)
+        self.assertNotIn("aria-keyshortcuts", anchor)
+        self.assertNotIn("tabShortcut", anchor)
+        self.assertLess(primary.index("id=tab-efficiency"), primary.index("id=tab-git"))
+        self.assertLess(primary.index("id=tab-git"), primary.index("id=tab-performance"))
+        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
+            "<div class=view id=view-git>", 1
+        )[0]
+        self.assertNotIn("id=e-builder-recap", efficiency)
+        for rejected in (
+            "id=view-performance-card", "performance-card", ".recapPageHead",
+            "const builderRecapState=", "function drawBuilderRecap(",
+            "recap-canvas", "recap-download",
+        ):
+            self.assertNotIn(rejected, self.page)
+
+    def test_language_signals_are_removed_from_the_dashboard(self):
+        for removed in (
+            "id=model-frustration", "id=frustration-settings", "id=positive-terms",
+            "id=f-chart", "id=f-collapse", "User language signals", "Language signals",
+            "/settings/language-signals", "renderFrustration", "language_signals",
+            "frustrationSection", "signalPanel", "tm_language_signals_collapsed",
+        ):
+            self.assertNotIn(removed, self.page)
+        self.assertIn("if(h==='models'||h==='frustration'){", self.page)
+        self.assertIn("if(h==='frustration')setHashRoute('models',{replace:true,apply:false});", self.page)
+        self.assertIn(".signalEmpty{", self.page)
+        self.assertIn(
+            "body.spectrumApp :is(.sessionStart,.toast,.capReview,.agentDiscovery,.previewStartStrip,.modelScopeStatus){border-left-width:1px}",
+            self.page,
+        )
+
+    def test_selected_session_token_split_fills_the_chart_column_gap(self):
+        run_grid = self.page.split('<div class=previewRunGrid>', 1)[1].split(
+            '<aside class=previewDecision>', 1
+        )[0]
+        self.assertIn('class=previewChartColumn', run_grid)
+        self.assertIn('id=preview-run-chart-slot', run_grid)
+        self.assertIn('id=preview-token-split-slot', run_grid)
+        self.assertLess(
+            run_grid.index('id=preview-run-chart-slot'),
+            run_grid.index('id=preview-token-split-slot'),
+        )
+        self.assertIn(
+            ".previewChartColumn{display:grid;grid-template-rows:minmax(0,1fr) auto;gap:12px;min-width:0}",
+            self.page,
+        )
+
+    def test_review_fixes_keep_focus_targets_and_timestamps(self):
+        # The inventory heading receives programmatic focus, so it must be focusable.
+        self.assertIn("<h2 id=c-inventory-title tabindex=-1>All capabilities</h2>", self.page)
+        self.assertIn("$('c-inventory-title').focus(", self.page)
+        # Detail view keeps the date/time line break instead of collapsing it.
+        self.assertIn(
+            "body.sessionRoute #view-session.sessionDetail .previewTimes b{overflow:visible;white-space:pre-line;line-height:1.35}",
+            self.page,
+        )
+        self.assertIn("$('preview-started-at').textContent=(dt12(timing.start_local)||'--').replace(' ','\\n');", self.page)
+        # The welcome tour opened from the palette returns focus to where the palette opened.
+        self.assertIn("const returnFocus=commandReturnFocus;commandReturnFocus=null;openWelcome(null,{returnFocus});", self.page)
+        self.assertNotIn("WELCOME_PANELS[2].title=", self.page)
+
+    def test_selected_session_columns_share_top_and_bottom_edges(self):
+        decision = self.page.split('<aside class=previewDecision>', 1)[1].split('</aside>', 1)[0]
+        # The right column opens with a heading row matching the left column's
+        # "Execution Profile" heading, so the first cards start on one line.
+        self.assertTrue(decision.lstrip().startswith(
+            '<div class=section-h><h2>Session cost</h2><span class=hint>estimate</span></div>'
+        ))
+        self.assertLess(decision.index('class=section-h'), decision.index('id=preview-status-card'))
+        self.assertLess(decision.index('id=preview-status-card'), decision.index('id=preview-run-budget-slot'))
+        for rule in (
+            # Both columns stretch to the row height; the first card in each
+            # column absorbs slack so the last cards end on one line.
+            ".previewRunGrid{display:grid;grid-template-columns:minmax(0,1.75fr) minmax(300px,.65fr);gap:12px;align-items:stretch}",
+            ".previewChartColumn{display:grid;grid-template-rows:minmax(0,1fr) auto;gap:12px;min-width:0}",
+            ".previewChartSlot{display:grid}",
+            ".previewChartSlot #session-chart-module{display:grid;grid-template-rows:auto minmax(0,1fr);gap:12px}",
+            ".previewChartSlot .section-h,.previewDecision>.section-h{margin:0}",
+            ".previewDecision{display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:auto minmax(0,1fr) auto;gap:12px}",
+            # The wider 18px inset must not push the budget slider past the
+            # narrow 1024px right column.
+            ".previewRunBudgetSlot .sessionBudgetTrack{grid-template-columns:52px minmax(0,1fr) 60px}",
+            ".previewStatus{display:flex;flex-direction:column;",
+            ".previewStatus .previewPressure{margin-block:auto}",
+            # Right-column cards share the left cards' 18px inner edge.
+            "body.sessionRoute #view-session.sessionDetail .previewRunBudgetSlot .sessionBudget{padding:18px;",
+            # Context pressure uses the same label treatment as Started/Last activity.
+            ".previewPressureHead>span{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.04em}",
+        ):
+            self.assertIn(rule, self.page)
+        self.assertNotIn("#view-session.sessionDetail .previewRunGrid{gap:14px}", self.page)
+        self.assertNotIn(".previewChartSlot .section-h{margin:0 0 10px}", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_saved_non_folder_project_filters_migrate_to_other_local_sessions(self):
+        value_match = re.search(r"function projectFilterValue\(.*?\n\}", self.page, re.DOTALL)
+        filter_match = re.search(r"function storedModelFilterId\(.*?\n\}", self.page, re.DOTALL)
+        migration_match = re.search(r"function migrateStoredProjectFilters\(.*?\n\}", self.page, re.DOTALL)
+        self.assertIsNotNone(value_match, "Project filters need folder-only values")
+        self.assertIsNotNone(filter_match, "Stored project filter values need a safe aggregate-ID boundary")
+        self.assertIsNotNone(migration_match, "Stored project filters need a grouping migration")
+        script = "const OTHER_LOCAL_SESSIONS_PROJECT='__other_local_sessions__';\n" + value_match.group(0) + "\n" + filter_match.group(0) + "\n" + migration_match.group(0) + r"""
+const storage=new Map([
+ ['tm_model_project','CLI'],
+ ['tm_efficiency_project','No project'],
+ ['tm_global_project','~/Documents/Codex/2026-08-31/task'],
+ ['tm_model_project_filters',JSON.stringify({CLI:['gpt::Codex','gpt-5.6::Codex::xhigh','/Users/alice/private-project','gpt::Codex\t','gpt::Codex\u0000']})],
+ ['tm_efficiency_project_filters',JSON.stringify({'No project':['gpt::Codex']})],
+]);
+globalThis.localStorage={getItem:key=>storage.get(key)??null,setItem:(key,value)=>storage.set(key,String(value)),removeItem:key=>storage.delete(key)};
+['tm_model_project','tm_efficiency_project','tm_global_project'].forEach(key=>migrateStoredProjectFilters(key));
+migrateStoredProjectFilters('tm_model_project_filters',true);
+migrateStoredProjectFilters('tm_efficiency_project_filters',true);
+console.log(JSON.stringify(Object.fromEntries(storage)));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        stored = json.loads(result.stdout)
+        other = "__other_local_sessions__"
+        self.assertEqual(stored["tm_model_project"], other)
+        self.assertEqual(stored["tm_efficiency_project"], other)
+        self.assertEqual(stored["tm_global_project"], other)
+        self.assertEqual(json.loads(stored["tm_model_project_filters"]), {other: ["gpt::Codex", "gpt-5.6::Codex::xhigh"]})
+        self.assertEqual(json.loads(stored["tm_efficiency_project_filters"]), {other: ["gpt::Codex"]})
+
+    def test_session_card_hover_preserves_the_live_card_node(self):
+        for marker in (
+            "currentGrid=$('current-session-grid'),interactingCurrentSessionCard=currentGrid.querySelector('.currentSessionSlot:hover,.currentSessionCard:focus,.currentSessionDesktop:focus');",
+            "const mountedCurrentSessionIds=[...currentGrid.querySelectorAll('.currentSessionCard[data-current-session-id]')].map(card=>card.dataset.currentSessionId);",
+            "if(currentSessionDragId||(interactingCurrentSessionCard&&currentSessionIdsMatch(mountedCurrentSessionIds,rows))){syncCurrentSessionActivity(currentGrid,rows);return;}",
+            "card.classList.remove('activity-working','activity-waiting','activity-recent');",
+            "body.spectrumApp.sessionRoute #view-session .currentSessionCard:hover{transform:none}",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_session_chart_only_offers_linear_and_cumulative_scales(self):
+        scale_controls = self.page.split('<div class=seg id=scale>', 1)[1].split(
+            "</div>", 1
+        )[0]
+        self.assertIn("data-scale=linear", scale_controls)
+        self.assertIn("data-scale=cumulative", scale_controls)
+        self.assertNotIn("data-scale=sqrt", scale_controls)
+        self.assertNotIn("data-scale=log", scale_controls)
+        self.assertIn("const CHART_SCALES=['linear','cumulative'];", self.page)
+        self.assertIn("if(!CHART_SCALES.includes(chartScale))", self.page)
+        self.assertIn("localStorage.setItem('tm_chart_scale',chartScale);", self.page)
+        self.assertNotIn("if(scale==='sqrt')", self.page)
+        self.assertNotIn("if(scale==='log')", self.page)
+
+    def test_session_chart_supports_cumulative_cost_and_token_views(self):
+        for marker in (
+            "data-scale=cumulative",
+            "Show running estimated cost or token totals through each execution.",
+            "const CHART_SCALES=['linear','cumulative'];",
+            "if(!CHART_SCALES.includes(chartScale))",
+            "b.setAttribute('aria-pressed',selected?'true':'false');",
+            "function cumulativeChartParts(parts,mode)",
+            "const keys=mode==='cost'?['cost']:['fresh','read','write','cache','total','out'];",
+            "keys.forEach(key=>{sums[key]+=Math.max(0,Number(part[key]||0));});",
+            "const cumulativeTokens=mode==='tokens'&&chartScale==='cumulative';",
+            "const cumulativeCost=mode==='cost'&&chartScale==='cumulative';",
+            "const cumulativeValues=cumulativeTokens||cumulativeCost;",
+            "parts=cumulativeValues?cumulativeChartParts(rawParts,mode):rawParts",
+            "running estimated cost through each execution",
+            "running token totals through each execution",
+            "cumulative cost",
+            "cumulative usd",
+            "cumulative tokens",
+            "const tokenPrefix=cumulativeTokens?'cumulative ':'';",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("rawParts.map(p=>p.tools)", self.page)
+        self.assertIn("rawParts.map(p=>p.reason)", self.page)
+
+    def test_execution_overview_separates_activity_from_removable_optimization(self):
+        for marker in ("id=ov-activity-tools", "id=ov-optional-use", "id=ov-unused-packs"):
+            self.assertIn(marker, self.page)
+        self.assertIn("renderCurrentOptimization(s)", self.page)
+        self.assertIn("function setCapabilityStatBar(id,value)", self.page)
+        self.assertLess(
+            self.page.index("function setCapabilityStatBar(id,value)"),
+            self.page.index("setCapabilityStatBar('ov-optional-bar'"),
+        )
+        self.assertIn("if(!bar)return;", self.page)
+        self.assertIn("bar.setAttribute('aria-valuetext',label);", self.page)
+        self.assertNotIn("renderCapabilityUsage('ov-cap'", self.page)
+        self.assertIn("Default tools and MCP servers are read-only evidence", self.page)
+
+    def test_non_current_views_keep_visible_copy_terse(self):
+        expected_subtitles = {
+            "models": [],
+            "capabilities": ["Tools, MCP servers, and skills."],
+            "settings": ["Connections, pricing, and updates."],
+        }
+        boundaries = (
+            ("models", "daily"),
+            ("capabilities", "settings"),
+            ("settings", None),
+        )
+        for view, next_view in boundaries:
+            section = self.page.split(f"id=view-{view}", 1)[1]
+            section = section.split(
+                f"id=view-{next_view}" if next_view else "<dialog class=welcome",
+                1,
+            )[0]
+            paragraphs = [
+                re.sub(r"<[^>]+>", "", value).strip()
+                for value in re.findall(r"<p(?:\s[^>]*)?>(.*?)</p>", section, re.S)
+            ]
+            self.assertEqual(
+                [value for value in paragraphs if value],
+                expected_subtitles[view],
+                f"{view} should carry only its concise page subtitle",
+            )
+            self.assertNotIn("class=foot", section)
+
+        spend = self.page.split("id=view-daily", 1)[1].split("id=view-learn", 1)[0]
+        self.assertNotIn("Estimated agent spend over time.", spend)
+        total_note = self.page.split("$('s-total-note').textContent=", 1)[1].split(";\n", 1)[0]
+        self.assertIn("'API-equivalent estimate'", total_note)
+        self.assertIn("Estimate after discounts", total_note)
+        self.assertIn("<p id=s-chart-note>Line = average</p>", spend)
+        self.assertNotIn("class=foot", spend)
+
+        for marker in (
+            'aria-description="Observed model output divided by attributable timing.',
+            'aria-description="Set a budget for each runtime',
+            'aria-description="Give Codex and Claude read-only, on-demand access',
+            "#fieldtip-popup{position:fixed",
+            "No use observed",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_all_sessions_supports_app_project_and_time_range_filters(self):
+        for marker in ("id=g-app", "id=g-project", "id=g-time", "App filter",
+                       "Projects filter", "Time range filter", "class=logsToolbarStatus", "id=g-active-filters",
+                       "id=g-clear", "id=lf-cost", "id=lf-input", "id=lf-output", "id=lf-models"):
+            self.assertIn(marker, self.page)
+        clear_wrapper = re.search(r"<div class=filterClear>(.*?)</div>", self.page)
+        self.assertIsNotNone(clear_wrapper)
+        self.assertIn("id=g-clear", clear_wrapper.group(1))
+        self.assertNotIn("id=g-count", clear_wrapper.group(1))
+        self.assertLess(self.page.index("id=g-clear"), self.page.index("id=g-sort"))
+        for value in ("value=today", "value=yesterday", "value=7d", "value=30d", "value=90d", "value=month", "value=last_month"):
+            self.assertIn(value, self.page)
+        self.assertIn("allSessionsView(workRows,{showChildren:globalShowChildren,app:globalApp,project:globalProject,rangeStart,rangeEnd,query:q})", self.page)
+        self.assertIn("if(app&&appFilterGroup(s)!==app)return false;", self.page)
+        self.assertIn("const appFilterGroup=session=>runtimeId(session)", self.page)
+        self.assertIn("const appFilterLabel=session=>runtimeMeta(session).label", self.page)
+        self.assertIn("['claude_code','claude_desktop'].includes(globalApp)", self.page)
+        self.assertIn("if(project&&projectFilterValue(s.project)!==project)return false;", self.page)
+        self.assertIn("Other local sessions", self.page)
+        self.assertIn("const {start:rangeStart,end:rangeEnd}=timeFilterBounds(globalTime);", self.page)
+        self.assertIn("tm_global_app", self.page)
+        self.assertIn("tm_global_project", self.page)
+        self.assertIn("tm_global_time", self.page)
+        self.assertIn("renderAllSessionStats(view.statsRows)", self.page)
+        self.assertIn("session.model_stats", self.page)
+        self.assertIn("let globalTime=localStorage.getItem('tm_global_time')||DEFAULT_TIME_FILTER_WINDOW;", self.page)
+        self.assertIn("globalSearch='';globalApp='';globalProject='';globalTime=DEFAULT_TIME_FILTER_WINDOW", self.page)
+        self.assertIn("if(key==='time'){globalTime=DEFAULT_TIME_FILTER_WINDOW;", self.page)
+        self.assertIn("globalTime!==DEFAULT_TIME_FILTER_WINDOW&&['time',", self.page)
+        self.assertIn("['tm_global_search','tm_global_app','tm_global_project','tm_global_time']", self.page)
+        self.assertIn("fetch('/logs',{cache:'no-store'})", self.page)
+        self.assertIn("allSessionInventory?mergeAllSessionInventory(allSessionInventory,xs.sessions)", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_all_sessions_keep_one_row_per_trace_file(self):
+        script = "\n".join(
+            self.page_function(self.page, name)
+            for name in ("sessionRowKey", "compareKeyFor", "mergeAllSessionInventory")
+        ) + """
+const inventory=[
+ {id:'task-1',session:'rollout-a.jsonl',cost:0.91},
+ {id:'task-1',session:'rollout-b.jsonl',cost:111.57},
+ {id:'task-1',session:'rollout-c.jsonl',cost:0.16},
+ {id:'legacy'},
+];
+const live=[{id:'task-1',session:'rollout-b.jsonl',cost:112.0}];
+const merged=mergeAllSessionInventory(inventory,live);
+console.log(JSON.stringify({
+ keys:merged.map(sessionRowKey),
+ cost:merged.reduce((sum,row)=>sum+(row.cost||0),0),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        merged = json.loads(result.stdout)
+        self.assertEqual(merged["keys"], [
+            "rollout-a.jsonl", "rollout-b.jsonl", "rollout-c.jsonl", "legacy",
+        ])
+        self.assertAlmostEqual(merged["cost"], 0.91 + 112.0 + 0.16)
+
+    def test_every_session_entry_point_addresses_one_trace_file(self):
+        for marker in (
+            "function sessionRowKey(row){return String(row?.session||row?.id||'');}",
+            "function stateSessionKey(state){return String(state?.session||stateSessionId(state)||'');}",
+            "renderedAllSessions=new Map(all.map(row=>[sessionRowKey(row),row]));",
+            "const pinnedKey=pinned?(renderedAllSessions.has(pinned)?pinned:(stateSessionId(CURRENT)===pinned?stateSessionKey(CURRENT):'')):'';",
+            "const key=sessionRowKey(s),rowKey=compareKeyFor(s),active=pinned?key===pinnedKey:Boolean(LATEST&&key===stateSessionKey(LATEST));",
+            "row.dataset.id=key;",
+            "data-delete-session=\"${esc(sessionRowKey(s))}\"",
+            "body:JSON.stringify({session_id:target.id,trace:target.session||''})",
+            "const workRows=workSessionFilter?all.filter(s=>workSessionFilter.keys.has(sessionRowKey(s))):all;",
+            "keys:new Set(payload.keys.map(String))",
+            "data-spend-session=\"${esc(sessionRowKey(row))}\"",
+            "data-spend-insight-session=\"${esc(sessionRowKey(row))}\"",
+            "href=\"${esc(sessionRoute(sessionRowKey(row)))}\"",
+            "<span class=\"badge subagentTag\">Subagent</span>",
+                ".srow .subagentTag{",
+                "sessionDeleteAvailable(s,renderedAllSessionActions),s.subagent,s.client,",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("workSessionFilter.ids.has(String(s.id))", self.page)
+        self.assertNotIn("rows.set(String(row.id),row)", self.page)
+        self.assertNotIn("renderedAllSessions=new Map(all.map(row=>[String(row.id),row]));", self.page)
+
+    def test_current_and_all_sessions_share_the_defined_app_badge_helper(self):
+        self.assertIn("const appBadgeClass=session=>", self.page)
+        self.assertIn("'badge app '+appBadgeClass(s)", self.page)
+        self.assertIn("${appBadgeClass(s)}", self.page)
+        self.assertNotIn("providerBadgeClass", self.page)
+
+    def test_current_sessions_keep_opencode_identity(self):
+        self.assertIn(
+            "const provider=runtimeId(row)",
+            self.page,
+        )
+        self.assertIn('class="card currentSessionCard provider-${esc(provider)}', self.page)
+        self.assertIn("Object.entries(RUNTIME_CATALOG).filter(([id])=>id!=='unknown-runtime')", self.page)
+
+    def test_session_delete_actions_require_confirmation_and_use_trash_endpoint(self):
+        for marker in ("id=session-delete", "data-delete-session", "id=session-delete-dialog",
+                       "id=session-delete-confirm", "Move to Trash", "/session/delete"):
+            self.assertIn(marker, self.page)
+        self.assertIn("openSessionDeleteDialog", self.page)
+        self.assertIn("event.stopPropagation()", self.page)
+        self.assertIn("X-Token-Meter-Action", self.page)
+        self.assertIn("Provider metadata and configuration are not changed", self.page)
+        self.assertIn("function sessionDeleteAvailable(target,actions)", self.page)
+        self.assertIn("actions?.read_only_providers", self.page)
+        self.assertIn("status.alert_percent??status.percent", self.page)
+        self.assertIn("don't trigger budget notifications", self.page)
+        self.assertIn("!sessionDeleteAvailable(target,actions)", self.page)
+
+    def test_token_chart_fills_use_the_same_colors_as_legend_and_tooltip(self):
+        self.assertIn("const band=(top,bottom,col,opacity)=>", self.page)
+        self.assertIn(
+            "band(cacheRead,zeros,CHART.cacheRead,.18)+"
+            "band(cacheTop,cacheRead,CHART.cacheWrite,.18)",
+            self.page,
+        )
+        self.assertIn('fill-opacity="${opacity}"', self.page)
+        self.assertNotIn("cacheReadFill", self.page)
+        self.assertNotIn("cacheWriteFill", self.page)
+
+    def test_selected_session_stays_pinned_while_other_live_state_changes(self):
+        self.assertIn("function followLatestSession", self.page)
+        self.assertIn("function refreshSelectedSession", self.page)
+        self.assertIn(
+            "fetchLiveJson('/session?id='+encodeURIComponent(id)+'&live=1',LIVE_XSESSION.session,'Session')",
+            self.page,
+        )
+        self.assertLess(
+            self.page.index("const LIVE_XSESSION="),
+            self.page.index("applyLocationRoute();"),
+        )
+        self.assertLess(
+            self.page.index("selectedPollId=''"),
+            self.page.index("applyLocationRoute();"),
+        )
+        self.assertIn("const SELECTED_SESSION_POLL_MS=2000", self.page)
+        self.assertIn(
+            "setInterval(()=>refreshSelectedSession({show:true}),SELECTED_SESSION_POLL_MS)",
+            self.page,
+        )
+        self.assertIn("pinned=id;\n if(show)applyHashRoute();\n return refreshSelectedSession", self.page)
+        self.assertIn(
+            "const sessionSurfaceActive=$('view-session').classList.contains('on');\n"
+            " if(!pinned&&sessionSurfaceActive&&currentPanel!=='sessions')renderSession(LATEST);",
+            self.page,
+        )
+        self.assertNotIn("if(LATEST&&id===stateSessionId(LATEST))", self.page)
+        self.assertNotIn("if(pinned&&pinned===stateSessionId(LATEST))", self.page)
+
+    def test_sessions_overview_is_bounded_routed_and_accessible(self):
+        for marker in (
+            "id=preview-surface-sessions",
+            "id=current-session-grid",
+            "function renderCurrentSessions",
+            "function openCurrentSessions",
+            "'/#sessions'",
+            "data-current-session-id",
+            '<h1 id=session-page-title>Sessions</h1>',
+            'class=currentSessionsCount id=current-session-count-label',
+            "filterView.countLabel",
+            "Working",
+            "Waiting",
+            "Recent",
+            "provider-claude",
+            "provider-codex",
+            "provider-cursor",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("const CURRENT_PANEL_KEYS=['sessions','run'];",
+                      self.page)
+        self.assertNotIn("data-current-panel=sessions", self.page)
+        self.assertNotIn('id=current-tabs', self.page)
+        self.assertRegex(self.page, r"id=tab-session[^>]*>.*?<span class=tabLabel>Sessions</span>")
+        self.assertIn("if(h==='sessions'||h==='sessions-all'||h==='sessions-compare'||h==='current-sessions')", self.page)
+        self.assertIn("history.replaceState(null,'','/#sessions')", self.page)
+        self.assertIn("function currentSessionModelName", self.page)
+        self.assertIn("row.session_name||row.project||'Untitled session'", self.page)
+        self.assertIn("`${runtime} / ${model}${effort?` ${effort}`:''}`", self.page)
+        self.assertIn("<span>Speed</span>", self.page)
+        self.assertIn("speedFmt(throughput.output_tps)} tok/s", self.page)
+        self.assertIn("<span>Output / $</span>", self.page)
+        self.assertIn("row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar)", self.page)
+        self.assertIn(
+            "const outputPerDollar=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar);",
+            self.page,
+        )
+        self.assertNotIn(
+            "const outputPerDollar=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar)+(estimate||row.token_estimate?' est':'');",
+            self.page,
+        )
+        self.assertIn(".currentSessionMetrics{display:grid;grid-template-columns:repeat(3,minmax(0,1fr))", self.page)
+        self.assertIn(
+            "body.sessionRoute #view-session .currentSessionMetrics{grid-template-columns:.9fr 1.2fr 1fr;gap:0;margin-top:14px;padding-top:14px",
+            self.page,
+        )
+        self.assertIn(
+            "body.sessionRoute #view-session .currentSessionMetric{padding:0 14px",
+            self.page,
+        )
+        self.assertNotIn("id=unpin", self.page)
+        self.assertNotIn("Back to current sessions", self.page)
+        self.assertNotIn("Back to all sessions", self.page)
+        self.assertNotIn("$('unpin')", self.page)
+        self.assertNotIn("Reorder: drag or ⌥ + arrows", self.page)
+        self.assertNotIn("currentSessionsMoveHint", self.page)
+        self.assertNotIn("currentSessionOpen", self.page)
+        self.assertNotIn(">Open →</span>", self.page)
+
+    def test_current_session_activity_filters_are_accessible_and_wired(self):
+        for marker in (
+            'id=current-session-activity-filters role=group aria-label="Filter current sessions by activity"',
+            'data-current-activity-filter=all aria-pressed=true>All</button>',
+            'data-current-activity-filter=working aria-pressed=false>Working</button>',
+            'data-current-activity-filter=recent aria-pressed=false>Recent</button>',
+            "let currentSessionRuntimeFilter='all',currentSessionActivityFilter='all';",
+            "function renderCurrentSessionActivityFilters(selection)",
+            "currentSessionFilterView(orderedRows,currentSessionRuntimeFilter,currentSessionActivityFilter)",
+            "renderCurrentSessionActivityFilters(filterView.activitySelection);",
+            "currentSessionActivityFilter=button.dataset.currentActivityFilter||'all';",
+            "currentSessionsFilteredEmptyHtml(filterView.activitySelection)",
+            "function keepCurrentSessionFilterFocusVisible(event)",
+            "button.scrollIntoView({block:'nearest',inline:'nearest'});",
+            "currentSessionRuntimeFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);",
+            "currentSessionActivityFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn(
+            "$('current-session-activity-filters').hidden=true;",
+            self.page,
+        )
+        for marker in (
+            ".currentSessionFilterGroups{display:flex;align-items:center;gap:10px;min-width:0;overflow-x:auto",
+            ".currentSessionFilterGroup[hidden]{display:none}",
+            "body.sessionRoute #view-session .currentSessionRuntimeFilters,body.sessionRoute #view-session .currentSessionActivityFilters{display:flex;min-width:0}",
+            "body.sessionRoute #view-session .currentSessionFilterGroups{display:grid;width:100%;max-width:none;overflow:visible}",
+            "body.sessionRoute #view-session .currentSessionFilterGroup{min-width:0;max-width:100%;overflow-x:auto;overflow-y:hidden;scrollbar-width:thin}",
+        ):
+            self.assertIn(marker, self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_session_runtime_view_discovers_filters_and_preserves_valid_selection(self):
+        match = re.search(
+            r"^function currentSessionRuntimeView\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs currentSessionRuntimeView")
+        rows = [
+            {"id": "claude-code", "provider": "claude"},
+            {"id": "codex", "provider": "codex"},
+            {"id": "claude-desktop", "provider": "claude"},
+        ]
+        script = """
+const appFilterGroup=row=>row.provider;
+const appFilterLabel=row=>({claude:'Claude',codex:'Codex',cursor:'Cursor'})[row.provider];
+""" + match.group(0) + "\nconst rows=" + json.dumps(rows) + ";\n" + """
+const all=currentSessionRuntimeView(rows,'all');
+const claude=currentSessionRuntimeView(rows,'claude');
+rows.push({id:'cursor',provider:'cursor'});
+const emerged=currentSessionRuntimeView(rows,'claude');
+const vanished=currentSessionRuntimeView(rows.filter(row=>row.provider!=='claude'),'claude');
+console.log(JSON.stringify({all,claude,emerged,vanished}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["all"], {
+            "options": [
+                {"id": "claude", "label": "Claude", "count": 2},
+                {"id": "codex", "label": "Codex", "count": 1},
+            ],
+            "selection": "all",
+            "rows": rows[:3],
+            "countLabel": "3 active",
+        })
+        self.assertEqual(
+            [row["id"] for row in rendered["claude"]["rows"]],
+            ["claude-code", "claude-desktop"],
+        )
+        self.assertEqual(rendered["claude"]["countLabel"], "2 of 3 active")
+        self.assertEqual(rendered["emerged"]["selection"], "claude")
+        self.assertEqual(
+            rendered["emerged"]["options"],
+            [
+                {"id": "claude", "label": "Claude", "count": 2},
+                {"id": "codex", "label": "Codex", "count": 1},
+                {"id": "cursor", "label": "Cursor", "count": 1},
+            ],
+        )
+        self.assertEqual(rendered["vanished"]["selection"], "all")
+        self.assertEqual(rendered["vanished"]["countLabel"], "2 active")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_session_filter_view_composes_runtime_and_sticky_activity_selection(self):
+        names = (
+            "currentSessionActivity",
+            "currentSessionRuntimeView",
+            "currentSessionFilterView",
+        )
+        functions = []
+        for name in names:
+            match = re.search(
+                rf"^function {name}\(.*?^\}}\n",
+                self.page,
+                re.MULTILINE | re.DOTALL,
+            )
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        rows = [
+            {"id": "claude-working", "provider": "claude", "activity_state": "working"},
+            {"id": "claude-recent", "provider": "claude", "activity_state": "recent"},
+            {"id": "codex-working", "provider": "codex", "activity_state": "working"},
+            {"id": "codex-waiting", "provider": "codex", "activity_state": "waiting"},
+        ]
+        script = """
+const appFilterGroup=row=>row.provider;
+const appFilterLabel=row=>({claude:'Claude',codex:'Codex'})[row.provider];
+""" + "\n".join(functions) + "\nconst rows=" + json.dumps(rows) + ";\n" + """
+const codexWorking=currentSessionFilterView(rows,'codex','working');
+const claudeRecent=currentSessionFilterView(rows,'claude','recent');
+const zeroWorking=currentSessionFilterView(
+ rows.filter(row=>row.activity_state!=='working'),
+ 'all',
+ 'working',
+);
+const invalidActivity=currentSessionFilterView(rows,'all','waiting');
+console.log(JSON.stringify({codexWorking,claudeRecent,zeroWorking,invalidActivity}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(
+            [row["id"] for row in rendered["codexWorking"]["rows"]],
+            ["codex-working"],
+        )
+        self.assertEqual(rendered["codexWorking"]["selection"], "codex")
+        self.assertEqual(rendered["codexWorking"]["activitySelection"], "working")
+        self.assertEqual(rendered["codexWorking"]["countLabel"], "1 of 4 active")
+        self.assertEqual(
+            [row["id"] for row in rendered["claudeRecent"]["rows"]],
+            ["claude-recent"],
+        )
+        self.assertEqual(rendered["zeroWorking"]["rows"], [])
+        self.assertEqual(rendered["zeroWorking"]["activitySelection"], "working")
+        self.assertEqual(rendered["zeroWorking"]["countLabel"], "0 of 2 active")
+        self.assertEqual(rendered["invalidActivity"]["activitySelection"], "all")
+        self.assertEqual(rendered["invalidActivity"]["countLabel"], "4 active")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_sessions_filtered_empty_copy_describes_the_selected_activity(self):
+        match = re.search(
+            r"^function currentSessionsFilteredEmptyHtml\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs currentSessionsFilteredEmptyHtml")
+        script = match.group(0) + """
+console.log(JSON.stringify({
+ working:currentSessionsFilteredEmptyHtml('working'),
+ recent:currentSessionsFilteredEmptyHtml('recent'),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertIn("No working sessions right now", rendered["working"])
+        self.assertIn("No recent sessions right now", rendered["recent"])
+        for html in rendered.values():
+            self.assertIn("Filters are still active", html)
+            self.assertNotIn("Your next live session appears here", html)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_session_keyboard_move_reorders_the_visible_runtime_sequence(self):
+        match = re.search(
+            r"^function currentSessionKeyboardMove\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs currentSessionKeyboardMove")
+        script = match.group(0) + """
+const moved=currentSessionKeyboardMove(
+ ['claude-1','codex-1','claude-2'],
+ ['claude-1','claude-2'],
+ 'claude-1',
+ 1,
+);
+console.log(JSON.stringify(moved));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "ids": ["codex-1", "claude-2", "claude-1"],
+            "index": 1,
+            "total": 2,
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_session_keyboard_move_uses_the_combined_filter_sequence(self):
+        names = (
+            "currentSessionActivity",
+            "currentSessionKeyboardMove",
+            "currentSessionRuntimeView",
+            "currentSessionFilterView",
+            "moveCurrentSessionCardBy",
+        )
+        functions = []
+        for name in names:
+            match = re.search(
+                rf"^function {name}\(.*?^\}}\n",
+                self.page,
+                re.MULTILINE | re.DOTALL,
+            )
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        script = """
+const appFilterGroup=row=>row.provider;
+const appFilterLabel=row=>({claude:'Claude',codex:'Codex'})[row.provider];
+const LATEST={xsession:{current_sessions:[
+ {id:'claude-working',provider:'claude',activity_state:'working'},
+ {id:'codex-working',provider:'codex',activity_state:'working'},
+ {id:'claude-recent',provider:'claude',activity_state:'recent'},
+]}};
+const currentSessionRuntimeFilter='claude';
+const currentSessionActivityFilter='working';
+const orderedCurrentSessionRows=rows=>rows;
+let saved=null;
+const setCurrentSessionOrder=ids=>{saved=ids};
+""" + "\n".join(functions) + """
+const result=moveCurrentSessionCardBy('claude-working',1);
+console.log(JSON.stringify({result,saved}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {"result": None, "saved": None})
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_session_ids_match_detects_a_stale_filtered_grid(self):
+        match = re.search(
+            r"^function currentSessionIdsMatch\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs currentSessionIdsMatch")
+        script = match.group(0) + """
+const stable=currentSessionIdsMatch(
+ ['claude-1','claude-2'],
+ [{id:'claude-1'},{id:'claude-2'}],
+);
+const stale=currentSessionIdsMatch(
+ ['claude-1','claude-2'],
+ [{id:'codex-1'}],
+);
+console.log(JSON.stringify({stable,stale}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertTrue(rendered["stable"])
+        self.assertFalse(rendered["stale"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_current_session_filter_focus_survives_emergence_and_falls_back_on_disappearance(self):
+        match = re.search(
+            r"^function currentSessionFilterFocusTarget\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs currentSessionFilterFocusTarget")
+        script = match.group(0) + """
+const emerged=currentSessionFilterFocusTarget(
+ {selection:'claude',options:[{id:'claude'},{id:'codex'},{id:'cursor'}]},
+ 'claude',
+);
+const vanished=currentSessionFilterFocusTarget(
+ {selection:'all',options:[{id:'codex'}]},
+ 'claude',
+);
+console.log(JSON.stringify({emerged,vanished}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["emerged"], "claude")
+        self.assertEqual(rendered["vanished"], "all")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_flow_snapshot_uses_real_activity_and_marks_only_new_arrivals(self):
+        match = re.search(
+            r"^function sessionFlowSnapshot\(.*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs a pure sessionFlowSnapshot")
+        script = match.group(0) + """
+const unavailable=sessionFlowSnapshot(undefined,[],false);
+const first=sessionFlowSnapshot([
+ {id:'working',activity_state:'working'},
+ {id:'waiting',activity_state:'waiting'},
+ {id:'recent',activity_state:'recent'},
+],[],false);
+const next=sessionFlowSnapshot([
+ {id:'waiting',activity_state:'waiting'},
+ {id:'arriving',activity_state:'working'},
+],first.ids,true);
+const idle=sessionFlowSnapshot([],next.ids,true);
+console.log(JSON.stringify({unavailable,first,next,idle}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["unavailable"], {
+            "evidence": "unavailable", "mode": "idle", "count": 0,
+            "working": 0, "waiting": 0, "recent": 0,
+            "ids": [], "arriving": [],
+        })
+        self.assertEqual(rendered["first"], {
+            "evidence": "available", "mode": "working", "count": 3,
+            "working": 1, "waiting": 1, "recent": 1,
+            "ids": ["working", "waiting", "recent"], "arriving": [],
+        })
+        self.assertEqual(rendered["next"], {
+            "evidence": "available", "mode": "working", "count": 2,
+            "working": 1, "waiting": 1, "recent": 0,
+            "ids": ["waiting", "arriving"], "arriving": ["arriving"],
+        })
+        self.assertEqual(rendered["idle"], {
+            "evidence": "available", "mode": "idle", "count": 0,
+            "working": 0, "waiting": 0, "recent": 0,
+            "ids": [], "arriving": [],
+        })
+
+    def test_current_day_summary_compares_partial_days_without_estimate_suffix(self):
+        script = f"""
+const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const nodes={{}};const $=id=>nodes[id]||(nodes[id]={{textContent:'',classList:{{toggle(){{}},add(){{}},remove(){{}}}},setAttribute(){{}},removeAttribute(){{}},dataset:{{}}}});
+const money=v=>'$'+Number(v||0).toFixed(2),f=v=>String(v),countWord=(n,w)=>n===1?w:w+'s';
+const metricAvailable=(row,k)=>row.availability?.[k]!==false,metricPartial=(row,k)=>Boolean(row.partial?.[k]);
+const hasLocalEstimate=row=>row.basis==='mixed',estimateSuffix=row=>row.basis==='mixed'?' incl. est':'';
+const setCostValue=(id,text)=>{{$(id).textContent=text;}};
+eval(['localDayKey','dailyDeltaLabel','renderCurrentDaySummary'].map(extract).join('\\n'));
+const day=offset=>{{const d=new Date();d.setHours(12,0,0,0);d.setDate(d.getDate()-offset);return localDayKey(d);}};
+const out={{}};
+for(const [name,todayPartial,yesterdayPartial] of [['both',true,true],['today',true,false],['yesterday',false,true],['none',false,false]]){{
+ renderCurrentDaySummary({{daily:[
+  {{day:day(0),cost:57.25,sessions:4,basis:'mixed',partial:{{cost:todayPartial}}}},
+  {{day:day(1),cost:50,sessions:14,partial:{{cost:yesterdayPartial}}}}]}});
+ out[name]={{spend:$('current-day-spend').textContent,spendNote:$('current-day-spend-note').textContent,vs:$('current-day-vs-yesterday').textContent,note:$('current-day-vs-yesterday-note').textContent}};
+}}
+const run=(daily,key)=>{{renderCurrentDaySummary({{daily}});out[key]={{vs:$('current-day-vs-yesterday').textContent,note:$('current-day-vs-yesterday-note').textContent,spendNote:$('current-day-spend-note').textContent}};}};
+run([{{day:day(0),cost:5,sessions:1,partial:{{cost:true}}}}],'noYesterday');
+run([{{day:day(0),cost:5,sessions:1}},{{day:day(1),cost:4,sessions:1,availability:{{cost:false}}}}],'yesterdayUnavailable');
+run([{{day:day(1),cost:4,sessions:1}}],'noActivityToday');
+run([{{day:day(0),cost:5,sessions:1}},{{day:day(1),cost:4,sessions:1,basis:'mixed'}}],'yesterdayEstimated');
+process.stdout.write(JSON.stringify(out));
+"""
+        out = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
+        for case in (out[name] for name in ("both", "today", "yesterday", "none")):
+            self.assertEqual(case["spend"], "$57.25")
+            self.assertNotEqual(case["vs"], "--")
+        self.assertEqual(out["both"]["note"], "vs $50.00 yesterday · both days partial")
+        self.assertEqual(out["today"]["note"], "vs $50.00 yesterday · today partial")
+        self.assertEqual(out["yesterday"]["note"], "vs $50.00 yesterday · yesterday partial")
+        self.assertEqual(out["none"]["note"], "vs $50.00 yesterday")
+        self.assertEqual(out["none"]["vs"], out["both"]["vs"])
+        # Estimates stay disclosed now that the value has no suffix.
+        self.assertEqual(out["both"]["spendNote"], "Partial billing coverage · includes estimates")
+        self.assertEqual(out["none"]["spendNote"], "API-equivalent estimate · includes local estimates")
+        self.assertEqual(out["yesterdayEstimated"]["note"], "vs $4.00 est yesterday")
+        self.assertEqual((out["noYesterday"]["vs"], out["noYesterday"]["note"]),
+                         ("New", "No recorded spend yesterday · today partial"))
+        self.assertEqual((out["yesterdayUnavailable"]["vs"], out["yesterdayUnavailable"]["note"]),
+                         ("--", "Yesterday cost unavailable"))
+        self.assertEqual((out["noActivityToday"]["vs"], out["noActivityToday"]["note"]),
+                         ("--", "No recorded activity today"))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_sessions_2.py b/tests/test_dashboard_sessions_2.py
new file mode 100644
index 00000000..2649d1c6
--- /dev/null
+++ b/tests/test_dashboard_sessions_2.py
@@ -0,0 +1,296 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+import meter
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardSessionsLayoutTests2(DashboardLayoutCase):
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_readouts_compare_against_prior_days_and_never_invent_baselines(self):
+        functions = []
+        for name in ("localDayKey", "typicalComparison", "typicalCaption", "readoutScaleHtml", "dailyBaseline"):
+            match = re.search(rf"^function {name}\(.*?^\}}\n", self.page, re.MULTILINE | re.DOTALL)
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        medians = re.search(r"^const medianOf=.*$", self.page, re.MULTILINE)
+        self.assertIsNotNone(medians)
+        script = """
+const esc=s=>String(s??'');
+const money=n=>'$'+Number(n||0).toFixed(2);
+const pct=n=>Math.round((n||0)*100)+'%';
+const waitFmt=n=>Math.round(n)+'s';
+const metricAvailable=(row,metric)=>row?.availability?.[metric]!==false;
+const metricPartial=(row,metric)=>row?.coverage?.[metric]?.complete===false;
+const hasLocalEstimate=row=>row?.usage_basis==='local_estimate';
+""" + medians.group(0) + "\n" + "".join(functions) + """
+const days=[
+ {day:'2026-10-13',sessions:9,cost:50},
+ {day:'2026-10-12',sessions:2,cost:2},
+ {day:'2026-10-11',sessions:4,cost:4},
+ {day:'2026-10-10',sessions:6,cost:6,coverage:{cost:{complete:false}}},
+ {day:'2026-10-09',sessions:0,cost:0},
+ {day:'2026-08-01',sessions:30,cost:900},
+];
+const baseline=dailyBaseline(days,'2026-10-13');
+const burst=dailyBaseline([
+ {day:'2026-10-12',sessions:1000,cost:200},
+ {day:'2026-10-11',sessions:10,cost:120},
+ {day:'2026-10-10',sessions:5,cost:50},
+],'2026-10-13');
+console.log(JSON.stringify({
+ baseline,
+ burst,
+ empty:dailyBaseline([], '2026-10-13'),
+ above:typicalCaption(6,2,'your typical day','$2.00'),
+ below:typicalCaption(1,4,'your typical day','$4.00'),
+ near:typicalCaption(2.1,2,'your typical day','$2.00'),
+ none:typicalCaption(0,2,'your typical day','$2.00'),
+ missing:typicalCaption(3,null,'your typical day',''),
+ scale:readoutScaleHtml({value:6,typical:2,label:'x'}),
+ calm:readoutScaleHtml({value:6,typical:2,toned:false}),
+ noScale:readoutScaleHtml({value:6,typical:0}),
+}));
+"""
+        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
+        # Today, the partial-cost day, idle days, and days older than 30 days stay out of the baseline.
+        self.assertEqual(result["baseline"]["days"], 3)
+        self.assertEqual(result["baseline"]["typicalCost"], 3)
+        self.assertEqual(result["baseline"]["highCost"], 4)
+        self.assertEqual(result["baseline"]["typicalSessions"], 4)
+        self.assertEqual(result["baseline"]["sessionCost"], 1)
+        # A day of many tiny scripted sessions must not swamp the per-session baseline.
+        self.assertEqual(result["burst"]["sessionCost"], 10)
+        self.assertIsNone(result["empty"]["typicalCost"])
+        self.assertIsNone(result["empty"]["sessionCost"])
+        self.assertEqual(result["above"], "3.0× your typical day of $2.00")
+        self.assertEqual(result["below"], "75% below your typical day of $4.00")
+        self.assertEqual(result["near"], "In line with your typical day of $2.00")
+        self.assertEqual(result["none"], "Nothing yet · your typical day is $2.00")
+        self.assertEqual(result["missing"], "")
+        self.assertIn('data-tone="high"', result["scale"])
+        self.assertIn("--at:90.9%;--typ:30.3%", result["scale"])
+        self.assertIn('data-tone=""', result["calm"])
+        self.assertEqual(result["noScale"], "")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_empty_current_sessions_render_live_arrival_and_real_seven_day_history(self):
+        functions = []
+        for name in ("currentSessionsIdleHistory", "currentSessionsEmptyHtml"):
+            match = re.search(
+                rf"^function {name}\(.*?^\}}\n",
+                self.page,
+                re.MULTILINE | re.DOTALL,
+            )
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        fixture = {"daily": [
+            {"day": "2026-08-18", "sessions": 1, "cost": 1.25,
+             "providers": [{"provider": "codex"}],
+             "availability": {"cost": True},
+             "coverage": {"cost": {"complete": True}},
+             "usage_basis": "local_estimate"},
+            {"day": "2026-08-17", "sessions": 5, "cost": 2.0,
+             "providers": [{"provider": "codex"}, {"provider": "claude"}],
+             "availability": {"cost": True},
+             "coverage": {"cost": {"complete": True}},
+             "usage_basis": "reported"},
+            {"day": "2026-08-12", "sessions": 2, "cost": 50.0,
+             "providers": [{"provider": "claude"}],
+             "availability": {"cost": False},
+             "coverage": {"cost": {"complete": False}},
+             "usage_basis": "unavailable"},
+            {"day": "2026-08-11", "sessions": 99, "cost": 99.0,
+             "providers": [{"provider": "outside-window"}],
+             "availability": {"cost": True},
+             "coverage": {"cost": {"complete": True}},
+             "usage_basis": "reported"},
+        ]}
+        script = """
+const f=value=>String(value);
+const money=value=>'$'+Number(value).toFixed(2);
+const esc=value=>String(value);
+const countWord=(count,singular,plural=singular+'s')=>Number(count)===1?singular:plural;
+""" + "\n".join(functions) + "\nconst xs=" + json.dumps(fixture) + ";\n" + """
+const history=currentSessionsIdleHistory(xs,'2026-08-18');
+const html=currentSessionsEmptyHtml(xs,'2026-08-18');
+const firstRunHtml=currentSessionsEmptyHtml({daily:[]},'2026-08-18');
+console.log(JSON.stringify({history,html,firstRunHtml}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["history"], {
+            "days": [
+                {"day": "2026-08-12", "sessions": 2},
+                {"day": "2026-08-13", "sessions": 0},
+                {"day": "2026-08-14", "sessions": 0},
+                {"day": "2026-08-15", "sessions": 0},
+                {"day": "2026-08-16", "sessions": 0},
+                {"day": "2026-08-17", "sessions": 5},
+                {"day": "2026-08-18", "sessions": 1},
+            ],
+            "sessions": 8,
+            "cost": 3.25,
+            "costAvailable": True,
+            "costPartial": True,
+            "costEstimated": True,
+            "runtimes": ["claude", "codex"],
+        })
+        html = rendered["html"]
+        for marker in (
+            "Your next live session appears here",
+            "Next live session",
+            "Cost",
+            "Output / $",
+            "Context in use",
+            "Speed",
+            "8 past sessions",
+            "At least $3.25 est tracked",
+            "2 runtimes",
+            "data-current-empty-history",
+            "Explore 8 past sessions",
+            'href="https://github.com/splunk/token-meter/issues"',
+            "Share feedback",
+        ):
+            self.assertIn(marker, html)
+        self.assertIn("No past sessions yet", rendered["firstRunHtml"])
+        self.assertIn("Your seven-day activity will build here.", rendered["firstRunHtml"])
+        self.assertNotIn("data-current-empty-history", rendered["firstRunHtml"])
+
+    def test_session_cards_use_compact_readable_metrics(self):
+        for marker in (
+            ".currentSessionGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}",
+            ".currentSessionGrid{gap:10px}",
+            ".currentSessionCard{min-height:190px;padding:16px 18px 14px}",
+            ".currentSessionIdentity h3{font-size:var(--fs-18)}",
+            ".currentSessionMetric b{margin-top:4px;font-size:var(--fs-18)}",
+            "font-variant-numeric:tabular-nums",
+            ".currentSessionMetric b.mono{font-size:var(--fs-18)}",
+            ".currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-20)}",
+            "@media(max-width:700px){.currentSessionGrid{grid-template-columns:1fr;gap:8px}",
+            ".currentSessionCard{min-height:184px;padding:14px 14px 12px}",
+            ".currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-16)",
+            "@media(max-width:700px){.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-18)}",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_session_cards_show_context_pressure_or_window_fallback(self):
+        for marker in (
+            "function currentSessionContextSparkline(row)",
+            "Array.isArray(context.samples)",
+            "if(!windowSize)return {",
+            "currentSessionContextUnavailable",
+            "window --",
+            "Context window unavailable;",
+            "Context window and latest token count unavailable.",
+            "const plotted=samples.slice(-24)",
+            "const values=plotted.map(value=>value/windowSize)",
+            "const width=96,height=22",
+            "currentSessionContextBar",
+            "value>=.85?' high':value>=.7?' watch'",
+            "<svg class=currentSessionContextSpark",
+            "class=currentSessionContextValue",
+            "const contextSpark=currentSessionContextSparkline(row)",
+            "${contextSpark.html}",
+            "<span>Context in use</span>",
+            ">Context in use</div><div class=\"v mono\" id=ov-context>",
+            ">Context in use</div><div class=\"v mono\" id=preview-context>",
+            "cacheSavingsAvailable?money(cache.saved||s.cache_saved||0):'--'",
+            "const cardDescription=`${heroCaption?heroCaption+'. ':''}${contextSpark.summary}",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("const values=windowSize?plotted.map(value=>value/windowSize):plotted", self.page)
+        self.assertNotIn("currentSessionContextCaption", self.page)
+        self.assertNotIn("currentSessionContextGuide", self.page)
+
+    def test_session_cards_do_not_have_native_hover_tooltips(self):
+        session_cards = self.page.split("function renderCurrentSessions(state=LATEST){", 1)[1].split(
+            "const currentSessionGrid=$('current-session-grid');", 1
+        )[0]
+        for marker in (
+            'class=currentSessionRuntime title=',
+            '<h3 title=',
+            '<p title=',
+            '<b class=mono title=',
+            "const contextNote=",
+        ):
+            self.assertNotIn(marker, session_cards)
+        self.assertIn('aria-description="${esc(cardDescription)}"', session_cards)
+
+    def test_run_status_card_has_no_decorative_context_circle(self):
+        self.assertNotIn("#view-session.sessionDetail .previewStatus:before", self.page)
+        self.assertNotIn("--context-pressure", self.page)
+        self.assertNotIn(".style.setProperty('--context-pressure'", self.page)
+        self.assertIn('id=preview-context-bar', self.page)
+        self.assertIn("$('preview-context-bar').querySelector('i').style.width=", self.page)
+
+    def test_sessions_is_default_new_cards_lead_and_known_cards_keep_manual_order(self):
+        for marker in (
+            "$('tab-session').onclick=()=>{window.scrollTo(0,0);openCurrentSessions();};",
+            "label:'Sessions'",
+            "action:'sessions'}",
+            "setHashRoute('sessions',{replace:true,apply:false})",
+            "const CURRENT_SESSION_ORDER_KEY='tm_current_session_order_v1'",
+            "const CURRENT_SESSION_ORDER_MIGRATION_KEY='tm_current_session_newest_first_v1'",
+            "function orderedCurrentSessionRows(rows)",
+            "function currentSessionActivity(row)",
+            "function syncCurrentSessionActivity(root,rows)",
+            "if(!Array.isArray(sourceRows))",
+            "function moveCurrentSessionCard(sourceId,targetId,after=false)",
+            "function moveCurrentSessionCardBy(sourceId,delta)",
+            "function focusCurrentSessionCard(id)",
+            "draggable=true",
+            "event.dataTransfer.effectAllowed='move'",
+            "currentSessionGrid.addEventListener('dragover'",
+            "currentSessionGrid.addEventListener('drop'",
+            "currentSessionGrid.addEventListener('dragend'",
+            "currentSessionGrid.addEventListener('keydown'",
+            "event.altKey",
+            "Press ⌥ and an arrow key to move.",
+            "id=current-session-order-status",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("if(!id||byId.has(id))return;", self.page)
+        self.assertIn(
+            "const known=currentSessionOrder.filter(id=>byId.has(id)),seen=new Set(known);",
+            self.page,
+        )
+        self.assertIn(
+            "if(currentSessionDragId||(interactingCurrentSessionCard&&currentSessionIdsMatch(mountedCurrentSessionIds,rows))){syncCurrentSessionActivity(currentGrid,rows);return;}",
+            self.page,
+        )
+        self.assertIn(
+            "const unseen=sourceIds.filter(id=>!seen.has(id));\n"
+            " let next=[...unseen,...known];",
+            self.page,
+        )
+        self.assertIn(
+            "if(currentSessionOrderNeedsNewestMigration&&sourceIds.length){\n"
+            "  const newest=sourceIds[0];\n"
+            "  next=[newest,...next.filter(id=>id!==newest)];",
+            self.page,
+        )
+        self.assertNotIn("next.push(id);seen.add(id)", self.page)
+        limit = re.search(r"const CURRENT_SESSION_ORDER_LIMIT=(\d+);", self.page)
+        self.assertIsNotNone(limit)
+        self.assertEqual(int(limit.group(1)), meter.CURRENT_SESSION_LIMIT)
+        self.assertIn(".slice(0,CURRENT_SESSION_ORDER_LIMIT))]:[];", self.page)
+        self.assertIn("JSON.stringify(currentSessionOrder.slice(0,CURRENT_SESSION_ORDER_LIMIT))", self.page)
+        self.assertNotIn("slice(0,64))]:[];", self.page)
+
+    def test_cursor_provenance_is_integrated_across_dashboard_views(self):
+        for marker in (
+            "const hasLocalEstimate", "const estimateSuffix",
+            "local token proxies are not comparable", "stroke-dasharray",
+            "id=c-runtime-filter", "Input context proxy",
+            "visible text estimate", "hasLocalEstimate(row)",
+        ):
+            self.assertIn(marker, self.page)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_settings.py b/tests/test_dashboard_settings.py
new file mode 100644
index 00000000..025a57bc
--- /dev/null
+++ b/tests/test_dashboard_settings.py
@@ -0,0 +1,401 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardSettingsLayoutTests(DashboardLayoutCase):
+    def test_promoted_current_is_dense_complete_and_settings_stay_dedicated(self):
+        for marker in (
+            "id=tab-session", 'class="view on" id=view-session',
+            "id=preview-run-chart-slot",
+            "id=preview-run-budget-slot", "id=preview-token-split-slot",
+            "id=preview-surface-run",
+            "id=session-token-split-home", "id=session-token-split-module",
+            "class=\"card previewStartStrip\"", "class=settingsPageLayout",
+            "class=\"card settingsMap\"", "data-settings-target=agent-access",
+            "function restoreCurrentModules()", "function showCurrentPanel(panel)",
+            "function renderCurrentRun(s)",
+            "if(h==='preview-settings')", "setHashRoute('settings',{replace:true,apply:false})",
+            "const legacyCurrentRoutes={preview:'summary','preview-run':'summary'",
+        ):
+            self.assertIn(marker, self.page)
+        for metric_id in (
+            "preview-speed", "preview-wait",
+            "preview-context", "preview-executions", "preview-tools",
+            "preview-tool-results", "preview-cache-rate", "preview-cache-saved",
+            "preview-burn", "preview-cost-task", "preview-started-at",
+            "preview-last-at",
+        ):
+            self.assertIn(f"id={metric_id}", self.page)
+        for removed_id in (
+            "preview-input", "preview-output", "preview-thinking", "preview-avg-cost",
+        ):
+            self.assertNotIn(f"id={removed_id}", self.page)
+        for unique_id in (
+            "iochart", "sembar", "session-token-split-module", "budget", "agent-access",
+            "model-pricing-settings", "update-settings",
+        ):
+            self.assertEqual(
+                len(re.findall(rf"\bid={re.escape(unique_id)}(?:\s|>)", self.page)),
+                1,
+                f"{unique_id} must be moved, not cloned",
+            )
+        self.assertNotIn("id=tab-preview", self.page)
+        self.assertNotIn("id=view-preview", self.page)
+        current = self.page.split('<div class="view on" id=view-session>', 1)[1].split(
+            "<div class=view id=view-models>", 1
+        )[0]
+        self.assertNotIn("Settings map", current)
+        self.assertNotIn("id=agent-access", current)
+        self.assertNotIn("id=frustration-settings", current)
+        self.assertNotIn("id=model-pricing-settings", current)
+        self.assertNotIn("What needs attention", current)
+        self.assertNotIn("Open original Current", current)
+        self.assertNotIn("Experimental", current)
+        self.assertNotIn("Current preview", current)
+        self.assertNotIn("previewKpi fieldtip", current)
+        self.assertLess(current.index("id=preview-start"), current.index("id=preview-run-chart-slot"))
+        self.assertLess(
+            current.index("id=preview-run-chart-slot"),
+            current.index("id=preview-token-split-slot"),
+        )
+        self.assertIn("previewSpeed", current)
+        self.assertIn("text-overflow:ellipsis;white-space:nowrap", self.page)
+        self.assertIn(
+            "if(t!=='session')restoreCurrentModules();",
+            self.page,
+        )
+        self.assertIn(
+            "mountCurrentModule('preview-run-chart-slot','session-chart-module')",
+            self.page,
+        )
+        self.assertIn(
+            "mountCurrentModule('preview-token-split-slot','session-token-split-module')",
+            self.page,
+        )
+        self.assertIn(
+            "['session-token-split-home','session-token-split-module']",
+            self.page,
+        )
+        for marker in (
+            "id=current-tabs", "data-current-panel=", "id=preview-activity-slot",
+            "id=preview-tools-slot", "id=preview-efficiency-slot",
+            "id=preview-alerts-slot", "id=preview-surface-activity",
+            "id=preview-surface-tools", "id=preview-surface-insights",
+            "id=preview-surface-alerts", "id=session-activity-home",
+            "id=session-tools-home", "id=session-insights-home",
+            "id=session-alerts-home", "id=panel-activity", "id=panel-tools",
+            "id=panel-insights", "id=panel-alerts",
+            "mountCurrentModule(`preview-${panel}-slot`,`panel-${panel}`)",
+            "const button=event.target.closest('[data-current-panel]');",
+        ):
+            self.assertNotIn(marker, self.page)
+        self.assertIn("const CURRENT_PANEL_KEYS=['sessions','run'];", self.page)
+        self.assertIn("const PANEL_KEYS=['summary'];", self.page)
+        self.assertNotIn("mountCurrentModule('preview-settings", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_restore_built_in_price_follows_scope_and_stays_reachable(self):
+        functions = []
+        for name in (
+            "modelPriceScopePayload", "requestModelPrice", "updateModelPriceScope",
+            "modelPriceLifecycle", "applyModelPriceLifecycle",
+        ):
+            match = re.search(
+                rf"^(?:async )?function {name}\(.*?^\}}\n", self.page,
+                re.MULTILINE | re.DOTALL,
+            )
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        script = """
+const sent=[],confirms=[],scoped=[],toasts=[],statuses=[],notes={};let row,scope='from_now';
+const modelPricingSelected=new Set(),LATEST=null,els={};
+const $=id=>els[id]||(els[id]={id,textContent:'',className:'',disabled:false,classList:{toggle(){}}});
+const modelPriceKey=(p,m)=>p+'/'+m,agentActionToken=()=>'t';
+const modelPriceScope=()=>scope,modelPriceEffectiveFrom=()=>null;
+const modelPriceRowFor=()=>row,renderModelPricing=()=>{},refreshLiveState=async()=>{};
+const showAppToast=toast=>toasts.push(toast.title+': '+toast.body);
+const confirm=text=>{confirms.push(text);return true;};
+const confirmModelPriceHistory=(action)=>{scoped.push(action);return true;};
+const fetch=async(url,options)=>{const body=JSON.parse(options.body);sent.push(body);return {ok:true,json:async()=>({ok:true,effective_scope:body.apply_to_all_history?'all_history':'now',model_pricing:{}})};};
+""" + "".join(functions) + """
+(async()=>{
+ const button={textContent:'',disabled:false};
+ const rows={
+  overridden:{provider:'codex',model:'gpt-5.6',builtin:true,custom:false,active:true,overridden:true,periods:1},
+  leftover:{provider:'codex',model:'gpt-5.6',builtin:true,custom:false,active:true,overridden:false,periods:2},
+  plain:{provider:'codex',model:'gpt-5.6',builtin:true,custom:false,active:true,overridden:false,periods:0},
+  custom:{provider:'codex',model:'mine',builtin:false,custom:true,active:true,overridden:false,periods:1},
+  retired:{provider:'codex',model:'mine',builtin:false,custom:true,active:false,overridden:false,periods:2},
+ };
+ const lifecycles=Object.fromEntries(Object.entries(rows).map(([k,v])=>[k,modelPriceLifecycle(v)]));
+ const run=async(key,selected)=>{scope=selected;row=rows[key];const before=sent.length;await applyModelPriceLifecycle(button);statuses.push([key,selected,sent.length-before,$('model-pricing-status').textContent]);};
+ await run('overridden','from_now');
+ await run('leftover','from_now');
+ await run('leftover','all_history');
+ await run('custom','from_now');
+ await run('retired','from_now');
+ for(scope of ['from_now','from_date','all_history']){updateModelPriceScope();notes[scope]=$('model-price-scope-note').textContent;}
+ console.log(JSON.stringify({lifecycles,sent,confirms,scoped,toasts,statuses,notes}));
+})();
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        out = json.loads(result.stdout)
+        restore = {"label": "Restore built-in price", "scope": None}
+        self.assertEqual(out["lifecycles"], {
+            "overridden": restore,
+            "leftover": restore,
+            "plain": None,
+            "custom": {"label": "Remove custom model", "scope": None},
+            "retired": {"label": "Remove custom model", "scope": "all_history"},
+        })
+        # Restore follows the selected scope, so a From-now restore keeps older dated prices.
+        self.assertEqual(out["sent"], [
+            {"provider": "codex", "model": "gpt-5.6", "remove": True,
+             "apply_to_all_history": False},
+            {"provider": "codex", "model": "gpt-5.6", "remove": True,
+             "apply_to_all_history": True},
+            {"provider": "codex", "model": "mine", "remove": True,
+             "apply_to_all_history": False},
+            {"provider": "codex", "model": "mine", "remove": True,
+             "apply_to_all_history": True},
+        ])
+        self.assertEqual(out["scoped"], [
+            "Restore built-in pricing", "Restore built-in pricing", "Retire this custom price",
+        ])
+        self.assertEqual(out["confirms"], ["Delete mine from all saved pricing history?"])
+        # A row already built-in from now explains how to clear its saved periods instead of no-op saving.
+        self.assertEqual(out["statuses"][1][:3], ["leftover", "from_now", 0])
+        self.assertIn("Choose All history, then restore", out["statuses"][1][3])
+        self.assertNotIn("From date", out["statuses"][1][3])
+        self.assertEqual(out["toasts"][1], "Already on built-in prices: " + out["statuses"][1][3])
+        self.assertIn("id=model-pricing-status role=status aria-live=polite", self.page)
+        self.assertEqual(out["statuses"][2][:3], ["leftover", "all_history", 1])
+        self.assertEqual(out["toasts"][2],
+                         "Default price restored: gpt-5.6 uses built-in prices across all history.")
+        self.assertEqual(out["notes"]["from_now"],
+                         "Changes start when you save; older session estimates keep their prior prices.")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_settings_polling_pauses_while_the_user_is_selecting_or_editing(self):
+        functions = []
+        for name in ("settingsInteractionActive", "budgetInteractionActive"):
+            match = re.search(rf"^function {name}\(\)\{{[^\n]*\}}\n", self.page, re.MULTILINE)
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        for name in ("viewInteractionActive", "renderSettings", "renderSpendView"):
+            match = re.search(
+                rf"^function {name}\(.*?^\}}\n",
+                self.page,
+                re.MULTILINE | re.DOTALL,
+            )
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        script = """
+let settingsPointerActive=false;
+let region='settings';
+const view={contains:node=>Boolean(node?.inside===region&&region==='settings')};
+const budgetView={contains:node=>Boolean(node?.inside===region&&region==='budgets')};
+const field={get inside(){return region;},matches:selector=>selector.includes('input')};
+const outside={inside:null,matches:()=>false};
+let activeElement=outside;
+let selection={isCollapsed:true,rangeCount:0,anchorNode:null,focusNode:null};
+const document={get activeElement(){return activeElement;}};
+const window={getSelection:()=>selection};
+const $=id=>id==='view-settings'?view:id==='spend-budgets'?budgetView:null;
+let calls=[];
+const renderBudgets=()=>calls.push('budgets');
+const renderModelPricing=()=>calls.push('pricing');
+const renderSpend=()=>calls.push('spend');
+function render(){renderSettings(xs);renderSpendView(xs);}
+""" + "\n".join(functions) + """
+const xs={model_pricing:{}};
+const out={};
+for(const where of ['settings','budgets']){
+ region=where;
+ activeElement=field;
+ calls=[];render();out[where+'Focused']=[...calls];
+ activeElement=outside;
+ selection={isCollapsed:false,rangeCount:1,anchorNode:{inside:where},focusNode:{inside:where}};
+ calls=[];render();out[where+'Selected']=[...calls];
+ selection={isCollapsed:true,rangeCount:0,anchorNode:null,focusNode:null};
+ settingsPointerActive=true;
+ calls=[];render();out[where+'Dragging']=[...calls];
+ settingsPointerActive=false;
+}
+calls=[];render();out.idle=[...calls];
+console.log(JSON.stringify(out));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "settingsFocused": ["spend", "budgets"],
+            "settingsSelected": ["spend", "budgets"],
+            "settingsDragging": ["spend"],
+            "budgetsFocused": ["pricing", "spend"],
+            "budgetsSelected": ["pricing", "spend"],
+            "budgetsDragging": ["spend"],
+            "idle": ["pricing", "spend", "budgets"],
+        })
+
+    def test_software_updates_keep_checks_and_install_preferences_independent(self):
+        for marker in (
+            "data-settings-target=update-settings",
+            "settings-updates",
+            "id=update-settings",
+            "id=update-enabled",
+            "id=update-enabled type=checkbox checked",
+            "id=update-auto-install type=checkbox checked",
+            "Check for updates every 10 minutes",
+            "Automatically install available updates",
+            "Enabled by default",
+            "checks once at startup, then every 10 minutes while it is running",
+            "id=update-check",
+            "id=update-notice",
+            "New update available",
+            "/settings/updates",
+            "/updates/status",
+            "/updates/check",
+            "/updates/install",
+            "setInterval(refreshSoftwareUpdateStatus,60000)",
+            "status.available&&status.can_update",
+            "softwareUpdateTarget=SOFTWARE_UPDATE.latest_revision",
+            "softwareUpdateTarget&&state==='attention'",
+            "setTimeout(()=>location.reload(),350)",
+            "Checks fetch revision metadata only",
+            "const autoInstall=enabled&&$('update-auto-install').checked",
+            "{enabled,auto_install:autoInstall}",
+            "$('update-auto-install').disabled=!enabled",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn(".updateNotice{position:fixed;right:18px;bottom:18px", self.page)
+        self.assertIn(".softwareUpdates{display:grid;gap:8px;padding:12px 16px!important}", self.page)
+        self.assertIn(
+            ".softwareUpdateActions{display:grid;grid-template-columns:auto minmax(0,1fr) auto",
+            self.page,
+        )
+        self.assertIn(
+            "<span class=softwareUpdateMeta id=update-settings-meta></span>",
+            self.page,
+        )
+        self.assertIn(".softwareUpdateActions .tbtn:disabled{opacity:.45;cursor:not-allowed}", self.page)
+        self.assertIn("body.classList.toggle('updateReady',showNotice)", self.page)
+        self.assertNotIn("setInterval(()=>postSoftwareUpdate('/updates/install'", self.page)
+        self.assertIn("'settings-updates':'update-settings'", self.page)
+        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
+            "</div>\n</div>\n<dialog class=commandPalette", 1
+        )[0]
+        self.assertLess(
+            settings.index("data-settings-target=model-pricing-settings"),
+            settings.index("data-settings-target=update-settings"),
+        )
+        self.assertLess(
+            settings.index("id=model-pricing-settings"),
+            settings.index("id=update-settings"),
+        )
+
+    def test_settings_sections_use_matching_titles_and_compact_supporting_copy(self):
+        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
+            "</div>\n</div>\n<dialog class=commandPalette", 1
+        )[0]
+        for title, target in (
+            ("Agent connection", "agent-access"),
+            ("Model pricing", "model-pricing-settings"),
+            ("Software updates", "update-settings"),
+        ):
+            self.assertIn(
+                f"data-settings-target={target}><b>{title}</b>", settings,
+            )
+            self.assertIn(f">{title}</h2>", settings)
+        self.assertNotIn(">Monthly budget</", settings)
+        for removed in (
+            "id=agent-access-badge", "class=mcpMark", "class=agentPromise",
+            "class=agentTools", "class=agentPrivacy", "id=frustration-term-count",
+            "<div class=softwareUpdatePromise",
+        ):
+            self.assertNotIn(removed, settings)
+        self.assertNotIn('href="#learn-agent-access"', settings)
+        self.assertIn("frame:{kind:'agent',anchor:'agent-access'", self.page)
+        self.assertIn("Connections stay local and read-only.", settings)
+        self.assertNotIn("Language signals", settings)
+        self.assertIn(
+            ".settingsMap:before,.agentAccess:before,.budgetLead:before{display:none}",
+            self.page,
+        )
+
+    def test_tools_is_in_the_secondary_rail_above_settings(self):
+        secondary = self.page.split("<div class=navSecondary>", 1)[1].split(
+            "</div>", 1
+        )[0]
+        self.assertIn("id=tab-capabilities", secondary)
+        self.assertLess(secondary.index("id=tab-learn"), secondary.index("id=tab-capabilities"))
+        self.assertLess(secondary.index("id=tab-capabilities"), secondary.index("id=tab-settings"))
+
+    def test_agent_access_has_a_dedicated_settings_tab(self):
+        for marker in ("id=agent-discovery", "id=agent-access", "id=agent-clients",
+                       "id=agent-dialog", "/agent-access/status", "/agent-access/toggle",
+                       "class=\"card settingsMap\""):
+            self.assertIn(marker, self.page)
+        self.assertIn("frame:{kind:'agent',anchor:'agent-access'", self.page)
+        self.assertIn("It gets numbers only, never your prompts or code.", self.page)
+        for tool in ("mcp__tokenmeter__check", "mcp__tokenmeter__usage",
+                     "mcp__tokenmeter__capabilities"):
+            self.assertNotIn(tool, self.page)
+        self.assertLess(self.page.index("id=view-capabilities"), self.page.index("id=view-settings"))
+        self.assertLess(self.page.index("id=view-settings"), self.page.index("id=agent-access"))
+        self.assertIn("setHashRoute('settings')", self.page)
+        self.assertIn("tm_agent_discovery_dismissed", self.page)
+        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
+            "</div>\n</div>\n<dialog class=commandPalette", 1
+        )[0]
+        self.assertLess(settings.index("data-settings-target=agent-access"),
+                        settings.index("data-settings-target=model-pricing-settings"))
+        self.assertLess(settings.index("data-settings-target=model-pricing-settings"),
+                        settings.index("data-settings-target=delivery-settings"))
+        self.assertLess(settings.index("id=agent-access"),
+                        settings.index("id=model-pricing-settings"))
+        self.assertLess(settings.index("id=model-pricing-settings"),
+                        settings.index("id=delivery-settings"))
+
+    def test_settings_has_no_agent_defaults_surface_or_loader(self):
+        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
+            "</div>\n</div>\n<dialog class=commandPalette", 1
+        )[0]
+        self.assertNotIn("id=agent-default-settings", settings)
+        self.assertNotIn("id=agent-defaults", settings)
+        self.assertNotIn("function renderAgentDefaults", self.page)
+        self.assertNotIn("function loadAgentDefaultSettings", self.page)
+        self.assertNotIn("/settings/agent-defaults", self.page)
+
+    def test_agent_access_status_loads_only_when_settings_is_opened(self):
+        startup = self.page[self.page.rindex(
+            "setInterval(refreshLiveState,LIVE_STATE_POLL_MS);"
+        ):]
+        self.assertNotIn("loadAgentAccess();", startup)
+        settings_route = self.page.split(
+            "if(h==='settings'||h==='model-pricing'", 1
+        )[1].split("if(!h||h==='session')", 1)[0]
+        self.assertIn("loadAgentAccess();", settings_route)
+
+    def test_agent_access_conflict_has_an_explicit_repair_flow(self):
+        for marker in (
+            "row.conflict?'Repair':'Connect'",
+            "const repairing=!!(enabled&&row.conflict)",
+            "Replace only the existing user-level tokenmeter entry",
+            "`${row.disconnect_command}\\n${row.connect_command}`",
+            "repair:repairing",
+            "result.repaired?'Connection repaired'",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("Resolve manually", self.page)
+        self.assertNotIn("||row.conflict", self.page[self.page.index("const disabled="):self.page.index("const detail=", self.page.index("const disabled="))])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_shell.py b/tests/test_dashboard_shell.py
new file mode 100644
index 00000000..865ca152
--- /dev/null
+++ b/tests/test_dashboard_shell.py
@@ -0,0 +1,876 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardShellLayoutTests(DashboardLayoutCase):
+    def test_dashboard_uses_splunk_favicon_and_bundled_wordmark(self):
+        self.assertIn('rel=icon type="image/svg+xml"', self.page)
+        self.assertIn("data:image/svg+xml", self.page)
+        self.assertIn("M47.03 36.16v-7.58L10 10", self.page)
+        self.assertIn('class=logo role=img aria-label="Splunk by Cisco"', self.page)
+        self.assertIn('/assets/brand/logo-splunk-by-cisco-rgb-w.png', self.page)
+        self.assertIn('name=theme-color content="#07090c"', self.page)
+
+    def test_agent_activity_work_time_header_aligns_with_right_aligned_values(self):
+        self.assertIn(
+            ".agentTreeHeader .fieldtip{justify-content:flex-end}",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_browser_agent_attention_adds_cap_and_live_growth_only_with_cost_evidence(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(page.match(/^const money=.*$/m)[0].replace('const money','globalThis.money'));
+eval(extract('deriveAgentAttention'));
+const group={{root_session_id:'root',totals:{{cost:2,cost_available:true}},agents:[
+ {{id:'root',kind:'root',cost:0.5,cost_available:true,activity_state:'recent'}},
+ {{id:'child',kind:'spawned',cost:1.5,cost_available:true,activity_state:'working'}}
+],attention:[{{agent_id:'child',level:'needs_attention',reasons:[{{code:'retry_pressure',explanation:'3 retries'}}]}}]}};
+const covered=deriveAgentAttention(group,1,new Map([['root:child',1.0]]));
+const partial=deriveAgentAttention({{...group,totals:{{cost:null,cost_available:false}},agents:[group.agents[0],{{...group.agents[1],cost:null,cost_available:false}}]}},1,new Map([['root:child',1.0]]));
+process.stdout.write(JSON.stringify({{covered,partial}}));
+"""
+
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        covered = {
+            row["agent_id"]: [reason["code"] for reason in row["reasons"]]
+            for row in payload["covered"]
+        }
+        partial = {
+            row["agent_id"]: [reason["code"] for reason in row["reasons"]]
+            for row in payload["partial"]
+        }
+        self.assertEqual(covered["root"], ["cap_exceeded"])
+        self.assertEqual(covered["child"], [
+            "retry_pressure", "cap_exceeded", "observed_live_growth",
+        ])
+        self.assertEqual(partial["child"], ["retry_pressure"])
+        self.assertNotIn("root", partial)
+
+    def test_current_header_keeps_one_line_session_start_message_visible(self):
+        self.assertIn('class="card previewStartStrip"', self.page)
+        self.assertIn("id=preview-start", self.page)
+        self.assertIn("function sessionStartMessage(s)", self.page)
+        self.assertIn("$('preview-start').textContent=startMessage", self.page)
+        current = self.page.split('<div class="view on" id=view-session>', 1)[1].split(
+            "<div class=view id=view-models>", 1
+        )[0]
+        self.assertLess(current.index("id=preview-start"), current.index("id=preview-run-chart-slot"))
+        self.assertIn("text-overflow:ellipsis;white-space:nowrap", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_project_filter_groups_non_folder_labels(self):
+        match = re.search(r"function projectFilterValue\(.*?\n\}", self.page, re.DOTALL)
+        self.assertIsNotNone(match, "Project filters need folder-only values")
+        script = "const OTHER_LOCAL_SESSIONS_PROJECT='__other_local_sessions__';\n" + match.group(0) + r"""
+console.log(JSON.stringify([
+  projectFilterValue('~/Documents/github/token-meter'),
+  projectFilterValue('/repo/a'), projectFilterValue('CLI'),
+  projectFilterValue('No project'), projectFilterValue('/private/tmp/run'),
+  projectFilterValue('~/Documents/Codex/2026-08-31/task'),
+]));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), [
+            "~/Documents/github/token-meter", "/repo/a",
+            "__other_local_sessions__", "__other_local_sessions__",
+            "__other_local_sessions__",
+            "__other_local_sessions__",
+        ])
+
+    def test_fieldtips_are_portaled_and_viewport_bound(self):
+        for marker in (
+            "#fieldtip-popup{position:fixed",
+            "function initFieldTipPopup()",
+            "popup.setAttribute('role','tooltip')",
+            "const maxLeft=Math.max(margin,window.innerWidth-margin-width)",
+            "below+height<=window.innerHeight-margin||above<margin?below:above",
+            "document.addEventListener('pointerover'",
+            "window.addEventListener('scroll',scheduleFieldTipPosition,true)",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("content:attr(data-tip)", self.page)
+
+    def test_primary_navigation_and_command_palette_share_the_same_workflow_order(self):
+        tab_ids = [
+            "tab-session", "tab-daily", "tab-models", "tab-subagents",
+            "tab-efficiency", "tab-work", "tab-git", "tab-performance", "tab-learn",
+            "tab-capabilities", "tab-settings",
+        ]
+        positions = [self.page.index(f"id={tab_id}") for tab_id in tab_ids]
+        self.assertEqual(positions, sorted(positions))
+        for marker in (
+            "id=command-palette", "id=command-search",
+            "const NAV_COMMANDS=[",
+            "key==='k'", "event.key==='Escape'", "event.key==='ArrowDown'",
+            "event.key==='Enter'",
+            "class=tabs aria-label=\"Primary navigation\"",
+            "button.setAttribute('aria-current','page')",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("if(command.latest)goToLatestSession()", self.page)
+        self.assertIn("action:'selected-session'", self.page)
+        self.assertIn("function openSelectedSessionRoute(route='summary')", self.page)
+        self.assertIn("history.pushState({sessionScope:sessionReturnScope},'',sessionRoute(pinned))", self.page)
+        self.assertIn("if(command.action==='selected-session'){openSelectedSessionRoute(command.route);return;}", self.page)
+        self.assertIn("else openTopLevelRoute(command.route)", self.page)
+        self.assertNotIn("shortcut:'⌥", self.page)
+        self.assertNotIn("id=command-trigger", self.page)
+        self.assertNotIn("Local evidence", self.page)
+        self.assertNotIn("class=pulse", self.page)
+        self.assertNotIn("@keyframes p{", self.page)
+        self.assertNotIn("id=live", self.page)
+        self.assertNotIn("id=livetxt", self.page)
+        self.assertNotIn("$('live')", self.page)
+        self.assertNotIn("$('livetxt')", self.page)
+        self.assertNotIn("id=command-alt-key", self.page)
+        self.assertNotIn("class=commandShortcut", self.page)
+
+    def test_top_level_pages_have_no_numbered_shortcuts(self):
+        for tab_id in (
+            "session", "daily", "models", "subagents", "efficiency",
+            "work", "git", "learn", "capabilities", "settings",
+        ):
+            match = re.search(rf'<button[^>]+id=tab-{tab_id}[^>]*>.*?</button>', self.page)
+            self.assertIsNotNone(match, tab_id)
+            button = match.group(0)
+            self.assertNotIn("aria-keyshortcuts", button)
+            self.assertNotIn("Shortcut", button)
+            self.assertNotIn("tabShortcut", button)
+        for marker in ("directKey", "tabShortcut", "Shortcut: Option+", "event.code"):
+            self.assertNotIn(marker, self.page)
+        perf = Path(__file__).resolve().parents[1].joinpath("performance.html").read_text(encoding="utf-8")
+        for marker in ("aria-keyshortcuts", "data-shortcut-digit", "railShortcut", "Shortcut: Option+", "event.code"):
+            self.assertNotIn(marker, perf)
+
+    def test_all_sessions_live_updates_preserve_mounted_rows(self):
+        for marker in (
+            "const logHtmlCache=new WeakMap()",
+            "function setLogText(element,value)",
+            "function setLogAttribute(element,name,value)",
+            "function setLogHtml(element,html)",
+            "function logRowRenderKey(s,active)",
+            "function reconcileLogRows(sessions,maxCost,liveSessionIds=new Set())",
+            "const interactingLogRow=forceAllSessionRowRefresh?null:root.querySelector('.srow:hover,.srow:focus-within');",
+            "if(interactingLogRow)return;",
+            "function mergeAllSessionInventory(inventory,liveSessions)",
+            "const key=row=>row?.key?compareKeyFor(row):sessionRowKey(row);",
+            "(liveSessions||[]).forEach(row=>rows.set(key(row),row))",
+            "const liveSessionIds=new Set((xs.current_sessions||[]).map(sessionRowKey));",
+            "const live=liveSessionIds.has(key)",
+            "const hasChildren=childAgentsFor(s).length>0;",
+            "const compareIndex=compareIds.indexOf(rowKey);",
+            "className=`srow${active?' active':''}${live?' live':''}${hasChildren?' hasChildren':''}${compareIndex>=0?' compareSelected':''}`",
+            ".srow.active,.srow.live{border-color:rgb(var(--signal-rgb)/.62)",
+            "const existing=new Map([...root.children]",
+            "if(row.className!==className)row.className=className",
+            "if(row.getAttribute('aria-label')!==ariaLabel)",
+            "if(row._logRenderKey!==renderKey)",
+            "else root.insertBefore(row,cursor)",
+            "reconcileLogRows(sessions,maxCost,liveSessionIds)",
+            "$('slist').onclick=event=>",
+            "$('slist').onkeydown=event=>",
+            "const inventoryStale=!allSessionInventory",
+            "if(inventoryStale)loadAllSessions()",
+            "else renderAllSessions(LATEST.xsession)",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn(
+            "body.spectrumApp.sessionRoute #view-session .srow:hover{transform:none}",
+            self.page,
+        )
+        self.assertNotIn("$('slist').innerHTML=sessions.length?sessions.map", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_header_names_the_opened_trace_not_a_sibling(self):
+        script = "let allSessionInventory=null;\n" + "\n".join(
+            self.page_function(self.page, name)
+            for name in ("stateSessionId", "stateSessionKey", "sessionStartMessage", "sessionDisplayName")
+        ) + """
+const state={session:'rollout-child.jsonl',source:{id:'task-1'},xsession:{current_sessions:[],sessions:[
+ {id:'task-1',session:'rollout-root.jsonl',title:'Root title'},
+ {id:'task-1',session:'rollout-child.jsonl',title:'Child title'}]}};
+const sibling={...state,session:'rollout-other.jsonl'};
+// Older traces fall outside the recent rows but are in the All sessions inventory the user opened them from.
+allSessionInventory=[{id:'task-1',session:'rollout-old.jsonl',title:'Old title'}];
+const older={...state,session:'rollout-old.jsonl'};
+console.log(JSON.stringify([sessionDisplayName(state),sessionDisplayName(sibling),sessionDisplayName(older)]));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        self.assertEqual(json.loads(result.stdout), ["Child title", "Session", "Old title"])
+
+    def test_all_sessions_inventory_is_declared_before_the_first_header_render(self):
+        declaration = self.page.index("let allSessionInventory=null")
+        self.assertLess(declaration, self.page.index("function showCurrentPanel("))
+        self.assertLess(declaration, self.page.index("function applyHashRoute(){"))
+
+    def test_custom_fieldtips_remove_delayed_native_tooltips_globally(self):
+        self.assertIn("root.querySelectorAll('.fieldtip[title]')", self.page)
+        self.assertIn("stripNativeFieldTipTitles();", self.page)
+        self.assertIn('return `class=fieldtip tabindex=0 aria-description="${safe}" data-tip="${safe}"`', self.page)
+        self.assertNotIn('return `class=fieldtip tabindex=0 title="${safe}"', self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_page_signal_presentations_share_one_animation_timeline(self):
+        functions = []
+        for name in ("pageSignalTiming", "sessionSignalPresentation", "pageSignalPresentation"):
+            match = re.search(
+                rf"^function {name}\(.*?^\}}\n",
+                self.page,
+                re.MULTILINE | re.DOTALL,
+            )
+            self.assertIsNotNone(match, f"dashboard needs {name}")
+            functions.append(match.group(0))
+        script = """
+let pageSignalClockStartedAt=1000;
+let clockNow=11000;
+const performance={now:()=>clockNow};
+""" + "\n".join(functions) + """
+let latestSessionSignalSnapshot={evidence:'available',mode:'working'};
+const pageSignalReducedMotionQuery={matches:false};
+const signals=['sessions','spend','models','capabilities','efficiency','learn','settings'];
+const routes=Object.fromEntries(signals.map(signal=>[
+ signal,pageSignalPresentation({dataset:{pageSignal:signal}}),
+]));
+const states={};
+for(const mode of ['working','waiting','recent','idle']){
+ states[mode]=sessionSignalPresentation({evidence:'available',mode},false);
+}
+states.unavailable=sessionSignalPresentation({evidence:'unavailable',mode:'idle'},false);
+latestSessionSignalSnapshot={evidence:'unavailable',mode:'idle'};
+const unavailable=pageSignalPresentation({dataset:{pageSignal:'sessions'}});
+clockNow=17000;
+latestSessionSignalSnapshot={evidence:'available',mode:'working'};
+const continued=Object.fromEntries(signals.map(signal=>[
+ signal,pageSignalPresentation({dataset:{pageSignal:signal}}),
+]));
+pageSignalReducedMotionQuery.matches=true;
+const reduced=Object.fromEntries(signals.map(signal=>[
+ signal,pageSignalPresentation({dataset:{pageSignal:signal}}),
+]));
+console.log(JSON.stringify({routes,states,unavailable,continued,reduced}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        timing = {
+            "heroSpeed": 0.018,
+            "heroFrame": 180,
+            "borderSpeed": 0.016,
+            "borderFrame": 9160,
+        }
+        for presentation in rendered["routes"].values():
+            self.assertEqual(
+                {key: presentation[key] for key in timing},
+                timing,
+            )
+        states = rendered["states"]
+        for mode in ("working", "waiting", "recent", "idle"):
+            self.assertEqual({key: states[mode][key] for key in timing}, timing)
+        self.assertGreater(states["working"]["heroStrength"], states["idle"]["heroStrength"])
+        self.assertEqual(rendered["unavailable"]["heroSpeed"], 0)
+        self.assertEqual(rendered["unavailable"]["borderSpeed"], 0)
+        self.assertEqual(rendered["unavailable"]["heroFrame"], timing["heroFrame"])
+        self.assertEqual(rendered["unavailable"]["borderFrame"], timing["borderFrame"])
+        continued_timing = {
+            "heroSpeed": 0.018,
+            "heroFrame": 288,
+            "borderSpeed": 0.016,
+            "borderFrame": 9256,
+        }
+        for presentation in rendered["continued"].values():
+            self.assertEqual(
+                {key: presentation[key] for key in continued_timing},
+                continued_timing,
+            )
+        for presentation in rendered["reduced"].values():
+            self.assertEqual(presentation["heroSpeed"], 0)
+            self.assertEqual(presentation["borderSpeed"], 0)
+            self.assertEqual(presentation["heroFrame"], continued_timing["heroFrame"])
+            self.assertEqual(presentation["borderFrame"], continued_timing["borderFrame"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_page_signal_route_change_disposes_a_partially_mounted_effect(self):
+        page_path = Path(DASHBOARD_PAGE)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{
+ let start=page.indexOf(`function ${{name}}(`);
+ if(start<0)throw new Error(name);
+ if(page.slice(start-6,start)==='async ')start-=6;
+ let i=page.indexOf('{{',start),depth=0;
+ for(;i<page.length;i++){{
+  if(page[i]==='{{')depth++;
+  else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);
+ }}
+}}
+class El{{
+ constructor(name){{this.name=name;this.dataset={{}};this.children=[];this.isConnected=true;this.className='';}}
+ querySelector(selector){{return this.children.find(child=>selector.includes(child.className))||null;}}
+ appendChild(child){{this.children.push(child);return child;}}
+ append(...children){{this.children.push(...children);}}
+ setAttribute(){{}}
+ replaceChildren(){{this.children=[];}}
+ closest(selector){{return selector.includes('sessionDetail')?null:this;}}
+}}
+let currentHead=null;
+const document={{querySelector(){{return currentHead;}},createElement(){{return new El('created');}}}};
+let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
+let activePageSignalMounting=false,activePageSignalGeneration=0,pageEffectsDisabled=false;
+let live=[];
+const borderResolvers=[];
+function handle(label){{
+ live.push(label);
+ return {{update(){{}},dispose(){{live=live.filter(value=>value!==label);}}}};
+}}
+let currentMount='A';
+function loadPageEffectsModule(){{
+ return Promise.resolve({{
+  mountDitherField(){{return Promise.resolve(handle(`hero:${{currentMount}}`));}},
+  mountPulsingBorder(){{
+   const label=`border:${{currentMount}}`;
+   return new Promise(resolve=>borderResolvers.push(()=>resolve(handle(label))));
+  }},
+ }});
+}}
+function pageSignalPresentation(){{return {{}};}}
+eval(extract('ensurePageSignalHosts'));
+eval(extract('disposeActivePageSignalEffects'));
+if(page.includes('function pageSignalHandle('))eval(extract('pageSignalHandle'));
+eval(extract('syncActivePageSignalEffects'));
+(async()=>{{
+ const a=new El('A'),b=new El('B');
+ a.dataset.pageSignal='models';b.dataset.pageSignal='spend';
+ currentHead=a;currentMount='A';
+ const mountA=syncActivePageSignalEffects();
+ await Promise.resolve();await Promise.resolve();await Promise.resolve();
+ const afterAHero=[...live];
+ currentHead=b;currentMount='B';
+ const mountB=syncActivePageSignalEffects();
+ await Promise.resolve();await Promise.resolve();await Promise.resolve();
+ const afterRouteChange=[...live];
+ borderResolvers.shift()();
+ await Promise.resolve();await Promise.resolve();
+ const afterStaleBorder=[...live];
+ borderResolvers.shift()();
+ await Promise.all([mountA,mountB]);
+ console.log(JSON.stringify({{afterAHero,afterRouteChange,afterStaleBorder,complete:live}}));
+}})().catch(error=>{{console.error(error);process.exitCode=1;}});
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["afterAHero"], ["hero:A"])
+        self.assertEqual(rendered["afterRouteChange"], ["hero:B"])
+        self.assertEqual(rendered["afterStaleBorder"], ["hero:B"])
+        self.assertEqual(rendered["complete"], ["hero:B", "border:B"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_stale_same_header_mount_cannot_clear_the_new_ready_marker(self):
+        page_path = Path(DASHBOARD_PAGE)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{
+ let start=page.indexOf(`function ${{name}}(`);
+ if(start<0)throw new Error(name);
+ if(page.slice(start-6,start)==='async ')start-=6;
+ let i=page.indexOf('{{',start),depth=0;
+ for(;i<page.length;i++){{
+  if(page[i]==='{{')depth++;
+  else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);
+ }}
+}}
+class El{{
+ constructor(name){{this.name=name;this.dataset={{}};this.children=[];this.isConnected=true;this.className='';}}
+ querySelector(selector){{
+  const wanted=selector.slice(1);
+  for(const child of this.children){{
+   if(child.className===wanted)return child;
+   const nested=child.querySelector(selector);
+   if(nested)return nested;
+  }}
+  return null;
+ }}
+ appendChild(child){{this.children.push(child);return child;}}
+ append(...children){{this.children.push(...children);}}
+ setAttribute(){{}}
+ replaceChildren(){{this.children=[];}}
+ closest(selector){{return selector.includes('sessionDetail')?null:this;}}
+}}
+let currentHead=null,currentMount='',live=[],borderQueue=[];
+const document={{querySelector(){{return currentHead;}},createElement(){{return new El('created');}}}};
+let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
+let activePageSignalMounting=false,activePageSignalGeneration=0,pageEffectsDisabled=false;
+function handle(label,host){{
+ live.push(label);host.dataset.pageEffect='ready';let disposed=false;
+ return {{
+  update(){{}},
+  dispose(){{
+   if(!disposed){{disposed=true;live=live.filter(value=>value!==label);}}
+   delete host.dataset.pageEffect;
+  }},
+ }};
+}}
+function loadPageEffectsModule(){{
+ return Promise.resolve({{
+  mountDitherField(host){{return Promise.resolve(handle(`hero:${{currentMount}}`,host));}},
+  mountPulsingBorder(host){{
+   const label=`border:${{currentMount}}`;
+   return new Promise(resolve=>borderQueue.push({{label,resolve:()=>resolve(handle(label,host))}}));
+  }},
+ }});
+}}
+function pageSignalPresentation(){{return {{}};}}
+eval(extract('ensurePageSignalHosts'));
+eval(extract('disposeActivePageSignalEffects'));
+if(page.includes('function pageSignalHandle('))eval(extract('pageSignalHandle'));
+eval(extract('syncActivePageSignalEffects'));
+const ticks=async(count=5)=>{{while(count--)await Promise.resolve();}};
+(async()=>{{
+ const a=new El('A'),b=new El('B');
+ a.dataset.pageSignal='models';b.dataset.pageSignal='spend';
+ currentHead=a;currentMount='A1';const mountA1=syncActivePageSignalEffects();await ticks();
+ currentHead=b;currentMount='B';const mountB=syncActivePageSignalEffects();await ticks();
+ currentHead=a;currentMount='A2';const mountA2=syncActivePageSignalEffects();await ticks();
+ const aHero=a.querySelector('.pageDither');
+ const before={{live:[...live],heroState:aHero.dataset.pageEffect||null}};
+ borderQueue.find(row=>row.label==='border:A1').resolve();await mountA1;await ticks();
+ const afterStale={{live:[...live],heroState:aHero.dataset.pageEffect||null}};
+ borderQueue.find(row=>row.label==='border:B').resolve();await mountB;await ticks();
+ borderQueue.find(row=>row.label==='border:A2').resolve();await mountA2;
+ console.log(JSON.stringify({{before,afterStale,complete:{{live,heroState:aHero.dataset.pageEffect||null}}}}));
+}})().catch(error=>{{console.error(error);process.exitCode=1;}});
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered["before"], {
+            "live": ["hero:A2"], "heroState": "ready",
+        })
+        self.assertEqual(rendered["afterStale"], {
+            "live": ["hero:A2"], "heroState": "ready",
+        })
+        self.assertEqual(rendered["complete"], {
+            "live": ["hero:A2", "border:A2"], "heroState": "ready",
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_shared_border_readiness_cancels_stale_mounts_before_construction(self):
+        page_path = Path(DASHBOARD_PAGE)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{
+ let start=page.indexOf(`function ${{name}}(`);
+ if(start<0)throw new Error(name);
+ if(page.slice(start-6,start)==='async ')start-=6;
+ let i=page.indexOf('{{',start),depth=0;
+ for(;i<page.length;i++){{
+  if(page[i]==='{{')depth++;
+  else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);
+ }}
+}}
+class El{{
+ constructor(name){{this.name=name;this.dataset={{}};this.children=[];this.isConnected=true;this.className='';}}
+ querySelector(selector){{
+  const wanted=selector.slice(1);
+  for(const child of this.children){{
+   if(child.className===wanted)return child;
+   const nested=child.querySelector(selector);
+   if(nested)return nested;
+  }}
+  return null;
+ }}
+ appendChild(child){{this.children.push(child);return child;}}
+ append(...children){{this.children.push(...children);}}
+ setAttribute(){{}}
+ replaceChildren(){{this.children=[];}}
+ closest(selector){{return selector.includes('sessionDetail')?null:this;}}
+}}
+let currentHead=null,currentMount='',live=[];
+let releaseSharedBorder;
+const sharedBorderReady=new Promise(resolve=>{{releaseSharedBorder=resolve;}});
+const document={{querySelector(){{return currentHead;}},createElement(){{return new El('created');}}}};
+let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
+let activePageSignalMounting=false,activePageSignalGeneration=0,pageEffectsDisabled=false;
+function handle(label,host){{
+ live.push(label);host.dataset.pageEffect='ready';host.paperShaderMount=label;let disposed=false;
+ return {{
+  update(){{}},
+  dispose(){{
+   if(disposed)throw new Error(`double dispose ${{label}}`);
+   disposed=true;live=live.filter(value=>value!==label);
+   delete host.dataset.pageEffect;delete host.paperShaderMount;
+  }},
+ }};
+}}
+function loadPageEffectsModule(){{
+ return Promise.resolve({{
+  mountDitherField(host){{return Promise.resolve(handle(`hero:${{currentMount}}`,host));}},
+  async mountPulsingBorder(host,presentation,isCurrent){{
+   const label=`border:${{currentMount}}`;
+   await sharedBorderReady;
+   if(isCurrent&&!isCurrent())return null;
+   return handle(label,host);
+  }},
+ }});
+}}
+function pageSignalPresentation(){{return {{}};}}
+eval(extract('ensurePageSignalHosts'));
+eval(extract('disposeActivePageSignalEffects'));
+if(page.includes('function pageSignalHandle('))eval(extract('pageSignalHandle'));
+eval(extract('syncActivePageSignalEffects'));
+const ticks=async(count=8)=>{{while(count--)await Promise.resolve();}};
+(async()=>{{
+ const a=new El('A'),b=new El('B');
+ a.dataset.pageSignal='models';b.dataset.pageSignal='spend';
+ currentHead=a;currentMount='A1';const mountA1=syncActivePageSignalEffects();await ticks();
+ currentHead=b;currentMount='B';const mountB=syncActivePageSignalEffects();await ticks();
+ currentHead=a;currentMount='A2';const mountA2=syncActivePageSignalEffects();await ticks();
+ const aHero=a.querySelector('.pageDither'),aBorder=a.querySelector('.pageHeroBorder');
+ releaseSharedBorder();
+ await Promise.all([mountA1,mountB,mountA2]);await ticks();
+ console.log(JSON.stringify({{
+  live,
+  heroState:aHero.dataset.pageEffect||null,
+  borderState:aBorder.dataset.pageEffect||null,
+  borderOwner:aBorder.paperShaderMount||null,
+  disabled:pageEffectsDisabled,
+ }}));
+}})().catch(error=>{{console.error(error);process.exitCode=1;}});
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        rendered = json.loads(result.stdout)
+        self.assertEqual(rendered, {
+            "live": ["hero:A2", "border:A2"],
+            "heroState": "ready",
+            "borderState": "ready",
+            "borderOwner": "border:A2",
+            "disabled": False,
+        })
+
+    def test_top_level_pages_share_one_dither_header_system(self):
+        for marker in (
+            "data-page-signal=sessions",
+            "data-page-signal=spend",
+            "data-page-signal=models",
+            "data-page-signal=subagents",
+            "data-page-signal=capabilities",
+            "data-page-signal=learn",
+            "data-page-signal=settings",
+            "class=spectrumPageHeadFrame",
+            "class=\"spectrumPageHeadFrame hasPageActions\"",
+            "class=spectrumPageSubtitle",
+            "class=spectrumPageActions",
+            "function ensurePageSignalHosts(head)",
+            "function syncActivePageSignalEffects()",
+            "document.querySelector('.view.on .spectrumPageHead[data-page-signal]')",
+            "activePageHeroHandle?.dispose()",
+            "activePageBorderHandle?.dispose()",
+            "requestAnimationFrame(syncActivePageSignalEffects)",
+            "function syncSessionFlow(snapshot)",
+            "import('/assets/session-effects.js')",
+            "if(label.textContent!==nextLabel)",
+            "data-session-flow",
+            ".currentSessionCard.is-arriving",
+            "@keyframes currentSessionArrive",
+            "@media(prefers-reduced-motion:reduce)",
+        ):
+            self.assertIn(marker, self.page)
+        for rejected_marker in (
+            "sessionFlowField",
+            "sessionFlowLine",
+            "sessionFlowPacket",
+            "currentSessionFlow",
+            "sessionAmbient",
+            "sessionGodRays",
+            "session-god-rays",
+            "sessionPrimaryBorder",
+            "session-primary-border",
+            "syncPrimarySessionBorder",
+            "primaryWorkingSessionId",
+            "neuro-noise",
+            "neuroNoise",
+            "currentSessionStateShift",
+            "<animateMotion",
+            "offset-path:path",
+        ):
+            self.assertNotIn(rejected_marker, self.page)
+
+    def test_top_level_headers_use_fixed_shared_heights_and_concise_subtitles(self):
+        for marker in (
+            ".spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;height:138px",
+            "@media(max-width:900px){.spectrumPageHead{height:126px",
+            "@media(max-width:520px){.spectrumPageHead{height:116px",
+            ".spectrumPageSubtitle{max-width:52ch;margin:6px 0 0;color:var(--dim);font-size:var(--fs-12);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}",
+            ".spectrumPageActions{position:absolute;z-index:5;right:30px;bottom:24px",
+            ".spectrumPageActions{position:static;display:flex;width:100%;max-width:none",
+            "Last 30 minutes",
+            "Track the cost of your custom agents.",
+            "Tools, MCP servers, and skills.",
+            "What the spend went into.",
+            "Pushed code &times; covered spend &middot; <span class=fieldtip id=d-caveat",
+            "Spend tokens like money. Measure what you get back.",
+            "Connections, pricing, and updates.",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertEqual(self.page.count("data-page-signal="), 10)
+        self.assertEqual(self.page.count("class=spectrumPageSubtitle"), 7)
+        for removed in ("Live local traces · last 30 minutes.", "Estimated agent spend over time.", "Cost, speed, and context.", "Local token efficiency."):
+            self.assertNotIn(removed, self.page)
+        self.assertNotIn(".spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;min-height:138px", self.page)
+
+    def test_shared_header_effect_adapter_exposes_generic_mounts(self):
+        for marker in (
+            "orderedDitherRainFragmentShader",
+            "export async function mountDitherField",
+            "export async function mountPulsingBorder(element, presentation, isCurrent = () => true)",
+            "if (!isCurrent()) return null;",
+        ):
+            self.assertIn(marker, self.session_effects)
+        self.assertNotIn("export async function mountSessionHero", self.session_effects)
+        self.assertNotIn("export async function mountSessionBorder", self.session_effects)
+
+    def test_desktop_action_headers_keep_titles_inside_their_text_slot(self):
+        titles = re.findall(
+            r'class="spectrumPageHeadFrame hasPageActions".*?<h1(?:\s[^>]*)?>([^<]+)</h1>',
+            self.page,
+            re.DOTALL,
+        )
+        self.assertEqual(
+            titles, ["Sessions", "Subagents", "Models", "Spend", "Efficiency", "Work", "Git", "Learn"],
+        )
+        self.assertTrue(all(len(title) <= 12 for title in titles))
+
+    def test_mobile_header_action_rows_scroll_instead_of_stacking(self):
+        for marker in (
+            ".spectrumPageActions .modelControls{display:grid;width:100%;grid-template-columns:repeat(3,minmax(0,1fr))",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("data-spend-range", self.page)
+        self.assertNotIn(".spendRangeControls .seg", self.page)
+
+    def test_session_shader_border_tracks_the_hero_edges(self):
+        for marker in (
+            "u_marginLeft: 0.002",
+            "u_marginRight: 0.002",
+            "u_marginTop: 0.002",
+            "u_marginBottom: 0.002",
+        ):
+            self.assertIn(marker, self.session_effects)
+        self.assertNotIn("u_marginLeft: 0.014", self.session_effects)
+        self.assertNotIn("u_marginTop: 0.024", self.session_effects)
+
+    def test_session_dither_uses_downward_ordered_pixel_streams(self):
+        for marker in (
+            "orderedDitherRainFragmentShader",
+            "const int bayer4x4[16]",
+            "float fallingPhase",
+            "cell.y + u_time * speed",
+            "float streamHead",
+        ):
+            self.assertIn(marker, self.session_effects)
+        self.assertNotIn("DitheringShapes.", self.session_effects)
+
+    def test_collapsed_navigation_keeps_session_scope_labels_visible(self):
+        self.assertIn(
+            "body.spectrumApp .top .brandCopy,body.spectrumApp .top .tabLabel{display:none}",
+            self.page,
+        )
+        self.assertIn("body.spectrumApp .top .brandCopy{display:grid}", self.page)
+        self.assertIn("body.spectrumApp .top .tabLabel{display:inline}", self.page)
+        self.assertNotIn(".brandCopy,.tabLabel,.tabShortcut{display:none}", self.page)
+
+    def test_redundant_hover_tips_are_removed_from_dashboard_labels(self):
+        for marker in (
+            '<h1 class=fieldtip id=session-page-title',
+            '<h1 class=fieldtip tabindex=0 aria-description="Local AI app logs',
+            '<h1 class=fieldtip tabindex=0 aria-description="Compare model runtimes',
+            '<h1 class=fieldtip tabindex=0 aria-description="What changed',
+            '<h1 class=fieldtip tabindex=0 aria-description="A practical review loop',
+            '<h1 class=fieldtip tabindex=0 aria-description="Review local tool',
+            '<h1 class=fieldtip tabindex=0 aria-description="Machine-wide controls',
+            'class="currentSessionsCount fieldtip"',
+            'class="previewStartText fieldtip"',
+            'class="card previewKpi fieldtip',
+            'class="learnShortcut fieldtip"',
+            '<h2 class=fieldtip tabindex=0 aria-description="Where the day’s covered spend',
+        ):
+            self.assertNotIn(marker, self.page)
+        for marker in (
+            '<h1 id=session-page-title>Sessions</h1>',
+            '<h2 class=workSrOnly>All sessions</h2>',
+            '<h1>Models</h1>',
+            '<h1>Spend</h1>',
+            '<h1>Learn</h1>',
+            '<h1>Tools</h1>',
+            '<h1>Settings</h1>',
+            '<div class="card previewKpi metric">',
+            'data-tip="Observed model output divided by attributable timing.',
+            'data-tip="Budget minus observed spend.',
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_sessions_use_the_distilled_token_meter_spectrum_system(self):
+        for marker in (
+            "shared-spectrum-system-v1",
+            "session-spectrum-field-v2",
+            "THESIS: Sessions are live instruments",
+            "<body class=spectrumApp>",
+            ":root,[data-theme=classic]{",
+            "--signal:#00bceb",
+            "--signal-mid:#1ba0e1",
+            "--signal-hi:#7fdbf2",
+            "--aura:#c7a7ff",
+            "--orange:#ffb457",
+            "body.sessionRoute{",
+            "--session-signal:var(--signal)",
+            'class="previewHead spectrumPageHead sessionFlowHead"',
+            'class="previewHeadCopy spectrumPageHeadCopy"',
+            ".spectrumPageHead:before",
+            ".spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;height:138px;align-items:flex-start",
+            ".currentSessionCard:before{content:none}",
+            ".currentSessionCard.activity-working",
+            ".currentSessionGrip",
+            "@media(prefers-reduced-motion:reduce)",
+            "document.body.classList.toggle('sessionRoute',t==='session');",
+            "$('view-session').classList.toggle('sessionOverview',overview);",
+            "$('view-session').classList.toggle('sessionDetail',!overview);",
+            "$('session-page-title').textContent=overview?'Sessions':sessionDisplayName(CURRENT);",
+            "function sessionDisplayName(s)",
+            "activity-${activity}",
+            "<svg class=currentSessionGrip",
+            'font-family:"Tektur Local"',
+            'src:url("/assets/fonts/Tektur-Variable.ttf")',
+            "filterView.countLabel",
+            "concept-roll seed a5c0fdde",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("id=current-eyebrow", self.page)
+        self.assertNotIn("miraiVerticalNote", self.page)
+        self.assertNotIn("miraiGaugeScale", self.page)
+        self.assertNotIn("直近30分", self.page)
+        self.assertNotIn("稼働状況", self.page)
+        self.assertNotIn("session-solar-field-v1", self.page)
+        self.assertNotIn("body.sessionRoute #view-session.sessionDetail .previewHead{min-height:152px}", self.page)
+        self.assertNotIn("body.sessionRoute #view-session.sessionDetail .previewStatus:before", self.page)
+        self.assertNotIn("body.sessionRoute #view-session.sessionDetail .previewStatus:after", self.page)
+
+    def test_top_level_views_share_the_spectrum_design_primitives(self):
+        for marker in (
+            "shared-spectrum-system-v1",
+            "spectrum-professional-finish-v2",
+            "--spectrum-card:",
+            "--spectrum-edge-light:",
+            "--spectrum-edge-hover:",
+            "--spectrum-depth-focus:",
+            "--spectrum-active-hover:",
+            "body.spectrumApp .card{",
+            "body.spectrumApp .tbtn{",
+            "body.spectrumApp .seg{",
+            "body.spectrumApp .tab.on,body.spectrumApp .seg button.on",
+            "body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary)",
+            "body.spectrumApp .spectrumPageHead:after",
+            "--spectrum-page:radial-gradient",
+            "--spectrum-card:radial-gradient",
+            "--spectrum-control:radial-gradient",
+            "--spectrum-active:linear-gradient",
+            '<div class="previewHead spectrumPageHead sessionFlowHead"',
+            '<header class="capPageHead spectrumPageHead"',
+            '<div class="modelHead spectrumPageHead"',
+            '<div class="dailyHead spectrumPageHead"',
+            '<div class="learnHead spectrumPageHead"',
+            '<div class="learnHead settingsPageHead spectrumPageHead"',
+            "<h1>Tools</h1>",
+            "<span class=allSessionsHint id=g-hint>Recent activity</span>",
+            "vertical-navigation-rail-v1",
+            "body.spectrumApp .wrap{--navigation-rail-width:184px",
+            "grid-template-columns:var(--navigation-rail-width) minmax(0,1320px)",
+            "body.spectrumApp .top{grid-column:1;grid-row:1;position:sticky",
+            "body.spectrumApp .top .tabs{display:flex;min-width:0;max-width:100%;overflow:visible;flex:1;flex-direction:column",
+            "body.spectrumApp .top .tab{display:grid;width:100%;min-height:42px",
+            "class=tabIcon",
+            "class=navPrimary",
+            "class=navSecondary",
+            ".navPrimary,.navSecondary{display:flex;flex-direction:column;gap:4px}",
+            ".navSecondary{margin-top:auto",
+            "@media(max-width:1180px){body.spectrumApp .wrap{--navigation-rail-width:68px",
+            "@media(max-width:760px){body.spectrumApp .wrap{display:block",
+            "body.spectrumApp .top .tabs{grid-column:1/-1;grid-row:2;min-width:0;width:100%;overflow-x:auto;flex:none;flex-direction:row",
+            ".navPrimary,.navSecondary{display:contents}",
+            "@media(max-width:760px){#view-models{overflow-x:clip}}",
+            "body.spectrumApp .settingsMap{grid-template-columns:repeat(6,minmax(0,1fr))",
+        ):
+            self.assertIn(marker, self.page)
+        for marker in (
+            "data-settings-target=budget-settings><span>01",
+            "data-settings-target=agent-access><span>02",
+            "data-settings-target=model-pricing-settings><span>03",
+            "data-settings-target=frustration-settings><span>04",
+            "data-settings-target=update-settings><span>05",
+            "&#8249;",
+            "&#8250;",
+        ):
+            self.assertNotIn(marker, self.page)
+
+    def test_handler_swallows_browser_disconnects(self):
+        source = Path(meter.IMPLEMENTATION_FILE).read_text()
+        self.assertIn("except (BrokenPipeError, ConnectionResetError):", source)
+
+    def test_dashboard_live_updates_do_not_hold_event_stream_connections(self):
+        self.assertNotIn("new EventSource('/events')", self.page)
+        self.assertIn("const LIVE_STATE_POLL_MS=1000", self.page)
+        self.assertIn("setInterval(refreshLiveState,LIVE_STATE_POLL_MS)", self.page)
+        self.assertIn("if(statePollBusy)return", self.page)
+        poll = self.page.split("async function refreshLiveState(){", 1)[1].split("\n}\n", 1)[0]
+        self.assertIn("applyLiveState(await fetchLiveJson('/state',LIVE_XSESSION.state,'State'))", poll)
+        source = Path(meter.IMPLEMENTATION_FILE).read_text()
+        state_route = source.index('elif req_path == "/state":')
+        self.assertIn("dashboard_state_body(", source[state_route:state_route + 400])
+        session_route = source.index('elif req_path == "/session":')
+        self.assertIn(
+            "dashboard_state_body(st or {}, known)",
+            source[session_route:state_route],
+        )
+        events = source.index('elif req_path == "/events":')
+        self.assertIn("self.send_response(204)", source[events:events + 700])
+
+    def test_http_server_tolerates_browser_connection_bursts(self):
+        self.assertTrue(meter.TokenMeterHTTPServer.daemon_threads)
+        self.assertGreaterEqual(meter.TokenMeterHTTPServer.request_queue_size, 32)
+
+    def test_dynamic_responses_cannot_be_reused_from_an_http_cache(self):
+        handler = mock.Mock()
+        meter.H._send(handler, "{}", "application/json")
+
+        handler.send_header.assert_any_call("Cache-Control", "no-store, max-age=0")
+        handler.send_header.assert_any_call("Pragma", "no-cache")
+        handler.send_header.assert_any_call("Expires", "0")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_spend.py b/tests/test_dashboard_spend.py
new file mode 100644
index 00000000..c3061aee
--- /dev/null
+++ b/tests/test_dashboard_spend.py
@@ -0,0 +1,849 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardSpendLayoutTests(DashboardLayoutCase):
+    def test_browser_operational_alerts_are_budget_only(self):
+        self.assertNotIn("function isNotifiableInsight(i)", self.page)
+        self.assertNotIn("fireNotification('Token insight'", self.page)
+        self.assertNotIn("id=spike", self.page)
+        self.assertNotIn("tm_spike", self.page)
+        self.assertNotIn("s.last_turn_cost>spike", self.page)
+        self.assertIn(
+            "fireNotification('Token Meter session budget'",
+            self.page,
+        )
+        self.assertIn(
+            "fireNotification(isExceeded?'Token Meter budget exceeded':'Token Meter monthly budget'",
+            self.page,
+        )
+        self.assertIn("n.title!=='Token insight'", self.page)
+        self.assertIn(
+            "String(n.body||'').startsWith('Last execution cost ')",
+            self.page,
+        )
+        settings = self.page[self.page.index("id=view-settings"):]
+        rail = self.page[self.page.index("<div class=top aria-label="):self.page.index("<div id=session-depot")]
+        for marker in (
+            "class=budgetBrowserAlerts", "class=budgetBrowserAlertsCopy",
+            "Browser delivery",
+        ):
+            self.assertNotIn(marker, settings)
+        for marker in (
+            "id=panel-alerts", "id=notify role=switch", "id=notify-test",
+            "id=notify-log", 'aria-label="Toggle browser budget alerts"',
+        ):
+            self.assertNotIn(marker, self.page)
+        self.assertNotIn("id=notify", rail)
+
+    def test_budget_alert_controls_share_the_set_budgets_header(self):
+        config = self.page[
+            self.page.index('id=budget-config'):
+            self.page.index('class="budgetFormGroup budgetRuntimeFields"')
+        ]
+        header = config[
+            config.index("class=budgetConfigHead"):
+            config.index("class=budgetFormGroup")
+        ]
+
+        self.assertIn("Set budgets</h2>", header)
+        self.assertIn("class=budgetAlertInline", header)
+        self.assertIn("class=budgetThresholds", header)
+        self.assertIn("id=budget-input-threshold-early", header)
+        self.assertIn("id=budget-input-threshold-mid", header)
+        self.assertIn("id=budget-input-threshold-full", header)
+        self.assertIn("class=budgetNotifySwitch", header)
+        self.assertIn("class=sw aria-hidden=true", header)
+        self.assertIn("id=budget-input-notifications", header)
+        self.assertNotIn("Default for sessions without a saved cap.", config)
+        self.assertNotIn("Browser delivery", config)
+
+    def test_monthly_budget_alerts_recover_missed_exceeded_state(self):
+        for marker in (
+            "function budgetExceededAlertState()",
+            "tm_monthly_budget_exceeded_alerts",
+            "previous=state[status.month]",
+            "Array.isArray(previous)?previous",
+            "over=Number((status.alert_percent??status.percent)||0)>=1",
+            "exceededState=budgetExceededAlertState()",
+            "monthExceeded.inApp===true",
+            "monthExceeded.browser===true",
+            "deliverMissedBrowserAlert",
+            "notifyOn&&canNotify&&Notification.permission==='granted'",
+            "Token Meter budget exceeded",
+            "requireInteraction:isExceeded",
+            "pushAppNotice(title,body",
+            "state[status.month]=[...new Set([...seen,...crossed])]",
+            "inApp:inAppNotified||alertExceeded",
+            "browser:browserNotified||deliverMissedBrowserAlert",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn(
+            "status.settings?.native_notifications===false",
+            self.page,
+        )
+        self.assertNotIn(
+            "if(!Array.isArray(seen)){state[status.month]=crossed",
+            self.page,
+        )
+
+    def test_current_summary_keeps_session_budget_slider(self):
+        summary = self.page[
+            self.page.index("id=panel-summary"):
+            self.page.index("<div class=foot>")
+        ]
+        for marker in (
+            "id=session-budget-control", "id=budget-slider type=range",
+            "id=budget type=number", "id=session-budget-spend",
+            "function syncSessionBudgetControls", "function persistSessionBudget",
+            "function queueSessionBudget", "const sessionBudgetWrites=new Map()",
+            "'/settings/session-budget'", "s?.session_budget?.budget_usd",
+            "$('budget-slider').addEventListener('input'",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("id=budget-slider type=range", summary)
+        self.assertIn("id=budget type=number", summary)
+        self.assertNotIn("id=panel-alerts", self.page)
+        self.assertNotIn("Only budget crossings create alerts.", self.page)
+        self.assertNotIn(
+            "Set a live-run cap without changing the machine-wide monthly budget.",
+            summary,
+        )
+
+    def test_settings_default_session_budget_preserves_saved_session_caps(self):
+        for marker in (
+            "id=budget-input-session-default",
+            "Default session budget",
+            "function sessionBudgetForSession(s)",
+            "defaultSessionBudget=Number(settings.default_session_budget||10)",
+            "s?.session_budget?.budget_usd",
+            "legacySessionBudgets",
+            "default_session_budget:budgetNumber('budget-input-session-default')",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_session_budget_writes_are_serialized_and_migration_is_superseded(self):
+        budget = self.page[
+            self.page.index("const SESSION_BUDGET_SLIDER_MIN"):
+            self.page.index("function dollarInputValue")
+        ]
+        self.assertIn("while(entry.pending)", budget)
+        self.assertIn("if(entry.saving)return entry.promise", budget)
+        self.assertIn("queueSessionBudget(CURRENT,n)", budget)
+        self.assertIn(
+            "syncSessionBudgetControls(sessionBudgetForSession(s),s)", budget,
+        )
+
+    def test_git_spend_headers_explain_covered_spend(self):
+        tip = "Covered spend: estimated spend from sessions with cost evidence in these projects."
+        for attr in ("data-delivery-model-sort=covered_cost", "data-delivery-sort=covered_cost"):
+            self.assertIn(f'{attr} data-tip="{tip}" aria-description="{tip}">Spend<', self.page)
+
+    def test_spend_route_and_shell_replace_daily_brief(self):
+        for marker in (
+            "data-label=Spend aria-label=Spend",
+            "<span class=tabLabel>Spend</span>",
+            "<h1>Spend</h1>",
+            "id=s-range", "<option value=today>Today</option>", "<option value=7>7 days</option>",
+            "<option value=month>Month</option>", "<option value=custom>Custom</option>",
+            "id=s-from", "id=s-to", "id=s-total", "id=s-average",
+            "id=s-top-runtime", "id=s-highest-day", "id=s-chart",
+            "id=s-chart-tip", "id=s-legend", "id=s-platforms",
+            "if(h==='daily')setHashRoute('spend',{replace:true,apply:false})",
+            "if(h==='spend'||h==='daily'||h==='spend-budgets'",
+            "openTopLevelRoute('spend')",
+            "{id:'spend',label:'Spend'",
+            "{label:'Open Spend',route:'spend-budgets'}",
+            "function renderSpend(xs)",
+        ):
+            self.assertIn(marker, self.page)
+        for removed in (
+            "<h1>Daily brief</h1>", "id=d-day-select", "id=d-trend-mode",
+            "data-daily-trend=wait", "id=d-sessions", "id=d-providers",
+            "renderDaily(",
+        ):
+            self.assertNotIn(removed, self.page)
+
+    def test_spend_fits_chart_and_restores_range_logs(self):
+        for marker in (
+            "class=spendEvidenceGrid",
+            "Highest-cost logs",
+            "id=s-log-day",
+            "id=s-log-count",
+            "id=s-logs",
+            "function spendAxisLabel(",
+            "function renderSpendLogs(payload,window)",
+            "function loadSpendLogs(window,generatedAt)",
+            "fetch(`/spend/logs?from=${encodeURIComponent(window.start)}&to=${encodeURIComponent(window.end)}`",
+            "data-spend-session=",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn(
+            ".spendChart{min-height:270px;margin-top:12px;overflow:hidden",
+            self.page,
+        )
+
+    def test_spend_evidence_cards_share_one_fixed_height(self):
+        """Removing either card from the shared height contract breaks alignment."""
+        for marker in (
+            ".spendEvidenceGrid{display:grid;grid-template-columns:minmax(0,1.3fr) minmax(300px,.7fr);align-items:stretch",
+            ".spendLogsCard,.spendPlatformCard{height:360px;display:flex;min-height:0;flex-direction:column",
+            "class=spendPlatformBody id=s-platforms",
+            ".spendPlatformBody{min-height:0;flex:1;overflow-y:auto;overflow-x:hidden;scrollbar-gutter:stable",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_spend_platform_split_keeps_amounts_inside_narrow_cards(self):
+        """Restoring the old wide column minimums clips amounts at laptop width."""
+        self.assertIn(
+            ".spendPlatformRow{display:grid;grid-template-columns:minmax(78px,.48fr) minmax(72px,1fr) minmax(82px,auto);align-items:center;gap:10px",
+            self.page,
+        )
+        self.assertIn(".spendPlatformValue{min-width:82px", self.page)
+
+    def test_spend_hover_detail_is_transient_and_bars_stay_mounted(self):
+        for marker in (
+            "class=\"spendChartTip chartTip\"",
+            ":where(.chartTip){position:absolute;pointer-events:none",
+            ".spendDay:hover .spendBarValue{opacity:1}",
+            "function hideSpendTip()",
+            "$('s-chart-inner').addEventListener('pointerleave',hideSpendTip)",
+            "if(!same){",
+            "updateSpendBar(button,rows[index],index,rows.length,axisMax,chartWidth,{peak:index===peakIndex,spansYears})",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn(
+            ".spendDay:hover .spendBarValue,.spendDay:focus-visible .spendBarValue,.spendDay.selected .spendBarValue",
+            self.page,
+        )
+        select_day = self.page.split("function selectSpendDay(day", 1)[1].split(
+            "function renderSpend(xs)", 1,
+        )[0]
+        self.assertNotIn("showSpendTip", select_day)
+        render_spend = self.page.split("function renderSpend(xs)", 1)[1].split(
+            "function validateSpendCustomDraft", 1,
+        )[0]
+        self.assertIn(
+            "const hovered=$('s-chart-inner').querySelector('.spendDay:hover');",
+            render_spend,
+        )
+        self.assertIn(
+            "if(hovered)showSpendTip(hovered.dataset.spendDay,hovered);else hideSpendTip();",
+            render_spend,
+        )
+
+    def test_spend_chart_uses_roving_focus_without_persistent_day_selection(self):
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1
+        )[0]
+        script = logic + """
+const rows = [{day:'2026-08-10'}, {day:'2026-08-11'}, {day:'2026-08-12'}];
+console.log(JSON.stringify({
+  initial: spendDayNavigation(rows, ''),
+  moved: spendDayNavigation(rows, '2026-08-11'),
+  empty: spendDayNavigation([], ''),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "initial": {
+                "focusDay": "2026-08-12",
+                "buttons": [
+                    {"day": "2026-08-10", "tabIndex": -1, "selected": False},
+                    {"day": "2026-08-11", "tabIndex": -1, "selected": False},
+                    {"day": "2026-08-12", "tabIndex": 0, "selected": False},
+                ],
+            },
+            "moved": {
+                "focusDay": "2026-08-11",
+                "buttons": [
+                    {"day": "2026-08-10", "tabIndex": -1, "selected": False},
+                    {"day": "2026-08-11", "tabIndex": 0, "selected": False},
+                    {"day": "2026-08-12", "tabIndex": -1, "selected": False},
+                ],
+            },
+            "empty": {"focusDay": "", "buttons": []},
+        })
+
+    def test_spend_y_axis_and_range_logs_are_bounded(self):
+        for marker in (
+            "id=s-y-axis",
+            "function spendNiceMax(value)",
+            "function renderSpendAxis(axisMax)",
+            ".spendLogsCard,.spendPlatformCard{height:360px",
+            "overflow-y:auto",
+            "scrollbar-gutter:stable",
+            ".spendLogRow{height:68px",
+            ".spendLogValue{grid-column:2/4;grid-row:2",
+            ".spendLogRow .tbtn{grid-column:3;grid-row:1",
+            "$('s-log-count').textContent=`${f(rows.length)} logs`",
+        ):
+            self.assertIn(marker, self.page)
+        render_logs = self.page.split("function renderSpendLogs(payload,window)", 1)[1].split(
+            "function loadSpendLogs", 1,
+        )[0]
+        self.assertNotIn(".slice(", render_logs)
+
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1,
+        )[0]
+        result = subprocess.run(
+            [
+                "node", "-e",
+                logic + "\nconsole.log(JSON.stringify([0,.7,18,189,200.00222974000008,458.253518,1000].map(spendNiceMax)));",
+            ],
+            capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), [1, 1, 20, 200, 240, 500, 1200])
+        self.assertIn("flex:1 1 0;min-width:0", self.page)
+        self.assertIn(
+            ".spendDayLabel{position:absolute;bottom:0;left:50%;width:max-content",
+            self.page,
+        )
+        self.assertIn(
+            ".spendDay[data-axis-edge=last] .spendDayLabel{right:0;left:auto;transform:none}",
+            self.page,
+        )
+        self.assertNotIn("inner.style.width=`max(100%", self.page)
+        self.assertNotIn(
+            ".spendChart{min-height:270px;margin-top:12px;overflow-x:auto",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_spend_last_month_is_previous_full_calendar_month(self):
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1,
+        )[0]
+        script = logic + """
+console.log(JSON.stringify([
+  spendRangeWindow('last_month','','',new Date(2026,2,15,9,0,0)),
+  spendRangeWindow('last_month','','',new Date(2026,0,1,0,5,0)),
+  normalizeSpendRangeChoice('last_month'),
+]));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), [
+            {"valid": True, "start": "2026-02-01", "end": "2026-02-28", "dayCount": 28, "error": ""},
+            {"valid": True, "start": "2025-12-01", "end": "2025-12-31", "dayCount": 31, "error": ""},
+            "last_month",
+        ])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_spend_trend_groups_by_monday_week_and_calendar_month(self):
+        """Clipped edge buckets and the bucket holding today must not count as full periods."""
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1,
+        )[0]
+        script = logic + """
+const now = new Date(2026, 9, 16, 12, 0, 0);
+const window = spendRangeWindow('custom', '2026-09-24', '2026-10-16', now);
+const rows = spendCalendarRows([
+  {day:'2026-09-24', cost:2, providers:[{provider:'claude', cost:2}]},
+  {day:'2026-09-30', cost:3, providers:[{provider:'codex', cost:3}], usage_basis:'local_estimate'},
+  {day:'2026-10-05', cost:5, providers:[{provider:'claude', cost:5}], coverage:{cost:{complete:false}}},
+  {day:'2026-10-16', cost:1, providers:[{provider:'claude', cost:1}]},
+], window);
+const pick = bucket => ({day:bucket.day, start:bucket.bucketStart, end:bucket.end, days:bucket.days, fullDays:bucket.fullDays, cost:bucket.cost, clipped:bucket.clipped, inProgress:bucket.inProgress, estimated:spendIsEstimated(bucket), complete:bucket.coverage.cost.complete});
+const weeks = spendBucketRows(rows, 'week', '2026-10-16');
+const days = spendBucketRows(rows, 'day', '2026-10-16');
+console.log(JSON.stringify({
+  weeks: weeks.map(pick),
+  months: spendBucketRows(rows, 'month', '2026-10-16').map(pick),
+  dayCount: days.length,
+  todayIncomplete: days.filter(row => row.incomplete).map(row => row.day),
+  weekAverageBasis: spendAverageBasis(weeks).map(row => row.day),
+  dayAverageBasis: spendAverageBasis(days).length,
+  sevenDays: spendGranularityOptions(spendCalendarRows([], spendRangeWindow('7', '', '', now))),
+  thirtyDays: spendGranularityOptions(spendCalendarRows([], spendRangeWindow('30', '', '', now))),
+  ninetyDays: spendGranularityOptions(spendCalendarRows([], spendRangeWindow('90', '', '', now))),
+  normalized: ['day', 'week', 'month', 'year', null].map(normalizeSpendGranularity),
+  auto: [1, 7, 30, 35, 36, 90, 186, 187, 400].map(spendAutoGranularity),
+  resolved: [
+    spendResolveGranularity('auto', spendCalendarRows([], spendRangeWindow('90', '', '', now))).granularity,
+    spendResolveGranularity('day', spendCalendarRows([], spendRangeWindow('90', '', '', now))).granularity,
+    spendResolveGranularity('month', spendCalendarRows([], spendRangeWindow('30', '', '', now))).granularity,
+    spendResolveGranularity('week', spendCalendarRows([], spendRangeWindow('7', '', '', now))).granularity,
+    spendResolveGranularity('auto', spendCalendarRows([], spendRangeWindow('30', '', '', now))).granularity,
+  ],
+}));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["weeks"], [
+            {"day": "2026-09-24", "start": "2026-09-21", "end": "2026-09-27", "days": 4, "fullDays": 7, "cost": 2, "clipped": True, "inProgress": False, "estimated": False, "complete": True},
+            {"day": "2026-09-28", "start": "2026-09-28", "end": "2026-10-04", "days": 7, "fullDays": 7, "cost": 3, "clipped": False, "inProgress": False, "estimated": True, "complete": True},
+            {"day": "2026-10-05", "start": "2026-10-05", "end": "2026-10-11", "days": 7, "fullDays": 7, "cost": 5, "clipped": False, "inProgress": False, "estimated": False, "complete": False},
+            {"day": "2026-10-12", "start": "2026-10-12", "end": "2026-10-16", "days": 5, "fullDays": 7, "cost": 1, "clipped": True, "inProgress": True, "estimated": False, "complete": True},
+        ])
+        self.assertEqual(payload["months"], [
+            {"day": "2026-09-24", "start": "2026-09-01", "end": "2026-09-30", "days": 7, "fullDays": 30, "cost": 5, "clipped": True, "inProgress": False, "estimated": True, "complete": True},
+            {"day": "2026-10-01", "start": "2026-10-01", "end": "2026-10-16", "days": 16, "fullDays": 31, "cost": 6, "clipped": True, "inProgress": True, "estimated": False, "complete": False},
+        ])
+        self.assertEqual(payload["dayCount"], 23)
+        self.assertEqual(payload["todayIncomplete"], ["2026-10-16"])
+        self.assertEqual(payload["weekAverageBasis"], ["2026-09-28", "2026-10-05"])
+        self.assertEqual(payload["dayAverageBasis"], 23)
+        self.assertEqual(payload["sevenDays"], {"day": True, "week": False, "month": False})
+        self.assertEqual(payload["thirtyDays"], {"day": True, "week": True, "month": False})
+        self.assertEqual(payload["ninetyDays"], {"day": True, "week": True, "month": True})
+        self.assertEqual(payload["normalized"], ["day", "week", "month", "day", "day"])
+        self.assertEqual(payload["auto"], ["day", "day", "day", "day", "week", "week", "week", "month", "month"])
+        self.assertEqual(payload["resolved"], ["week", "day", "week", "day", "day"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_spend_trend_options_ticks_and_in_progress_week(self):
+        """A week still in progress is no basis for an average, so it cannot make Week selectable."""
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1,
+        )[0]
+        script = logic + """
+const now = new Date(2026, 9, 11, 12, 0, 0);
+const rows = spendCalendarRows([], spendRangeWindow('custom', '2026-09-30', '2026-10-11', now));
+const yearRows = spendCalendarRows([], spendRangeWindow('custom', '2025-12-29', '2026-01-11', new Date(2026, 0, 11, 12)));
+console.log(JSON.stringify({
+  withToday: spendGranularityOptions(rows, '2026-10-11'),
+  withoutToday: spendGranularityOptions(rows),
+  fellBack: spendResolveGranularity('week', rows, '2026-10-11').granularity,
+  year: spendBucketRows(yearRows, 'month').map(row => [row.bucketStart, row.days, row.fullDays]),
+  yearWeeks: spendBucketRows(yearRows, 'week').map(row => row.bucketStart),
+  ticks: [3.95, 5, 40, 95, 3000].map(spendNiceMax),
+}));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["withToday"], {"day": True, "week": False, "month": False})
+        self.assertEqual(payload["withoutToday"], {"day": True, "week": True, "month": False})
+        self.assertEqual(payload["fellBack"], "day")
+        self.assertEqual(payload["year"], [["2025-12-01", 3, 31], ["2026-01-01", 11, 31]])
+        self.assertEqual(payload["yearWeeks"], ["2025-12-29", "2026-01-05"])
+        self.assertEqual(payload["ticks"], [6, 6, 50, 100, 3200])
+
+    def test_spend_trend_override_resets_whenever_the_range_changes(self):
+        """A manual Day on 30 days must not follow the user onto All history."""
+        for handler in (
+            "spendCustomFrom=from;spendCustomTo=to;spendRangeChoice='custom';spendGranularityChoice='auto';",
+            "spendRangeChoice=range;spendGranularityChoice='auto';persistSpendRange()",
+            "if(savedCustomInvalid){spendRangeChoice='30';spendGranularityChoice='auto';",
+            "spendRangeChoice='month';spendGranularityChoice='auto';persistSpendRange()",
+        ):
+            self.assertIn(handler, self.page)
+        self.assertIn("aria-disabled", self.page.split("function renderSpend(xs)", 1)[1])
+        self.assertNotIn("button.disabled=!granularityOptions", self.page)
+
+    def test_spend_trend_granularity_control_drives_chart(self):
+        for marker in (
+            '<div class=seg id=s-granularity role=group aria-label="Group spend by">',
+            "data-spend-granularity=day>Day</button>",
+            "data-spend-granularity=week>Week</button>",
+            "data-spend-granularity=month>Month</button>",
+            "let spendGranularityChoice='auto',spendChartRows=[];",
+            "spendChartRows=spendBucketRows(rows,granularity,today);",
+            "reconcileSpendBars(spendChartRows);",
+            "<div class=spendGrid aria-hidden=true></div>",
+            "button.setAttribute('aria-disabled',String(!granularityOptions[value]));",
+        ):
+            self.assertIn(marker, self.page)
+        render_spend = self.page.split("function renderSpend(xs)", 1)[1].split(
+            "function validateSpendCustomDraft", 1,
+        )[0]
+        self.assertIn("spendResolveGranularity(spendGranularityChoice,rows,today)", render_spend)
+        self.assertNotIn("SPEND_GRANULARITY_KEY", self.page)
+        self.assertIn(".spendChartInner[data-granularity] .spendStackSegment{opacity:.82", self.page)
+        self.assertIn(".spendChartInner[data-granularity] .spendStackSegment+.spendStackSegment{border-bottom:1px solid", self.page)
+        self.assertIn("<span class=spendDayStack style=\"--spend-height:${height}%\">${segments}</span>", self.page)
+        self.assertNotIn("spendTotalKey", self.page)
+        grid_rule = self.page.split("\n.spendGrid{", 1)[1].split("}", 1)[0]
+        self.assertIn("height:calc(var(--spend-chart-h) - var(--spend-day-head) - var(--spend-day-foot) - 2*var(--spend-day-gap))", grid_rule)
+        self.assertNotIn("inset:", grid_rule)
+        self.assertIn("--spend-chart-h:260px", self.page)
+        self.assertEqual(self.page.count("height:var(--spend-chart-h)"), 2)
+        self.assertIn("(index%step===0&&count-1-index>=step)", self.page)
+        self.assertIn("[data-peak=true][data-peak-edge=first] .spendBarValue{align-self:flex-start}", self.page)
+        show_tip = self.page.split("function showSpendTip(", 1)[1].split("function selectSpendDay", 1)[0]
+        self.assertIn("details.runtimes.filter(runtime=>runtime.cost>0||runtime.unavailable)", show_tip)
+        self.assertIn("Math.min(cardRect.height-tip.offsetHeight-8", show_tip)
+        day_rule = self.page.split("\n.spendDay{", 1)[1].split("}", 1)[0]
+        self.assertIn("grid-template-columns:minmax(0,1fr)", day_rule)
+        self.assertIn(".spendChartInner[data-dense=true]{--spend-bar-share:52%}", self.page)
+        self.assertIn("inner.dataset.dense=String(rows.length>45);", self.page)
+        stack_rule = self.page.split(".spendDayStack{", 1)[1].split("}", 1)[0]
+        self.assertNotIn("border-radius", stack_rule)
+        self.assertIn("width:min(var(--spend-bar-max,24px),var(--spend-bar-share,64%))", stack_rule)
+        self.assertNotIn("transparent 0 44px", self.page.split("\n.spendDayTrack{", 1)[1].split("}", 1)[0])
+
+    def test_spend_average_reference_uses_every_calendar_day(self):
+        """Dropping zero-spend days makes the chart line disagree with the KPI."""
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1,
+        )[0]
+        script = logic + """
+const rows = [
+  {day:'2026-08-01', cost:1},
+  {day:'2026-08-02', cost:2},
+  {day:'2026-08-03', cost:0},
+  {day:'2026-08-04', cost:1},
+];
+console.log(JSON.stringify({
+  reference: spendAverageReference(rows, 4),
+  empty: spendAverageReference([], 4),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), {
+            "reference": {"value": 1, "ratio": 0.25},
+            "empty": {"value": 0, "ratio": 0},
+        })
+
+    def test_spend_uses_exact_calendar_ranges_and_stacked_runtime_bars(self):
+        for marker in (
+            "// spend-range-logic-start",
+            "const SPEND_RUNTIME_COLORS={claude:'var(--provider-claude)',codex:'var(--provider-codex)',cursor:'var(--provider-cursor)',opencode:'var(--provider-opencode)',kiro:'var(--provider-kiro)',unknown:'var(--provider-other)'};",
+            "function spendRangeWindow(range,from='',to='',now=new Date(),earliest='')",
+            "<select class=filterSelect id=s-range aria-label=\"Spend history range\"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option><option value=custom>Custom</option></select>",
+            "$('s-range').value=spendRangeChoice;",
+            "$('s-range').onchange=event=>{",
+            "function normalizeSpendRangeChoice(value)",
+            "function spendCalendarRows(days,window)",
+            "function spendRuntimeKey(provider)",
+            "function spendRuntimeTotals(rows)",
+            "class=spendStackSegment",
+            "data-spend-day=",
+            "function spendDayNavigation(rows,focusDay='')",
+            "function showSpendTip(",
+            "addEventListener('pointerover',handleSpendInspect)",
+            "xs?.spend?.days||xs?.daily||[]",
+        ):
+            self.assertIn(marker, self.page)
+
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1
+        )[0]
+        script = logic + """
+const now = new Date(2026, 7, 12, 12, 0, 0);
+const today = spendRangeWindow('today', '', '', now);
+const seven = spendRangeWindow('7', '', '', now);
+const thirty = spendRangeWindow('30', '', '', now);
+const month = spendRangeWindow('month', '', '', now);
+const monthFirst = spendRangeWindow('month', '', '', new Date(2026, 8, 1, 12, 0, 0));
+const january = spendRangeWindow('month', '', '', new Date(2027, 0, 9, 12, 0, 0));
+const custom = spendRangeWindow('custom', '2026-08-01', '2026-08-03', now);
+const yesterday = spendRangeWindow('yesterday', '', '', now);
+const ninety = spendRangeWindow('90', '', '', now);
+const allHistory = spendRangeWindow('all', '', '', now, '2026-05-01');
+const allEmpty = spendRangeWindow('all', '', '', now, '');
+const invalid = spendRangeWindow('custom', '2026-08-04', '2026-08-03', now);
+const rows = spendCalendarRows([
+  {day:'2026-08-03',cost:3,providers:[{provider:'claude',cost:3}]},
+  {day:'2026-08-01',cost:2,providers:[{provider:'codex',cost:2}]},
+], custom);
+console.log(JSON.stringify({
+  today, seven, thirty, month, monthFirst, january, custom, invalid, yesterday, ninety, allHistory, allEmpty,
+  savedRanges: ['today','yesterday','7','30','90','month','last_month','all','custom','unexpected'].map(normalizeSpendRangeChoice),
+  rowDays: rows.map(row=>row.day),
+  rowCosts: rows.map(row=>row.cost),
+  keys: ['Claude Code','codex','Cursor IDE','OpenCode','Kiro CLI','other'].map(spendRuntimeKey),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["today"]["start"], "2026-08-12")
+        self.assertEqual(payload["today"]["end"], "2026-08-12")
+        self.assertEqual(payload["seven"]["start"], "2026-08-06")
+        self.assertEqual(payload["seven"]["end"], "2026-08-12")
+        self.assertEqual(payload["seven"]["dayCount"], 7)
+        self.assertEqual(payload["thirty"]["start"], "2026-07-14")
+        self.assertEqual(payload["thirty"]["dayCount"], 30)
+        self.assertEqual(payload["month"], {
+            "valid": True, "start": "2026-08-01", "end": "2026-08-12",
+            "dayCount": 12, "error": "",
+        })
+        self.assertEqual(payload["monthFirst"], {
+            "valid": True, "start": "2026-09-01", "end": "2026-09-01",
+            "dayCount": 1, "error": "",
+        })
+        self.assertEqual(payload["january"], {
+            "valid": True, "start": "2027-01-01", "end": "2027-01-09",
+            "dayCount": 9, "error": "",
+        })
+        self.assertEqual(
+            payload["savedRanges"],
+            ["today", "yesterday", "7", "30", "90", "month", "last_month", "all", "custom", "30"],
+        )
+        self.assertEqual(payload["yesterday"], {
+            "valid": True, "start": "2026-08-11", "end": "2026-08-11",
+            "dayCount": 1, "error": "",
+        })
+        self.assertEqual(payload["ninety"]["start"], "2026-05-15")
+        self.assertEqual(payload["ninety"]["dayCount"], 90)
+        self.assertEqual(payload["allHistory"], {
+            "valid": True, "start": "2026-05-01", "end": "2026-08-12",
+            "dayCount": 104, "error": "",
+        })
+        self.assertEqual(payload["allEmpty"]["start"], "2026-08-12")
+        self.assertEqual(payload["allEmpty"]["dayCount"], 1)
+        self.assertEqual(payload["custom"]["dayCount"], 3)
+        self.assertFalse(payload["invalid"]["valid"])
+        self.assertEqual(payload["rowDays"], [
+            "2026-08-01", "2026-08-02", "2026-08-03",
+        ])
+        self.assertEqual(payload["rowCosts"], [2, 0, 3])
+        self.assertEqual(payload["keys"], [
+            "claude", "codex", "cursor", "opencode", "kiro", "unknown",
+        ])
+
+    def test_spend_session_analytics_excludes_unavailable_evidence(self):
+        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
+            "// spend-range-logic-end", 1
+        )[0]
+        script = logic + """
+const rows = [
+  {id:'a', cost:40, input_tokens:1000, turns:1, duration_s:10,
+   duration_available:true, availability:{cost:true,input_tokens:true}},
+  {id:'b', cost:30, input_tokens:2000, turns:2, duration_s:20,
+   duration_available:true, availability:{cost:true,input_tokens:true}},
+  {id:'c', cost:20, input_tokens:3000, turns:3, duration_s:30,
+   duration_available:true, availability:{cost:true,input_tokens:true}},
+  {id:'d', cost:10, input_tokens:4000, turns:4, duration_s:999,
+   duration_available:false, availability:{cost:true,input_tokens:true}},
+  {id:'e', cost:99, input_tokens:5000, turns:5, duration_s:50,
+   duration_available:true, availability:{cost:false,input_tokens:true}},
+];
+const analytics = spendSessionAnalytics(rows);
+console.log(JSON.stringify({
+  concentration: analytics.concentration,
+  cost: analytics.distributions.cost,
+  input: analytics.distributions.input,
+  executions: analytics.distributions.executions,
+  active: analytics.distributions.active,
+  spendPoints: spendScatterRows(rows, 'cost').map(row => row.id),
+  inputPoints: spendScatterRows(rows, 'input').map(row => row.id),
+}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["concentration"], {
+            "covered": 4, "total": 100, "top_count": 1,
+            "top_cost": 40, "top_share": 0.4,
+        })
+        self.assertEqual(payload["cost"], {
+            "count": 4, "p10": 13, "p25": 17.5, "median": 25,
+            "mean": 25, "p75": 32.5, "p90": 37,
+        })
+        self.assertEqual(payload["input"], {
+            "count": 5, "p10": 1400, "p25": 2000, "median": 3000,
+            "mean": 3000, "p75": 4000, "p90": 4600,
+        })
+        self.assertEqual(payload["executions"], {
+            "count": 5, "p10": 1.4, "p25": 2, "median": 3,
+            "mean": 3, "p75": 4, "p90": 4.6,
+        })
+        self.assertEqual(payload["active"], {
+            "count": 4, "p10": 13, "p25": 17.5, "median": 25,
+            "mean": 27.5, "p75": 35, "p90": 44,
+        })
+        self.assertEqual(payload["spendPoints"], ["a", "b", "c"])
+        self.assertEqual(payload["inputPoints"], ["a", "b", "c", "e"])
+
+    def test_spend_route_exposes_concentration_shape_and_openable_outliers(self):
+        spend = self.page.split("id=view-daily", 1)[1].split("id=view-learn", 1)[0]
+        for marker in (
+            "id=s-concentration", "id=s-concentration-bar", "id=s-shape",
+            "id=s-scatter", "id=s-scatter-svg", "data-scatter-metric=cost",
+            "data-scatter-metric=input", "data-spend-insight-session=",
+        ):
+            self.assertIn(marker, spend if marker.startswith("id=s-") or marker.startswith("data-scatter") else self.page)
+        self.assertIn("function renderSpendSessionInsights(payload,window)", self.page)
+        self.assertIn("selectSession(button.dataset.spendInsightSession)", self.page)
+
+    def test_spend_monthly_budget_derives_total_from_runtime_budgets(self):
+        for marker in (
+            "id=spend-budgets", "class=spendBudgetSection", "class=spendBudgetEditor",
+            "id=budget-spend", "id=budget-total", "id=budget-remaining",
+            "id=budget-projected", "id=budget-runtimes",
+            "id=budget-progress-markers", "id=budget-allocation-note",
+            "id=budget-plan-jump",
+            "class=budgetDashboard", "class=budgetLeadHeadActions",
+            "class=\"card budgetLead\"",
+            "class=\"card pad budgetRuntimeCard budgetConfig\"",
+            "class=budgetLeadBody",
+            "class=budgetLeadTop", "class=budgetFigureLine",
+            "id=budget-spend-qualifier hidden>At least</span>",
+            "class=budgetStats", "class=budgetMeterFoot", "id=budget-month",
+            "$('budget-spend-qualifier').hidden=!status.lower_bound",
+            "$('budget-spend').textContent=wholeMoney(status.spend||0)",
+            "const wholeMoney=n=>",
+            "function budgetMonthLabel(month)",
+            "class=budgetRuntimeValue",
+            "class=budgetRuntimeTrack",
+            "class=budgetFormGroup", "class=budgetAlertInline",
+            "class=\"budgetForm budgetInlineForm\"",
+            "class=budgetRuntimeHead", "class=budgetRuntimeInput",
+            "id=budget-input-claude", "id=budget-input-codex",
+            "id=budget-input-cursor", "id=budget-input-opencode",
+            "id=budget-input-threshold-early",
+            "id=budget-runtime-spend-claude",
+            "id=budget-runtime-spend-codex",
+            "id=budget-runtime-spend-cursor",
+            "id=budget-runtime-spend-opencode",
+            "id=budget-runtime-track-claude",
+            "id=budget-runtime-track-opencode",
+            "/settings/budgets", "tm_monthly_budget_alerts",
+            "Partial cost coverage: recorded spend is a lower bound.",
+            "The sum of the registered runtime budgets.",
+            "Runtime budgets are added to calculate the monthly total.",
+            "function ensureBudgetRuntimeRows()",
+            "planJump.textContent=open?'Close editor':budgetConfigured?'Edit budgets':'Set budgets'",
+            "planJump.setAttribute('aria-expanded',String(open))",
+            "aria-expanded=false aria-controls=budget-config>Set budgets</button>",
+            "$('budget-plan-jump').onclick=()=>setBudgetEditorOpen($('budget-config').hidden,true)",
+            "config.scrollIntoView({behavior:",
+            "const input=config.querySelector('.budgetRuntimeInput input')",
+            "input.focus({preventScroll:true})",
+            ".budgetConfig[hidden]{display:none}",
+            ".spendBudgetSection .budgetRuntimeFields{grid-column:2;grid-row:2}",
+            "function budgetAllocationsFromInputs()",
+            "function previewCalculatedBudget()",
+            "const payload={currency:'USD',default_session_budget:",
+            "per session by default · ${money(total)} per month.",
+            "Save budgets",
+            "Set budgets</h2>",
+            "Spent this month</span><span>Budget (USD)",
+            "DEFAULT_RUNTIME_BUDGET=0",
+            "value=0",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertNotIn("class=budgetHero", self.page)
+        self.assertNotIn("class=budgetGrid", self.page)
+        self.assertNotIn("budgetConfigInitialized", self.page)
+        self.assertNotIn("<details class=\"card budgetConfig\"", self.page)
+        self.assertNotIn("<h2>Budget plan</h2>", self.page)
+        self.assertNotIn("<span class=budgetRuntimeName>Unallocated</span>", self.page)
+        self.assertNotIn("$('budget-runtimes').innerHTML", self.page)
+        self.assertNotIn("id=tab-budgets", self.page)
+        self.assertNotIn("id=view-budgets", self.page)
+        self.assertNotIn("no runtime allocation", self.page)
+        self.assertNotIn("id=budget-input-total", self.page)
+        self.assertNotIn("Monthly total (USD)", self.page)
+        self.assertNotIn("Runtime allocations cannot exceed", self.page)
+        self.assertNotIn("budget-runtime-meta-", self.page)
+        self.assertNotIn("const meta=allocated?", self.page)
+        self.assertEqual(self.page.count(" id=budget-config hidden>"), 1)
+        for removed in ("class=budgetSpendSummary", "class=budgetSpendLimit", "class=budgetReadouts>"):
+            self.assertNotIn(removed, self.page)
+        for removed in (
+            "id=budget-bars", "id=budget-history-note", ">Monthly spend</h2>",
+            "class=budgetDetailGrid", "budgetHistory", "budgetChartInner",
+            "data-settings-target=budget-settings",
+        ):
+            self.assertNotIn(removed, self.page)
+        self.assertNotRegex(self.page, r"id=budget-settings[\s>]")
+        spend = self.page.split("id=view-daily", 1)[1].split("id=view-efficiency", 1)[0]
+        self.assertLess(spend.index("<h1>Spend</h1>"), spend.index("id=spend-budgets"))
+        self.assertLess(spend.index("id=spend-budgets"), spend.index("class=spendKpis"))
+        self.assertLess(spend.index("class=\"card budgetLead\""), spend.index("id=budget-config"))
+        settings = self.page.split("id=view-settings", 1)[1]
+        self.assertNotIn("id=budget-form", settings)
+
+    def test_current_surfaces_runtime_budget_overruns(self):
+        for marker in (
+            "id=current-budget-warning",
+            "id=current-budget-warning-msg",
+            "id=current-budget-settings",
+            "Open monthly budget",
+            "$('current-budget-settings').onclick=()=>setHashRoute('spend-budgets')",
+            "function renderCurrentBudgetWarning(status)",
+            "status?.exceeded_runtimes||[]",
+            "renderCurrentBudgetWarning(s.xsession?.budget||LATEST?.xsession?.budget)",
+            "runtimeAttention?`${runtimeExceeded.map(row=>row.label).join(', ')} over budget`",
+            "row.exceeded===true",
+        ):
+            self.assertIn(marker, self.page)
+
+    def test_spend_uses_session_routing_without_restoring_daily_wait_health(self):
+        self.assertNotIn("Tool-result health", self.page)
+        self.assertNotIn("Tool results need attention", self.page)
+        self.assertNotIn("function openDailySession", self.page)
+        self.assertNotIn("data-daily-session", self.page)
+        self.assertIn("function renderSpend(xs)", self.page)
+        self.assertIn("data-spend-session=", self.page)
+        self.assertIn("if(row)selectSession(row.dataset.id)", self.page)
+
+    def test_sessions_overview_shows_exact_day_spend_summary_and_tokenomics_link(self):
+        for marker in (
+            'class=currentDaySummary aria-label="Today\'s usage summary"',
+            "id=current-day-spend",
+            "id=current-day-sessions",
+            "id=current-day-vs-yesterday",
+            "Spend today",
+            "Sessions today",
+            "Vs yesterday",
+            "function renderCurrentDaySummary(xs)",
+            "if(!Array.isArray(xs?.daily))",
+            "const todayKey=localDayKey(),yesterdayDate=new Date()",
+            "days.find(row=>row.day===todayKey)",
+            "days.find(row=>row.day===yesterdayKey)",
+            'href="https://www.splunk.com/en_us/products/tokenomics.html"',
+            'target=_blank rel="noopener noreferrer"',
+            'aria-label="Get Enterprise Tokenomics from Splunk (opens in a new tab)"',
+            ">Get Enterprise Tokenomics<",
+            "id=current-month-spend",
+            ">View month spend<",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertLess(self.page.index("class=currentDaySummary"), self.page.index("id=current-session-grid"))
+        self.assertIn("renderCurrentDaySummary(state?.xsession);", self.page)
+        self.assertIn(".currentDayReadouts{display:grid;grid-template-columns:repeat(3,minmax(0,1fr))", self.page)
+        self.assertIn(".currentDayMetric:nth-child(3){grid-column:1/-1", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_sessions_month_spend_action_selects_and_persists_month_before_routing(self):
+        match = re.search(
+            r"^function persistSpendRange\(\)[^\n]*\n"
+            r"^function openMonthSpend\(\).*?^\}\n",
+            self.page,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(match, "dashboard needs a month-spend action")
+        script = """
+const SPEND_RANGE_KEY='tm_spend_range_v1';
+let spendRangeChoice='7',spendCustomFrom='2026-08-01',spendCustomTo='2026-08-03';
+const writes=[],routes=[];
+const localStorage={setItem(key,value){writes.push([key,JSON.parse(value)]);}};
+const setHashRoute=route=>routes.push(route);
+""" + match.group(0) + """
+openMonthSpend();
+console.log(JSON.stringify({spendRangeChoice,writes,routes}));
+"""
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        self.assertEqual(json.loads(result.stdout), {
+            "spendRangeChoice": "month",
+            "writes": [["tm_spend_range_v1", {
+                "range": "month",
+                "from": "2026-08-01",
+                "to": "2026-08-03",
+            }]],
+            "routes": ["spend"],
+        })
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_subagents.py b/tests/test_dashboard_subagents.py
new file mode 100644
index 00000000..d4fd9563
--- /dev/null
+++ b/tests/test_dashboard_subagents.py
@@ -0,0 +1,818 @@
+import unittest
+import http.client
+import json
+import shutil
+import subprocess
+import time
+from pathlib import Path
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardSubagentLayoutTests(DashboardLayoutCase):
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_explorer_prefers_roles_and_filters_status_and_signals(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('agentIdentityPresentation'));
+eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
+const usage={{inventory_count:3,inventory_truncated:false,inventory:[
+ {{id:'a',root_session_id:'root-a',project:'/token-meter',runtime:'codex',model:'gpt',role:'token_meter_reviewer',label:'Heisenberg',activity_state:'complete',last_activity_at:100,tokens:10,tokens_available:true,cost:1,cost_available:true,work_time_s:30,attention:[]}},
+ {{id:'b',root_session_id:'root-a',project:'/token-meter',runtime:'codex',model:'gpt',role:null,label:'Gauss',activity_state:'incomplete',last_activity_at:200,tokens:20,tokens_available:true,cost:4,cost_available:true,work_time_s:60,attention:[{{code:'peer_cost_outlier',explanation:'3x peers'}}]}},
+ {{id:'c',root_session_id:'root-c',project:'/luna-3',runtime:'claude',model:'opus',role:null,label:'',activity_state:'working',last_activity_at:300,tokens:null,tokens_available:false,cost:null,cost_available:false,work_time_s:null,attention:[]}},
+]}};
+const result=filterSubagentInventory(usage,{{query:'gauss',runtime:'codex',project:'/token-meter',model:'gpt',status:'incomplete',signal:'peer_cost_outlier',window:'all',sort:'cost'}},400);
+const workSorted=filterSubagentInventory(usage,{{query:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'work'}},400);
+process.stdout.write(JSON.stringify({{
+ role:agentIdentityPresentation(usage.inventory[0],0),
+ nickname:agentIdentityPresentation(usage.inventory[1],1),
+ fallback:agentIdentityPresentation(usage.inventory[2],2),
+ result,workSorted,
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+
+        self.assertEqual(payload["role"], {
+            "primary": "token_meter_reviewer", "secondary": "Heisenberg",
+        })
+        self.assertEqual(payload["nickname"], {
+            "primary": "Gauss", "secondary": "",
+        })
+        self.assertEqual(payload["fallback"], {
+            "primary": "Agent 3", "secondary": "",
+        })
+        self.assertEqual([row["id"] for row in payload["result"]["rows"]], ["b"])
+        self.assertEqual(payload["result"]["summary"]["incomplete"], 1)
+        self.assertEqual(payload["result"]["summary"]["attention"], 1)
+        self.assertEqual(payload["result"]["summary"]["parentSessions"], 1)
+        self.assertTrue(payload["result"]["summary"]["complete"])
+        self.assertEqual(
+            [row["id"] for row in payload["workSorted"]["rows"]],
+            ["b", "a", "c"],
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_last_month_time_filter_bounds_sessions_subagents_and_role_days(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'';
+eval(['timeFilterBounds','agentIdentityPresentation','filterSubagentInventory','childRootId','localDateKey','dateKeyAgo','calendarMonthWindow','monthToDateWindow','modelRangeWindow','subagentRoleKey','subagentRoleDayRows','subagentModelKey','subagentModelDayRows','normalizedSubagentNavigationState'].map(extract).join('\\n'));
+eval(page.slice(page.indexOf('function allSessionsView('),page.indexOf('function allSessionsCountText(')));
+const DEFAULT_TIME_FILTER_WINDOW='30d';
+const subagentFilterDefaults={{query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'}};
+const now=new Date(2026,9,5,12).getTime(),at=(...parts)=>new Date(...parts).getTime()/1000;
+const bounds=timeFilterBounds('last_month',now);
+const stamps={{current:at(2026,9,1,0,0,1),lastStart:at(2026,8,1),lastEnd:at(2026,8,30,23,59,59),prior:at(2026,7,31,23,59,59)}};
+const inventory=Object.entries(stamps).map(([id,last])=>({{id,root_session_id:'root',runtime:'codex',label:id,activity_state:'complete',last_activity_at:last,attention:[]}}));
+const agents=filterSubagentInventory({{inventory}},{{window:'last_month',status:'all',signal:'all',sort:'recent'}},now/1000).rows.map(row=>row.id).sort();
+const sessions=allSessionsView(Object.entries(stamps).map(([id,mtime])=>({{id,provider:'codex',title:id,cost:1,mtime}})),{{rangeStart:bounds.start,rangeEnd:bounds.end}}).rows.map(row=>row.id).sort();
+const roleRow=day=>({{day,runtime:'codex',kind:'spawned',role:'reviewer',project:''}});
+const roleDays=subagentRoleDayRows({{role_days:['2026-10-01','2026-09-30','2026-09-01','2026-08-31'].map(roleRow)}},{{window:'last_month'}},now).map(row=>row.day);
+const monthBounds=timeFilterBounds('month',now);
+const monthAgents=filterSubagentInventory({{inventory}},{{window:'month',status:'all',signal:'all',sort:'recent'}},now/1000).rows.map(row=>row.id).sort();
+const monthSessions=allSessionsView(Object.entries(stamps).map(([id,mtime])=>({{id,provider:'codex',title:id,cost:1,mtime}})),{{rangeStart:monthBounds.start,rangeEnd:monthBounds.end}}).rows.map(row=>row.id).sort();
+const monthRoleDays=subagentRoleDayRows({{role_days:['2026-10-06','2026-10-05','2026-10-01','2026-09-30'].map(roleRow)}},{{window:'month'}},now).map(row=>row.day);
+const modelRow=day=>({{day,runtime:'codex',model:'gpt-5',project:''}});
+const lastMonthModelDays=subagentModelDayRows({{model_days:['2026-10-01','2026-09-30','2026-09-01','2026-08-31'].map(modelRow)}},{{window:'last_month'}},now).map(row=>row.day);
+const monthModelDays=subagentModelDayRows({{model_days:['2026-10-05','2026-10-01','2026-09-30'].map(modelRow)}},{{window:'month'}},now).map(row=>row.day);
+process.stdout.write(JSON.stringify({{
+ agents,sessions,roleDays,monthAgents,monthSessions,monthRoleDays,lastMonthModelDays,monthModelDays,
+ monthRestored:normalizedSubagentNavigationState('roles',{{window:'month'}}).filters.window,
+ restored:normalizedSubagentNavigationState('roles',{{window:'last_month'}}).filters.window,
+ rolling:timeFilterBounds('7d',now).end,
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload["agents"], ["lastEnd", "lastStart"])
+        self.assertEqual(payload["sessions"], ["lastEnd", "lastStart"])
+        self.assertEqual(payload["roleDays"], ["2026-09-01", "2026-09-30"])
+        self.assertEqual(payload["restored"], "last_month")
+        self.assertEqual(payload["rolling"], 0)
+        self.assertEqual(self.page.count(
+            "<option value=today>Today</option><option value=yesterday>Yesterday</option>"
+            "<option value=7d>7 days</option><option value=30d selected>30 days</option>"
+            "<option value=90d>90 days</option><option value=month>Month</option>"
+            "<option value=last_month>Last month</option><option value=all>All history</option></select>"
+        ), 2)
+        self.assertNotIn("value=24h", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_calendar_time_filters_bound_sessions_subagents_and_role_days(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'';
+eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('const DELIVERY_EVIDENCE_FILTERS=')).replace(/^const /gm,'var '));
+eval(['agentIdentityPresentation','filterSubagentInventory','childRootId','localDateKey','dateKeyAgo','calendarMonthWindow','monthToDateWindow','modelRangeWindow','subagentRoleKey','subagentRoleDayRows','normalizedSubagentNavigationState'].map(extract).join('\\n'));
+eval(page.slice(page.indexOf('function allSessionsView('),page.indexOf('function allSessionsCountText(')));
+const subagentFilterDefaults={{query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'}};
+const now=new Date(2026,9,5,12).getTime(),at=(...parts)=>new Date(...parts).getTime()/1000;
+const stamps={{today:at(2026,9,5,0,0,1),yesterdayStart:at(2026,9,4),yesterdayEnd:at(2026,9,4,23,59,59),monthStart:at(2026,9,1),lastMonth:at(2026,8,30,23,59,59)}};
+const inventory=Object.entries(stamps).map(([id,last])=>({{id,root_session_id:'root',runtime:'codex',label:id,activity_state:'complete',last_activity_at:last,attention:[]}}));
+const result={{}};
+for(const window of ['today','yesterday','month']){{
+ const bounds=timeFilterBounds(window,now);
+ result[window]={{
+  agents:filterSubagentInventory({{inventory}},{{window,status:'all',signal:'all',sort:'recent'}},now/1000).rows.map(row=>row.id).sort(),
+  sessions:allSessionsView(Object.entries(stamps).map(([id,mtime])=>({{id,provider:'codex',title:id,cost:1,mtime}})),{{rangeStart:bounds.start,rangeEnd:bounds.end}}).rows.map(row=>row.id).sort(),
+  roleDays:subagentRoleDayRows({{role_days:['2026-10-05','2026-10-04','2026-10-01','2026-09-30'].map(day=>({{day,runtime:'codex',kind:'spawned',role:'reviewer',project:''}}))}},{{window}},now).map(row=>row.day),
+ }};
+}}
+process.stdout.write(JSON.stringify({{
+ result,
+ migrated:normalizeTimeFilterWindow('24h'),invalid:normalizeTimeFilterWindow('bogus'),
+ restored:normalizedSubagentNavigationState('roles',{{window:'24h'}}).filters.window,
+ restoredMonth:normalizedSubagentNavigationState('roles',{{window:'month'}}).filters.window,
+ labels:TIME_FILTER_LABELS,
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        result = payload["result"]
+        self.assertEqual(result["today"]["agents"], ["today"])
+        self.assertEqual(result["today"]["sessions"], ["today"])
+        self.assertEqual(result["today"]["roleDays"], ["2026-10-05"])
+        self.assertEqual(result["yesterday"]["agents"], ["yesterdayEnd", "yesterdayStart"])
+        self.assertEqual(result["yesterday"]["sessions"], ["yesterdayEnd", "yesterdayStart"])
+        self.assertEqual(result["yesterday"]["roleDays"], ["2026-10-04"])
+        self.assertEqual(result["month"]["agents"], ["monthStart", "today", "yesterdayEnd", "yesterdayStart"])
+        self.assertEqual(result["month"]["roleDays"], ["2026-10-01", "2026-10-04", "2026-10-05"])
+        self.assertEqual(payload["migrated"], "today")
+        self.assertEqual(payload["invalid"], "30d")
+        self.assertEqual(payload["restored"], "today")
+        self.assertEqual(payload["restoredMonth"], "month")
+        self.assertEqual(payload["labels"]["month"], "Month")
+        self.assertNotIn("24h", payload["labels"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_explorer_withholds_filtered_totals_when_inventory_is_truncated(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
+const result=filterSubagentInventory({{inventory_count:1001,inventory_truncated:true,inventory:[{{id:'a',root_session_id:'root',runtime:'codex',label:'Agent A',activity_state:'complete',last_activity_at:100,attention:[]}}]}},{{query:'agent',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'recent'}},200);
+process.stdout.write(JSON.stringify(result));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertFalse(payload["summary"]["complete"])
+        self.assertIsNone(payload["summary"]["agents"])
+        self.assertEqual(payload["inventoryCount"], 1001)
+        self.assertEqual(len(payload["rows"]), 1)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_triage_preserves_context_and_pages_large_results(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('applySubagentPreset'));
+eval(extract('subagentPresetForFilters'));
+eval(extract('paginateSubagentRows'));
+const base={{query:'reviewer',runtime:'codex',project:'/token-meter',model:'gpt-5',status:'complete',signal:'retry_pressure',window:'7d',sort:'cost'}};
+const incomplete=applySubagentPreset(base,'incomplete');
+const attention=applySubagentPreset(base,'attention');
+const all=applySubagentPreset(base,'all');
+const rows=Array.from({{length:123}},(_,id)=>({{id}}));
+process.stdout.write(JSON.stringify({{
+ incomplete,attention,all,
+ presets:[subagentPresetForFilters(incomplete),subagentPresetForFilters(attention),subagentPresetForFilters(all),subagentPresetForFilters(base)],
+ first:paginateSubagentRows(rows,50),
+ complete:paginateSubagentRows(rows,150),
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+
+        for state in (payload["incomplete"], payload["attention"], payload["all"]):
+            self.assertEqual(state["runtime"], "codex")
+            self.assertEqual(state["project"], "/token-meter")
+            self.assertEqual(state["window"], "7d")
+            self.assertEqual(state["query"], "reviewer")
+            self.assertEqual(state["model"], "gpt-5")
+            self.assertEqual(state["sort"], "cost")
+        self.assertEqual(payload["incomplete"]["status"], "incomplete")
+        self.assertEqual(payload["incomplete"]["signal"], "all")
+        self.assertEqual(payload["attention"]["status"], "all")
+        self.assertEqual(payload["attention"]["signal"], "attention")
+        self.assertEqual(payload["all"]["status"], "all")
+        self.assertEqual(payload["all"]["signal"], "all")
+        self.assertEqual(payload["presets"], [
+            "incomplete", "attention", "all", "custom",
+        ])
+        self.assertEqual(len(payload["first"]["rows"]), 50)
+        self.assertEqual(payload["first"]["shown"], 50)
+        self.assertEqual(payload["first"]["total"], 123)
+        self.assertTrue(payload["first"]["hasMore"])
+        self.assertEqual(payload["first"]["nextLimit"], 100)
+        self.assertEqual(len(payload["complete"]["rows"]), 123)
+        self.assertFalse(payload["complete"]["hasMore"])
+        self.assertEqual(payload["complete"]["nextLimit"], 123)
+
+    def test_subagent_explorer_has_progressive_filters_and_evidence_inspector(self):
+        for expected in (
+            "id=subagent-view-tabs",
+            "aria-controls=subagent-results-panel",
+            "data-subagent-view=issues",
+            "data-subagent-view=sessions",
+            "data-subagent-view=roles",
+            "id=subagent-filter-more",
+            "id=subagent-filter-advanced",
+            "id=subagent-active-filters",
+            "id=subagent-workspace",
+            "id=subagent-results",
+            "id=subagent-results-panel role=tabpanel",
+            "id=subagent-inspector",
+            "data-subagent-open-parent",
+            "data-subagent-show-session",
+            "subagentWorkspace.roleView",
+            "expandedSubagentRoot=root",
+            "subagentInspector",
+        ):
+            self.assertIn(expected, self.page)
+        for removed in (
+            "id=subagent-triage",
+            "id=subagent-insights",
+            "id=subagent-explorer-summary",
+            "id=subagent-inventory-more",
+        ):
+            self.assertNotIn(removed, self.page)
+        self.assertIn("id=view-subagents", self.page)
+        self.assertIn("function renderSubagentInspector(", self.page)
+        self.assertIn("const incompletePill=compact('Incomplete'", self.page)
+        self.assertNotIn("compact('Needs review'", self.page)
+
+    def test_subagent_workspace_orders_roles_sessions_issues_and_defaults_to_roles(self):
+        tablist_start = self.page.index('id=subagent-view-tabs')
+        tablist_end = self.page.index('</div>', tablist_start)
+        tablist = self.page[tablist_start:tablist_end]
+        self.assertLess(tablist.index('data-subagent-view=roles'), tablist.index('data-subagent-view=sessions'))
+        self.assertLess(tablist.index('data-subagent-view=sessions'), tablist.index('data-subagent-view=issues'))
+        self.assertIn('data-subagent-view=roles aria-selected=true', tablist)
+        self.assertIn("localStorage.getItem('tm_subagent_view')||'roles'", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_work_sort_uses_user_facing_label_and_migrates_elapsed_preference(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const stored=new Map([['tm_subagent_filter_sort','elapsed']]),writes=[];
+const localStorage={{getItem:key=>stored.get(key)??null,setItem:(key,value)=>{{stored.set(key,String(value));writes.push([key,String(value)]);}}}};
+let subagentFilters;
+eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('function normalizeTimeFilterWindow(')).replace(/^const /gm,'var '));
+const initStart=page.indexOf('let subagentFilters={{');
+const initEnd=page.indexOf('const SUBAGENT_PAGE_SIZE',initStart);
+eval(page.slice(initStart,initEnd).replace('let subagentFilters=','subagentFilters='));
+const subagentFilterDefaults={{query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'}};
+eval(extract('normalizedSubagentNavigationState'));
+eval(extract('subagentActiveFilterItems'));
+const restored=normalizedSubagentNavigationState('sessions',{{sort:'elapsed'}});
+const chip=subagentActiveFilterItems({{...subagentFilterDefaults,sort:'work'}}).find(item=>item.key==='sort');
+process.stdout.write(JSON.stringify({{saved:subagentFilters.sort,stored:stored.get('tm_subagent_filter_sort'),writes,restored:restored.filters.sort,chip}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+
+        self.assertEqual(payload["saved"], "work")
+        self.assertEqual(payload["stored"], "work")
+        self.assertIn(["tm_subagent_filter_sort", "work"], payload["writes"])
+        self.assertEqual(payload["restored"], "work")
+        self.assertEqual(payload["chip"], {
+            "key": "sort", "label": "Sort", "value": "Work time",
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_time_filter_defaults_to_thirty_days_and_labels_all_history(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('function normalizeTimeFilterWindow(')).replace(/^const /gm,'var '));
+const initStart=page.indexOf('let subagentFilters={{'),initEnd=page.indexOf('const SUBAGENT_PAGE_SIZE',initStart);
+const defaultsLine=page.slice(page.indexOf('const subagentFilterDefaults='),page.indexOf('function persistSubagentFilter(')).replace(/^const /,'var ');
+const persistSource=extract('persistSubagentFilter'),chipsSource=extract('subagentActiveFilterItems');
+function load(entries){{
+ const stored=new Map(entries);
+ const localStorage={{getItem:key=>stored.get(key)??null,setItem:(key,value)=>stored.set(key,String(value)),removeItem:key=>stored.delete(key)}};
+ let subagentFilters;
+ eval(page.slice(initStart,initEnd).replace('let subagentFilters=','subagentFilters='));
+ eval(defaultsLine);
+ const subagentFilterStorage={{window:'tm_subagent_filter_time'}};
+ eval(persistSource);
+ const loaded=subagentFilters.window;
+ subagentFilters.window='all';persistSubagentFilter('window');const keptAll=stored.get('tm_subagent_filter_time')??null;
+ subagentFilters.window='30d';persistSubagentFilter('window');const atDefault=stored.get('tm_subagent_filter_time')??null;
+ return {{loaded,keptAll,atDefault,defaults:subagentFilterDefaults}};
+}}
+const fresh=load([]),bogus=load([['tm_subagent_filter_time','bogus']]),saved=load([['tm_subagent_filter_time','all']]);
+const subagentFilterDefaults=fresh.defaults;
+const appFilterLabel=row=>row.provider,projectFilterLabel=value=>value;
+eval(chipsSource);
+const chip=window=>subagentActiveFilterItems({{...subagentFilterDefaults,window}}).find(item=>item.key==='window')||null;
+process.stdout.write(JSON.stringify({{
+ fresh:fresh.loaded,bogus:bogus.loaded,saved:saved.loaded,keptAll:fresh.keptAll,atDefault:fresh.atDefault,
+ defaultChip:chip('30d'),allChip:chip('all'),sevenChip:chip('7d'),
+}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload["fresh"], "30d")
+        self.assertEqual(payload["bogus"], "30d")
+        self.assertEqual(payload["saved"], "all")
+        self.assertEqual(payload["keptAll"], "all")
+        self.assertIsNone(payload["atDefault"])
+        self.assertIsNone(payload["defaultChip"])
+        self.assertEqual(payload["allChip"], {"key": "window", "label": "Time", "value": "All history"})
+        self.assertEqual(payload["sevenChip"], {"key": "window", "label": "Time", "value": "7 days"})
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_summary_tags_toggle_incomplete_and_attention_filters(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)return null;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}return null;}}
+const source=extract('toggleSubagentSummaryFilter');
+if(!source)process.stdout.write(JSON.stringify({{missing:true}}));
+else{{
+ eval(source);
+ const start={{query:'reviewer',runtime:'codex',project:'/token-meter',model:'gpt',status:'all',signal:'all',window:'7d',sort:'cost'}};
+ process.stdout.write(JSON.stringify({{
+  missing:false,
+  incomplete:toggleSubagentSummaryFilter(start,'incomplete'),
+  incompleteOff:toggleSubagentSummaryFilter(toggleSubagentSummaryFilter(start,'incomplete'),'incomplete'),
+  attention:toggleSubagentSummaryFilter(start,'attention'),
+  outlier:toggleSubagentSummaryFilter(start,'peer_cost_outlier'),
+ }}));
+}}
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+
+        self.assertFalse(payload.get("missing", False))
+        self.assertEqual(payload["incomplete"]["status"], "incomplete")
+        self.assertEqual(payload["incomplete"]["signal"], "all")
+        self.assertEqual(payload["incompleteOff"]["status"], "all")
+        self.assertEqual(payload["attention"]["signal"], "attention")
+        self.assertEqual(payload["attention"]["status"], "all")
+        self.assertEqual(payload["outlier"]["signal"], "peer_cost_outlier")
+        self.assertEqual(payload["outlier"]["query"], "reviewer")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_drilldown_adds_restorable_browser_history(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const calls=[];
+const history={{state:{{sessionScope:'all'}},replaceState(state,title,url){{this.state=state;calls.push(['replace',state.subagent,url]);}},pushState(state,title,url){{this.state=state;location.href=String(url);location.hash='#'+String(url).split('#')[1];calls.push(['push',state.subagent,url]);}}}};
+const location={{href:'http://127.0.0.1:8722/#subagents',hash:'#subagents'}};
+const localStorage={{setItem(){{}},removeItem(){{}}}};
+const subagentFilterDefaults={{query:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'recent'}};
+let subagentView='roles',subagentFilters={{...subagentFilterDefaults,project:'/token-meter',window:'30d'}},selectedSubagentId='child',expandedSubagentRoot='root';
+const persistSubagentFilter=()=>{{}},resetSubagentResultView=()=>{{}};
+eval(['normalizedSubagentNavigationState','restoreSubagentNavigationState','openSubagentRoleRuns'].map(extract).join('\\n'));
+openSubagentRoleRuns('token_meter_reviewer','codex','spawned');
+const drilldown={{view:subagentView,filters:subagentFilters}};
+restoreSubagentNavigationState(calls[0][1]);
+process.stdout.write(JSON.stringify({{calls,drilldown,restored:{{view:subagentView,filters:subagentFilters}},sessionScope:history.state.sessionScope}}));
+"""
+        completed = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        payload = json.loads(completed.stdout)
+
+        self.assertEqual([call[0] for call in payload["calls"]], ["replace", "push"])
+        self.assertEqual(payload["calls"][0][1]["view"], "roles")
+        self.assertEqual(payload["calls"][0][1]["filters"]["project"], "/token-meter")
+        self.assertEqual(payload["drilldown"]["view"], "sessions")
+        self.assertEqual(payload["calls"][1][2], "/#sessions-subagents")
+        self.assertEqual(payload["drilldown"]["filters"]["role"], "token_meter_reviewer")
+        self.assertEqual(payload["drilldown"]["filters"]["kind"], "spawned")
+        self.assertEqual(payload["restored"]["view"], "roles")
+        self.assertEqual(payload["restored"]["filters"]["window"], "30d")
+        self.assertEqual(payload["sessionScope"], "all")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagents_have_a_primary_page_and_canonical_return_route(self):
+        self.assertIn("id=tab-subagents", self.page)
+        self.assertIn("id=view-subagents", self.page)
+        self.assertIn("id=session-scope-subagents", self.page)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const SESSION_SCOPES=['current','all','subagents'];
+eval(extract('normalizeSessionScope'));
+eval(extract('sessionScopeRoute'));
+process.stdout.write(JSON.stringify({{subagents:sessionScopeRoute('subagents'),all:sessionScopeRoute('all'),current:sessionScopeRoute('current')}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertEqual(payload, {
+            "subagents": "sessions-subagents", "all": "sessions-all", "current": "sessions",
+        })
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_runs_model_distribution_is_exact_and_runtime_scoped(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
+eval(extract('subagentModelDistribution'));
+const rows=[
+ {{id:'1',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-x',cost:2,cost_available:true}},
+ {{id:'2',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-x',cost_available:false}},
+ {{id:'3',runtime:'claude',kind:'spawned',role:'token_meter_reviewer',model:'gpt-x',cost:3,cost_available:true}},
+ {{id:'4',runtime:'codex',role:'tester',label:'token_meter_reviewer helper',model:'gpt-y',cost:9,cost_available:true}},
+ {{id:'5',runtime:'codex',kind:'internal',role:'token_meter_reviewer',model:'gpt-y',cost:11,cost_available:true}},
+];
+const result=filterSubagentInventory({{inventory:rows}},{{role:'token_meter_reviewer',kind:'spawned',status:'all',signal:'all',window:'all',sort:'recent'}});
+process.stdout.write(JSON.stringify({{ids:result.rows.map(row=>row.id),models:subagentModelDistribution(result.rows)}}));
+"""
+        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        payload = json.loads(completed.stdout)
+        self.assertEqual(payload["ids"], ["1", "2", "3"])
+        self.assertEqual(len(payload["models"]), 2)
+        self.assertEqual(payload["models"][0]["runtime"], "codex")
+        self.assertEqual(payload["models"][0]["runs"], 2)
+        self.assertEqual(payload["models"][0]["costCovered"], 1)
+        self.assertEqual(payload["models"][0]["cost"], 2)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_session_rows_keep_spawned_run_count(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const selectedSubagentId='',expandedSubagentRoot='not-this-root';
+const esc=value=>String(value),f=value=>String(value),countWord=(value,word)=>value===1?word:`${{word}}s`,money=value=>`$${{Number(value).toFixed(2)}}`,compactNumber=value=>String(value),currentSessionAge=()=> 'now',durationShort=value=>`${{value}}s`;
+const agentIdentityPresentation=(row)=>({{primary:row.role||row.label,secondary:''}}),subagentParentPresentation=()=>({{title:'Parent run',project:'token-meter'}});
+eval(extract('groupSubagentSessions'));
+eval(extract('subagentCostHeat'));
+eval(extract('subagentGroupHtml'));
+const rows=[
+ {{id:'a',role:'reviewer',kind:'spawned',activity_state:'complete',model:'gpt',cost:1,cost_available:true,tokens:10,tokens_available:true,work_time_s:600,attention:[]}},
+ {{id:'b',role:'tester',kind:'spawned',activity_state:'incomplete',model:'gpt',cost:2,cost_available:true,tokens:20,tokens_available:true,work_time_s:null,attention:[]}},
+];
+rows.forEach(row=>{{row.root_session_id='root';row.project='/token-meter';}});
+const html=subagentGroupHtml(groupSubagentSessions(rows,false,'work')[0],0,new Map(),false);
+process.stdout.write(JSON.stringify({{html}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertIn("Spawned runs", payload["html"])
+        self.assertIn("<b>2</b>", payload["html"])
+        self.assertIn("Work time", payload["html"])
+        self.assertIn("600s", payload["html"])
+        self.assertIn("work time --", payload["html"])
+        self.assertIn("subagentCostHeat", payload["html"])
+        self.assertIn("--cost-fill:100%", payload["html"])
+        self.assertNotIn("Need review", payload["html"])
+        self.assertNotIn("Needs attention", payload["html"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_cost_color_is_relative_and_unavailable_cost_is_neutral(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('subagentCostHeat'));
+process.stdout.write(JSON.stringify({{low:subagentCostHeat(1,10,true),high:subagentCostHeat(10,10,true),missing:subagentCostHeat(null,10,false)}}));
+"""
+        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        result = json.loads(completed.stdout)
+        self.assertIn("--cost-fill:10%", result["low"])
+        self.assertIn("--cost-fill:100%", result["high"])
+        self.assertNotEqual(result["low"], result["high"])
+        self.assertEqual(result["missing"], "")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_role_name_search_keeps_exact_cost_trend_and_comparison(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(['selectSubagentUsageScope','subagentRoleKey','subagentRoleFineFilters','subagentRoleDayRows','buildSubagentRoleEconomics','buildSubagentModelTrends','subagentModelDayRows','subagentModelKey'].map(extract).join('\\n'));
+const reviewer={{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',agents:2,known_cost:4,cost_available:true,cost_covered_agents:2}};
+const tester={{runtime:'codex',kind:'spawned',role:'token_meter_tester',agents:1,known_cost:9,cost_available:true,cost_covered_agents:1}};
+const usage={{scopes:[{{runtime:'',project:'',window:'7d',roles:[reviewer,tester],comparison:{{roles:[{{...reviewer,agents:1,known_cost:3,cost_covered_agents:1}},tester]}}}}],role_days:[{{...reviewer,day:'2026-09-27'}},{{...tester,day:'2026-09-27'}}]}};
+const filters={{query:'reviewer',runtime:'',project:'',window:'7d',model:'',status:'all',signal:'all'}};
+process.stdout.write(JSON.stringify(buildSubagentRoleEconomics(usage,filters,Date.parse('2026-09-28T12:00:00'))));
+"""
+        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        result = json.loads(completed.stdout)
+        self.assertIsNone(result["reason"])
+        self.assertEqual(result["runs"], 2)
+        self.assertEqual(result["cost"], 4)
+        self.assertEqual(result["previousCost"], 3)
+        self.assertEqual([row["role"] for row in result["roles"]], ["token_meter_reviewer"])
+        self.assertEqual([row["role"] for row in result["days"]], ["token_meter_reviewer"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_table_reports_total_covered_spend(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,compactNumber=value=>String(value),appFilterLabel=({{provider}})=>provider;
+eval(extract('buildSubagentRoleRows'));
+eval(extract('renderSubagentRoles'));
+const html=renderSubagentRoles([
+ {{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt',activity_state:'complete',cost:1,cost_available:true,tokens:100,tokens_available:true,attention:[]}},
+ {{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt',activity_state:'complete',cost:3,cost_available:true,tokens:200,tokens_available:true,attention:[]}},
+ {{runtime:'codex',kind:'spawned',role:'token_meter_tester',model:'gpt',activity_state:'complete',cost:null,cost_available:false,tokens:50,tokens_available:true,attention:[]}},
+]);
+process.stdout.write(JSON.stringify({{html}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        self.assertIn("Total spend", payload["html"])
+        self.assertIn("$4.00", payload["html"])
+        self.assertIn("token_meter_tester", payload["html"])
+        self.assertIn("<b>--</b>", payload["html"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_economics_compares_spend_volume_and_cost_per_run(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(['selectSubagentUsageScope','subagentRoleKey','subagentRoleFineFilters','subagentRoleDayRows','buildSubagentRoleEconomics','buildSubagentModelTrends','subagentModelDayRows','subagentModelKey'].map(extract).join('\\n'));
+const current=[
+ {{id:'reviewer::codex::spawned',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost:6,cost_available:true,cost_covered_agents:2,known_tokens:600,tokens:600,tokens_available:true,token_covered_agents:2,median_cost:3,p95_cost:4,incomplete_agents:1,attention_agents:1}},
+ {{id:'tester::codex::spawned',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost:2,cost_available:true,cost_covered_agents:1,known_tokens:200,tokens:200,tokens_available:true,token_covered_agents:1,median_cost:2,p95_cost:2,incomplete_agents:0,attention_agents:0}},
+];
+const previous=[
+ {{id:'reviewer::codex::spawned',runtime:'codex',kind:'spawned',role:'reviewer',agents:1,known_cost:8,cost:8,cost_available:true,cost_covered_agents:1,median_cost:8,p95_cost:8,incomplete_agents:0,attention_agents:0}},
+];
+const usage={{scopes:[{{window:'7d',runtime:'codex',project:'/repo',roles:current,comparison:{{roles:previous}}}}],role_day_count:2,role_days_truncated:false,role_days:[
+ {{day:'2026-09-24',project:'/repo',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true,cost_covered_agents:2}},
+ {{day:'2026-09-23',project:'/repo',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost_available:true,cost_covered_agents:1}},
+]}};
+const base={{query:'',runtime:'codex',project:'/repo',model:'',status:'all',signal:'all',window:'7d',sort:'recent'}};
+const result=buildSubagentRoleEconomics(usage,base,Date.parse('2026-09-24T12:00:00'));
+const partial=buildSubagentRoleEconomics({{...usage,scopes:[{{...usage.scopes[0],roles:[{{...current[0],known_cost:3,cost:null,cost_available:false,cost_covered_agents:1}}]}}]}},base,Date.parse('2026-09-24T12:00:00'));
+const uncovered=buildSubagentRoleEconomics({{...usage,scopes:[{{...usage.scopes[0],roles:[{{...current[0],known_cost:0,cost:null,cost_available:false,cost_covered_agents:0}}]}}]}},base,Date.parse('2026-09-24T12:00:00'));
+const filtered=buildSubagentRoleEconomics(usage,{{...base,status:'incomplete'}},Date.parse('2026-09-24T12:00:00'));
+process.stdout.write(JSON.stringify({{result,partial,uncovered,filtered}}));
+"""
+        completed = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        payload = json.loads(completed.stdout)
+
+        result = payload["result"]
+        self.assertEqual(result["runs"], 3)
+        self.assertEqual(result["cost"], 8)
+        self.assertAlmostEqual(result["averageCost"], 8 / 3)
+        self.assertEqual(result["previousRuns"], 1)
+        self.assertEqual(result["previousCost"], 8)
+        self.assertEqual(result["costChange"], 0)
+        self.assertAlmostEqual(result["averageCostChange"], -2 / 3)
+        reviewer = next(row for row in result["roles"] if row["role"] == "reviewer")
+        self.assertEqual(reviewer["costChange"], -0.25)
+        self.assertEqual(reviewer["runChange"], 1)
+        self.assertEqual(payload["partial"]["cost"], 3)
+        self.assertEqual(payload["partial"]["costCovered"], 1)
+        self.assertEqual(payload["partial"]["averageCost"], 3)
+        self.assertIsNone(payload["partial"]["costChange"])
+        self.assertIsNone(payload["partial"]["averageCostChange"])
+        self.assertIsNone(payload["uncovered"]["cost"])
+        self.assertIsNone(payload["uncovered"]["averageCost"])
+        self.assertEqual(payload["filtered"]["reason"], "filtered")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_economics_renders_a_clear_chart_for_each_role(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,appFilterLabel=({{provider}})=>provider;
+let subagentRoleChartMode='average';
+eval(['subagentRoleKey','renderSubagentRoleSparkline','renderSubagentRoleEconomics','renderSubagentTrendSparkline','renderSubagentModelTrends','subagentModelKey'].map(extract).join('\\n'));
+const economics={{reason:null,window:'7d',runs:3,cost:8,averageCost:8/3,costCovered:3,previousRuns:1,previousCost:8,costChange:0,averageCostChange:-2/3,runChange:2,incomplete:1,attention:1,previousIncomplete:0,roles:[
+ {{id:'reviewer::codex::spawned',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost:6,cost_available:true,cost_covered_agents:2,known_tokens:600,tokens_available:true,token_covered_agents:2,median_cost:3,p95_cost:4,incomplete_agents:1,attention_agents:1,costChange:-.25,runChange:1,averageCostChange:-.625}},
+ {{id:'tester::codex::spawned',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost:2,cost_available:true,cost_covered_agents:1,known_tokens:200,tokens_available:true,token_covered_agents:1,median_cost:2,p95_cost:2,incomplete_agents:0,attention_agents:0,costChange:.2,runChange:0,averageCostChange:.2}},
+],days:[
+ {{day:'2026-09-23',runtime:'codex',kind:'spawned',role:'reviewer',agents:1,known_cost:4,cost_available:true,cost_covered_agents:1}},
+ {{day:'2026-09-24',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true,cost_covered_agents:2}},
+ {{day:'2026-09-23',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:1,cost_available:true,cost_covered_agents:1}},
+ {{day:'2026-09-24',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost_available:true,cost_covered_agents:1}},
+]}};
+const partial=renderSubagentRoleEconomics({{...economics,runs:2,cost:3,averageCost:3,costCovered:1,costChange:null,averageCostChange:null}});
+const allHistory=renderSubagentRoleEconomics({{...economics,window:'all',previousRuns:null,previousCost:null,costChange:null,averageCostChange:null,runChange:null,roles:economics.roles.map(row=>({{...row,costChange:null,averageCostChange:null,runChange:null}}))}});
+process.stdout.write(JSON.stringify({{html:renderSubagentRoleEconomics(economics),partial,allHistory}}));
+"""
+        completed = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        payload = json.loads(completed.stdout)
+
+        html = payload["html"]
+        self.assertIn("Role trends", html)
+        self.assertIn("Cost / run", html)
+        self.assertEqual(html.count("<svg"), 2)
+        self.assertIn('aria-label="reviewer cost per run trend"', html)
+        self.assertIn('aria-label="tester cost per run trend"', html)
+        self.assertLess(html.index('subagentRoleKpi'), html.index('Role spend'))
+        self.assertLess(html.index('Cost / run'), html.index('Role spend'))
+        self.assertIn('2026-09-23', html)
+        self.assertIn('2026-09-24', html)
+        self.assertNotIn('>1 review<', html)
+        self.assertIn("data-subagent-inspect-role=", html)
+        self.assertIn("reviewer", html)
+        self.assertIn("tester", html)
+        self.assertIn("View runs", html)
+        self.assertNotIn("What changed", html)
+        self.assertNotIn("Role spend over time", html)
+        self.assertIn("Covered role spend", payload["partial"])
+        self.assertIn("Cost / covered run", payload["partial"])
+        self.assertIn("$3.00", payload["partial"])
+        self.assertIn("1 / 2 cost-covered", payload["partial"])
+        self.assertIn("Named runs", payload["partial"])
+        self.assertNotIn("No comparable baseline", payload["allHistory"])
+        self.assertNotIn("<small>--</small>", payload["allHistory"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_economics_withholds_truncated_period_insights(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,appFilterLabel=({{provider}})=>provider;
+let subagentRoleChartMode='spend';
+eval(['subagentRoleKey','renderSubagentRoleSparkline','renderSubagentRoleEconomics','renderSubagentTrendSparkline','renderSubagentModelTrends','subagentModelKey'].map(extract).join('\\n'));
+const economics={{reason:null,window:'7d',runs:2,cost:6,averageCost:3,costCovered:2,previousRuns:1,previousCost:2,costChange:2,averageCostChange:.5,runChange:1,incomplete:0,attention:0,previousIncomplete:0,trendTruncated:true,roles:[
+ {{runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true,cost_covered_agents:2,median_cost:3,p95_cost:4,incomplete_agents:0,attention_agents:0,costChange:2,runChange:1}},
+],days:[{{day:'2026-09-24',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true}}]}};
+const spend=renderSubagentRoleEconomics(economics);
+subagentRoleChartMode='runs';
+const runs=renderSubagentRoleEconomics(economics);
+process.stdout.write(JSON.stringify({{spend,runs}}));
+"""
+        completed = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        payload = json.loads(completed.stdout)
+        for html in payload.values():
+            self.assertIn("Trend unavailable", html)
+            self.assertIn("daily history was truncated", html)
+            self.assertNotIn("What changed", html)
+            self.assertNotIn("Higher spend for reviewer", html)
+        self.assertNotIn("+1 vs prior", payload["runs"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_role_charts_do_not_hide_lower_spend_roles(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const esc=value=>String(value);
+let subagentRoleChartMode='spend';
+eval(['subagentRoleKey','renderSubagentRoleSparkline','renderSubagentTrendSparkline'].map(extract).join('\\n'));
+const roles=Array.from({{length:6}},(_,index)=>({{runtime:'codex',kind:'spawned',role:`role_${{index+1}}`}}));
+const days=roles.map((row,index)=>({{day:'2026-09-24',...row,agents:1,known_cost:6-index,cost_available:true}}));
+process.stdout.write(roles.map(row=>renderSubagentRoleSparkline({{trendTruncated:false,days}},row)).join(''));
+"""
+        completed = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        self.assertEqual(completed.stdout.count("<svg"), 6)
+        self.assertIn('aria-label="role_5 spend trend"', completed.stdout)
+        self.assertIn('aria-label="role_6 spend trend"', completed.stdout)
+        self.assertNotIn("Other roles", completed.stdout)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_workspace_groups_parent_sessions_and_prioritizes_issues(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('groupSubagentSessions'));
+const rows=[
+ {{id:'quiet',root_session_id:'root-quiet',project:'/quiet',activity_state:'complete',last_activity_at:300,cost:10,cost_available:true,attention:[]}},
+ {{id:'incomplete',root_session_id:'root-incomplete',project:'/work',activity_state:'incomplete',last_activity_at:200,cost:4,cost_available:true,attention:[]}},
+ {{id:'attention-2',root_session_id:'root-attention',project:'/work',activity_state:'complete',last_activity_at:90,cost:null,cost_available:false,attention:[]}},
+ {{id:'attention',root_session_id:'root-attention',project:'/work',activity_state:'complete',last_activity_at:100,cost:1,cost_available:true,attention:[{{code:'peer_cost_outlier'}}]}},
+];
+process.stdout.write(JSON.stringify({{issues:groupSubagentSessions(rows,true),sessions:groupSubagentSessions(rows,false)}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+
+        self.assertEqual(
+            [row["rootSessionId"] for row in payload["issues"]],
+            ["root-attention", "root-incomplete"],
+        )
+        self.assertEqual(len(payload["sessions"]), 3)
+        attention = payload["issues"][0]
+        self.assertEqual(attention["agents"], 2)
+        self.assertEqual(attention["attention"], 1)
+        self.assertEqual(attention["incomplete"], 0)
+        self.assertEqual(attention["costCovered"], 1)
+        self.assertEqual(attention["cost"], 1)
+        self.assertEqual(
+            [row["id"] for row in attention["rows"]],
+            ["attention", "attention-2"],
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_roles_preserve_runtime_kind_and_calculate_review_metrics(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('buildSubagentRoleRows'));
+const rows=[
+ {{id:'a',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-a',activity_state:'complete',cost:1,cost_available:true,tokens:100,tokens_available:true,attention:[]}},
+ {{id:'b',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-a',activity_state:'incomplete',cost:3,cost_available:true,tokens:300,tokens_available:true,attention:[{{code:'retry_pressure'}}]}},
+ {{id:'c',runtime:'claude',kind:'spawned',role:'token_meter_reviewer',model:'opus',activity_state:'complete',cost:8,cost_available:true,tokens:800,tokens_available:true,attention:[]}},
+ {{id:'d',runtime:'codex',kind:'spawned',role:null,model:'gpt-a',activity_state:'complete',cost:5,cost_available:true,tokens:500,tokens_available:true,attention:[]}},
+];
+process.stdout.write(JSON.stringify(buildSubagentRoleRows(rows)));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+
+        self.assertEqual(len(payload), 2)
+        claude, codex = payload
+        self.assertEqual((claude["runtime"], claude["role"]), ("claude", "token_meter_reviewer"))
+        self.assertEqual((codex["runtime"], codex["kind"]), ("codex", "spawned"))
+        self.assertEqual(codex["agents"], 2)
+        self.assertEqual(codex["incomplete"], 1)
+        self.assertEqual(codex["attention"], 1)
+        self.assertEqual(codex["incompleteRate"], 0.5)
+        self.assertEqual(codex["attentionRate"], 0.5)
+        self.assertEqual(codex["medianCost"], 2)
+        self.assertEqual(codex["p95Cost"], 3)
+        self.assertEqual(codex["knownTokens"], 400)
+        self.assertEqual(codex["topModel"], "gpt-a")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_subagent_usage_scope_supports_project_filters_and_blocks_text_search(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+eval(extract('selectSubagentUsageScope'));
+const usage={{totals:{{agents:9}},scope_truncated:false,scopes:[
+ {{window:'all',runtime:'',project:'',totals:{{agents:9}}}},
+ {{window:'7d',runtime:'codex',project:'~/Documents/github/token-meter',totals:{{agents:2}}}},
+]}};
+process.stdout.write(JSON.stringify({{
+ supported:selectSubagentUsageScope(usage,'codex','7d','~/Documents/github/token-meter',false),
+ blocked:selectSubagentUsageScope(usage,'codex','7d','~/Documents/github/token-meter',true),
+ missing:selectSubagentUsageScope(usage,'codex','7d','~/Documents/github/luna-3',false),
+ truncated:selectSubagentUsageScope({{...usage,scope_truncated:true}},'codex','7d','~/Documents/github/luna-3',false),
+}}));
+"""
+
+        result = subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        )
+        payload = json.loads(result.stdout)
+        self.assertIsNotNone(payload["supported"]["usage"])
+        self.assertEqual(payload["supported"]["usage"]["totals"]["agents"], 2)
+        self.assertIsNone(payload["supported"]["reason"])
+        self.assertIsNone(payload["blocked"]["usage"])
+        self.assertEqual(payload["blocked"]["reason"], "filtered")
+        self.assertIsNone(payload["missing"]["usage"])
+        self.assertEqual(payload["missing"]["reason"], "empty")
+        self.assertIsNone(payload["truncated"]["usage"])
+        self.assertEqual(payload["truncated"]["reason"], "unavailable")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_tools.py b/tests/test_dashboard_tools.py
new file mode 100644
index 00000000..4081f5ce
--- /dev/null
+++ b/tests/test_dashboard_tools.py
@@ -0,0 +1,210 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardToolsLayoutTests(DashboardLayoutCase):
+    def test_tools_leads_with_stats_review_queue_and_visible_inventory(self):
+        self.assertRegex(self.page, r"id=tab-capabilities[^>]*>.*?<span class=tabLabel>Tools</span>")
+        tools = self.page.split("id=view-capabilities", 1)[1].split(
+            "id=view-settings", 1
+        )[0]
+        for marker in (
+            'aria-label="Capability overview"', "id=c-stat-tools",
+            "id=c-stat-mcps", "id=c-stat-skills", "data-cap-jump=tool",
+            "id=c-review-queue", "id=c-review-list",
+            "id=c-selection-bar", "id=c-disable-selected",
+            "id=c-inventory", "id=c-clear-filters", "id=c-active-filters",
+            'aria-label="Prompt-load evidence"',
+        ):
+            self.assertIn(marker, tools)
+        self.assertLess(tools.index('aria-label="Capability overview"'), tools.index("id=c-review-queue"))
+        self.assertLess(tools.index("id=c-review-queue"), tools.index("id=c-inventory"))
+        self.assertRegex(tools, r"<section class=\"card capInventory\" id=c-inventory")
+        self.assertNotIn('class="card capInventory" id=c-inventory-details', tools)
+        self.assertNotIn("id=c-catalog-details", tools)
+        self.assertIn('class="capPageHead spectrumPageHead"', tools)
+        self.assertIn("class=spectrumPageHeadCopy", tools)
+        tools_head = tools.split('<section class="card capStats"', 1)[0]
+        for removed in (
+            "hasPageActions", "spectrumPageActions", "capFreshness",
+            "c-evidence-status", "c-evidence-updated",
+        ):
+            self.assertNotIn(removed, tools_head)
+        self.assertNotIn("c-evidence-status", self.page)
+        self.assertNotIn("c-evidence-updated", self.page)
+        for removed in (
+            "id=c-decision-panel", "id=c-opt-enabled", "id=c-opt-used",
+            "id=c-opt-review", "id=c-mcp-observed",
+            'aria-label="Capability evidence summary"', "id=c-review-filter",
+            "id=c-browse-all",
+        ):
+            self.assertNotIn(removed, tools)
+        self.assertIn('aria-label="Capability type"', self.page)
+        self.assertIn('aria-label="Evidence and configuration"', self.page)
+        self.assertIn('aria-label="Search installed capabilities"', self.page)
+        self.assertIn("button.setAttribute('aria-pressed'", self.page)
+        self.assertIn("function renderCapabilityReviewQueue(cap", self.page)
+        self.assertIn("function unusedReviewGroups(cap)", self.page)
+        self.assertIn("if(!cap)return;", self.page)
+        self.assertIn("fetch('/capabilities/inventory'", self.page)
+        self.assertIn("CAPABILITY_PAGE_SIZE=100", self.page)
+        self.assertIn("id=c-mobile-sort", self.page)
+        self.assertIn("function openCapabilityInventory(type='all')", self.page)
+        self.assertIn("button.onclick=()=>openCapabilityInventory(button.dataset.capJump)", self.page)
+        self.assertIn("function clearCapabilityFilter(key)", self.page)
+        self.assertIn("row.measurement==='instruction'?'Instruction-only':'Evidence unavailable'", self.page)
+        self.assertIn("return row.enabled===true?'Enabled':row.enabled===false?'Disabled':'Unknown'", self.page)
+        self.assertIn("const selectedCapabilityIds=new Set()", self.page)
+        self.assertIn("openSelectedDisableDialog", self.page)
+        self.assertIn("capabilityRuntime='all'", self.page)
+        self.assertIn("lastCapabilityReviewRevision", self.page)
+        self.assertIn("cap.review_revision", self.page)
+        self.assertIn("cap.inventory_revision", self.page)
+        self.assertIn("setCapabilityAvailability('stale'", self.page)
+        self.assertIn("data-label=\"Configuration\"", self.page)
+        self.assertIn("data-label=\"Evidence\"", self.page)
+        self.assertNotIn("Loaded ·", self.page)
+        self.assertNotIn("Disable all unused", self.page)
+        self.assertNotIn("if(row.unmeasurable) return '<span class=subline>not measurable</span>'", self.page)
+
+    def test_skill_pack_changes_confirm_exact_control_and_use_verified_state(self):
+        self.assertIn("id=cap-dialog", self.page)
+        self.assertIn("control_id:controlId", self.page)
+        self.assertIn("result.capabilities||cap", self.page)
+        self.assertIn("Setting verified.", self.page)
+        self.assertIn("row.reviewable!==false", self.page)
+        self.assertNotIn("...group,id:group.item_id", self.page)
+
+    def test_sessions_show_skill_and_mcp_capability_counts(self):
+        self.assertIn("return `${f(counts.used)}/${counts.loaded==null?'—':f(counts.loaded)}${counts.basis==='configured'?'*':''}`;", self.page)
+        self.assertIn('</div>${identityAction}</div>\n  <div class=sactions>${sessionDeleteAvailable(s,renderedAllSessionActions)?', self.page)
+        self.assertNotIn('<div class="badge tok">', self.page)
+        self.assertIn('class="sessionDelete sessionDeleteIcon" data-delete-session="${esc(sessionRowKey(s))}" type=button aria-label="Delete session" title="Delete session"><svg', self.page)
+        self.assertIn('<span class="currentSessionCaps mono" title="${esc(CAPABILITY_SUMMARY_TIP)}">${esc(capabilitySummaryText(row.capabilities))}</span>', self.page)
+        self.assertIn('<div class=meta title="${esc(`${waitText} · ${avg}/exec${speed} · ${CAPABILITY_SUMMARY_TIP}`)}">${esc(s.project||\'local\')} · ${esc(s.last||s.start||\'\')} · ${esc(capabilitySummaryText(s.capabilities))}</div>', self.page)
+        self.assertIn("s.throughput,s.cost_approx,s.capabilities,childAgentsFor(s)", self.page)
+        self.assertIn("<div class=sbar><i></i></div>${childAgentSubsection(s)}</div>", self.page)
+        self.assertIn('id=ov-skills>--</div>', self.page)
+        self.assertIn('id=ov-mcp>--</div>', self.page)
+        self.assertIn("counts.loaded==null?'loaded list not recorded'", self.page)
+        self.assertIn("* means configured now, not recorded by this session.", self.page)
+
+    def test_selected_candidate_action_has_confirmation_and_exact_control_ids(self):
+        self.assertIn("id=c-disable-selected", self.page)
+        self.assertIn("id=bulk-dialog", self.page)
+        self.assertIn("/capability/disable-unused", self.page)
+        self.assertIn('data-cap-select="${esc(row.id)}"', self.page)
+        self.assertIn("selectedCapabilityIds.add(input.dataset.capSelect)", self.page)
+        self.assertIn("unusedReviewGroups(cap).filter(row=>selectedCapabilityIds.has(row.id))", self.page)
+        self.assertIn("pendingBulkDisable={controlIds,fingerprints:", self.page)
+        self.assertIn("capabilityGroupFingerprint(row)", self.page)
+        self.assertIn("$('bulk-dialog-controls').textContent=controlIds.join('\\n')", self.page)
+        self.assertIn("control_ids:controlIds", self.page)
+        self.assertIn("Review evidence changed", self.page)
+        self.assertIn('aria-label="Select ${esc(name)}"', self.page)
+        self.assertIn("MCP servers, runtime packs, built-ins, standalone skills, and used groups are excluded.", self.page)
+        self.assertIn("Disable selected", self.page)
+        self.assertNotIn("id=c-disable-unused", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_capability_review_queue_renders_one_expandable_row_per_pack(self):
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const f=n=>Math.round(n||0).toLocaleString('en-US');
+const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
+const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({{'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}}[c]));
+const compactNumber=n=>String(n);
+const els={{}};
+const el=id=>els[id]||(els[id]={{id,textContent:'',innerHTML:'',hidden:false,disabled:false,title:'',classList:{{toggle(){{}}}},matches:()=>false,contains:()=>false,querySelectorAll:()=>[],querySelector:()=>null}});
+const $=el;
+const document={{activeElement:null}};
+const selectedCapabilityIds=new Set(['codex:aws']);
+const openCapabilityReviewIds=new Set();
+let capabilityEvidenceState='current',lastCapabilityReviewRevision='',pendingCapabilityReview=null;
+const openCapabilityInventory=()=>{{}};
+eval(['capabilityPackName','capabilityGroupFingerprint','updateCapabilitySelection','unusedReviewGroups'].map(extract).join('\\n'));
+eval(page.slice(page.indexOf('function renderCapabilityReviewQueue('),page.indexOf('function renderCapabilityTable(')));
+const group=(id,plugin,runtime,extra={{}})=>({{id,plugin_id:plugin,runtime,mutable:true,enabled:true,used:false,unmeasurable:false,scanned_sessions:142,members:['a','b','c','d','e','f'],setting_path:'~/.codex/config.toml',...extra}});
+const render=groups=>{{
+ lastCapabilityReviewRevision='';
+ renderCapabilityReviewQueue({{review_revision:String(Math.random()),summary:{{optional:{{review_candidates:groups.map(g=>g.id)}}}},control_groups:groups}},{{force:true}});
+ return {{html:el('c-review-list').innerHTML,caveat:el('c-review-detail').textContent}};
+}};
+const same=render([group('codex:aws','aws-skills@market','Codex'),group('codex:gcp','gcp-skills','Codex',{{unused_eager_definition_tokens:12345,members:['solo']}})]);
+const mixed=render([group('codex:aws','aws-skills','Codex'),group('claude:k8s','k8s','Claude')]);
+process.stdout.write(JSON.stringify({{same,mixed}}));
+"""
+        payload = json.loads(subprocess.run(
+            ["node", "-e", script], capture_output=True, text=True, check=True,
+        ).stdout)
+        same = payload["same"]["html"]
+        rows = re.findall(r"<article class=capReviewItem[^>]*>.*?</article>", same, re.S)
+        self.assertEqual(len(rows), 2)
+        self.assertEqual(same.count("class=capReviewHead"), 1)
+        self.assertLess(same.index("class=capReviewHead"), same.index("<article"))
+        first = rows[0]
+        summary = re.search(r"<summary class=capReviewCols[^>]*>(.*?)</summary>", first, re.S)
+        self.assertIsNotNone(summary)
+        summary_html = summary.group(1)
+        self.assertIn("<strong>aws-skills</strong>", summary_html)
+        self.assertIn("Codex · User-installed", summary_html)
+        self.assertIn("0 uses · 142 logs", summary_html)
+        self.assertIn('title="Not measured"', summary_html)
+        self.assertIn(">—<", summary_html)
+        self.assertNotIn(">0<", summary_html)
+        self.assertIn("6 skills", summary_html)
+        self.assertIn('class="stateDot unknown"', summary_html)
+        # The checkbox sits outside the summary so selecting never toggles the row.
+        self.assertNotIn("data-cap-select", summary_html)
+        self.assertNotIn("<input", first.split("</details>", 1)[0])
+        self.assertIn('data-cap-select="codex:aws" aria-label="Select aws-skills" checked', first)
+        detail = first.split("</summary>", 1)[1].split("</details>", 1)[0]
+        for marker in ("class=capReviewFacts", "0 activations · 142 Codex logs",
+                       "Not measured", "Exact control", "codex:aws", "~/.codex/config.toml"):
+            self.assertIn(marker, detail)
+        self.assertIn("12,345", rows[1])
+        self.assertIn("1 skill<", rows[1])
+        self.assertNotIn('aria-label="Select gcp-skills" checked', rows[1])
+        # One runtime: the restart note is shown once in the header, not per row.
+        self.assertNotIn("to apply", same)
+        self.assertIn("Restart Codex to apply", payload["same"]["caveat"])
+        mixed = payload["mixed"]["html"]
+        self.assertEqual(mixed.count("Restart Codex to apply"), 1)
+        self.assertEqual(mixed.count("Restart Claude to apply"), 1)
+        self.assertNotIn("Restart", payload["mixed"]["caveat"])
+
+    def test_capability_polling_uses_stable_revisions_and_lazy_inventory(self):
+        review = self.page.split("function renderCapabilityReviewQueue", 1)[1].split(
+            "function renderCapabilityTable", 1
+        )[0]
+        inventory = self.page.split("function renderCapabilityTable", 1)[1].split(
+            "let pendingCapabilityAction", 1
+        )[0]
+        self.assertIn("revision===lastCapabilityReviewRevision", review)
+        self.assertIn("lastCapabilityReviewRevision=revision", review)
+        self.assertIn("if(!cap)return;", inventory)
+        self.assertNotIn("c-inventory-details", inventory)
+        self.assertNotIn("$('c-inventory-details').addEventListener('toggle'", self.page)
+        self.assertIn("fetch('/capabilities/inventory',{cache:'no-store'})", self.page)
+        self.assertIn("countWord(inventoryCount,'capability','capabilities')", self.page)
+        self.assertIn("capabilityInventorySnapshot.inventory_revision===cap.inventory_revision", self.page)
+        self.assertIn("renderCapabilityTable(merged,{force});", self.page)
+        self.assertIn("if(inventory)renderCapabilityTable(inventory,{force:true});", self.page)
+        self.assertIn("capabilityLastGoodAt=Date.now()", self.page)
+        self.assertIn("setCapabilityAvailability('unavailable'", self.page)
+        self.assertIn("setCapabilityAvailability('stale'", self.page)
+        self.assertIn("capabilityEvidenceState!=='current'", self.page)
+        self.assertIn("Confirmation closed", self.page)
+        self.assertIn("if(capabilitySort==='returned')capabilitySort='use'", self.page)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_dashboard_tour.py b/tests/test_dashboard_tour.py
new file mode 100644
index 00000000..7d19916f
--- /dev/null
+++ b/tests/test_dashboard_tour.py
@@ -0,0 +1,430 @@
+import unittest
+import shutil
+import time
+from tests.dashboard_layout_support import DashboardLayoutCase
+
+
+class DashboardTourLayoutTests(DashboardLayoutCase):
+    def test_leaving_the_tour_through_a_link_offers_a_way_back(self):
+        self.assertIn('<button class="deckPrimary tourReturn" id=tour-return type=button hidden>', self.page)
+        self.assertIn("@media(prefers-reduced-motion:reduce){.tourReturn,.tourReturnArrow{animation:none}}", self.page)
+        self.assertIn("@keyframes tourReturnIn{from{transform:translateY(16px) scale(.94)}to{transform:none}}", self.page, "never starts invisible")
+        self.assertIn("const TOUR_RETURN_KEY='tm_tour_return';", self.page)
+        self.assertIn("$('tour-return').onclick=returnToTour;\nrestoreTourReturn();", self.page)
+        self.assertIn("value.host==='learn'?'Back to Learn':'Back to the tour'", self.page)
+        self.assertIn("const from={index:deckHosts.learn.index,hash:location.hash,host:'learn'};", self.page)
+        self.assertIn("if(tourReturn?.host==='learn'&&(h==='learn'||h==='learn-agent-access'))showTourReturn(null);", self.page)
+        self.assertIn("if(route){openDeckRoute(route,target);if(from)showTourReturn(from);}", self.page)
+        self.assertIn("$('tour-return').onclick=returnToTour;", self.page)
+        self.assertIn("window.addEventListener('popstate',()=>{if(tourReturn&&location.hash===tourReturn.hash)returnToTour();});", self.page)
+        self.assertIn(" showTourReturn(null);\n const start=welcomeStartSlide(index);", self.page)
+
+    def test_sessions_all_spend_learn_and_settings_are_first_class_routes(self):
+        for marker in (
+            "id=session-scope-tabs", "id=session-scope-current", "id=session-scope-all",
+            "id=tab-subagents", "id=view-subagents", "id=all-session-history",
+            "id=subagent-explorer", "id=tab-daily", "id=view-daily",
+            "id=tab-learn", "id=view-learn", "id=tab-settings", "id=view-settings",
+        ):
+            self.assertIn(marker, self.page)
+        for removed in (
+            "id=tab-global", "id=view-global", "data-global-panel",
+            "id=tab-budgets", "id=view-budgets", "id=tab-logs", "id=view-logs",
+        ):
+            self.assertNotIn(removed, self.page)
+        self.assertIn("const legacyGlobal=h==='global'||h==='global-logs'", self.page)
+        self.assertIn("if(h==='logs'||legacyGlobal)", self.page)
+        self.assertIn("'/#sessions-all'", self.page)
+        self.assertIn("function openSessionScope(scope", self.page)
+        self.assertIn("function setSessionScope(scope)", self.page)
+        self.assertIn('class="tabs sessionScopeTabs"', self.page)
+        self.assertIn('<span class=tabLabel>Current sessions</span>', self.page)
+        self.assertIn('<span class=tabLabel>All sessions</span>', self.page)
+        self.assertIn('<span class=tabLabel>Subagents</span>', self.page)
+        self.assertIn("h==='sessions-subagents'", self.page)
+        self.assertIn("live · updated ${new Date(generatedAt*1000).toLocaleTimeString", self.page)
+        self.assertLess(self.page.index("id=tab-session"), self.page.index("id=tab-daily"))
+        self.assertIn("id=s-range", self.page)
+        self.assertNotIn("id=learn-glossary", self.page)
+        self.assertIn("Compare: change one thing, run again.", self.page)
+        self.assertIn("if(h==='daily')setHashRoute('spend',{replace:true,apply:false})", self.page)
+        self.assertIn("if(h==='spend'||h==='daily'||h==='spend-budgets'||h==='spend-discounts'||h==='settings-budgets'||h==='budgets')", self.page)
+        self.assertIn("if(h==='learn'||h==='learn-agent-access')", self.page)
+        self.assertIn("if(h==='settings-budgets'||h==='budgets')setHashRoute('spend-budgets',{replace:true,apply:false})", self.page)
+        self.assertNotIn("setHashRoute('settings-budgets'", self.page)
+        self.assertIn("activeTop.scrollIntoView({block:'nearest',inline:'center'})", self.page)
+
+    def test_read_action_opens_tokenomics_before_learn_without_becoming_a_route(self):
+        secondary = self.page.split("<div class=navSecondary>", 1)[1].split(
+            "</div>", 1
+        )[0]
+        self.assertIn("id=tab-read", secondary)
+        self.assertLess(secondary.index("id=tab-read"), secondary.index("id=tab-learn"))
+        self.assertIn(
+            "$('tab-read').onclick=()=>window.open(TOKENOMICS_SEARCH_URL,'_blank','noopener')",
+            self.page,
+        )
+        commands = self.page.split("const NAV_COMMANDS=[", 1)[1].split("];", 1)[0]
+        self.assertNotIn("id:'read'", commands)
+        self.assertNotIn("route:'read'", self.page)
+
+    def test_onboarding_checklist_and_lesson_dialog_are_retired(self):
+        current = self.page.split('<div class="view on" id=view-session>', 1)[1].split(
+            '<div class=view id=view-models>', 1
+        )[0]
+        for retired in (
+            "id=onboarding-card", "id=onboarding-toggle", "id=onboarding-progress",
+            "id=onboarding-next", "id=onboarding-checklist", "id=onboarding-dialog",
+            "id=learn-onboarding-status", "id=learn-onboarding-action",
+            "First five minutes", "Closing this lesson marks the step complete",
+        ):
+            self.assertNotIn(retired, self.page)
+        self.assertNotIn(">Collapse<", current)
+        for retired in (
+            "ONBOARDING_STEPS", "function renderOnboarding(", "function commitOnboardingSteps(",
+            "function openOnboardingLesson(", "function resumeOrRestartOnboarding(",
+            "onboardingCard", "onboardingDialog", "learnOnboarding", "action:'onboarding'",
+        ):
+            self.assertNotIn(retired, self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_registry_has_twelve_page_named_slides_in_four_chapters(self):
+        payload = self._run_tour("""
+process.stdout.write(JSON.stringify({
+ chapters:DECK_CHAPTERS.map(c=>c.title),
+ slides:DECK_SLIDES.map(s=>[s.chapter,s.id]),
+ complete:DECK_SLIDES.every(s=>['rail','kicker','title'].every(k=>typeof s[k]==='string'&&s[k].trim())&&(s.body===undefined||typeof s.body==='string'&&s.body.trim())&&(!!s.frame!==(typeof s.visual==='function'))),
+ frames:DECK_SLIDES.filter(s=>s.frame).every(s=>typeof s.frame.html==='function'&&s.frame.html.length===0&&s.frame.label&&s.frame.alt&&Array.isArray(s.frame.legend)),
+ time:[deckTimeLeft(0),deckTimeLeft(6),deckTimeLeft(10),deckTimeLeft(11)],
+}));
+""")
+        self.assertEqual(payload["chapters"], ["The basics", "While you work", "Review and find waste", "Do better"])
+        self.assertEqual(payload["slides"], [
+            ["basics", "tokens"], ["basics", "prices"],
+            ["work", "context"], ["work", "glance"], ["work", "compare"],
+            ["review", "month"], ["review", "models"], ["review", "efficiency"], ["review", "tools"], ["review", "helpers"],
+            ["better", "agent"], ["better", "start"],
+        ])
+        self.assertTrue(payload["complete"], "each slide has copy and exactly one visual: a frame or a list")
+        self.assertTrue(payload["frames"], "frame markup takes no arguments, so no live value can reach it")
+        self.assertEqual(payload["time"], ["about 4 min", "about 2 min left", "under a minute left", "under a minute left"])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_copy_stays_within_slide_word_budgets(self):
+        # Less text, more explaining: the frame and its numbered legend carry the idea. Node reports
+        # no known platform here, so the longest companion wording is counted.
+        payload = self._run_tour("""
+const words=text=>String(text||'').split(/\\s+/).filter(word=>/[A-Za-z0-9$]/.test(word)).length;
+const sentences=text=>String(text||'').split(/[.!?](?:\\s|$)/).filter(part=>part.trim()).length;
+process.stdout.write(JSON.stringify(DECK_SLIDES.map(s=>({id:s.id,title:words(s.title),body:words(s.body),
+ bodySentences:sentences(s.body),legend:(s.frame?.legend||[]).map(words),links:(s.links||[]).length,frame:!!s.frame}))));
+""")
+        self.assertEqual(len(payload), 12)
+        for row in payload:
+            with self.subTest(slide=row["id"]):
+                self.assertLessEqual(row["title"], 8, "headline")
+                self.assertLessEqual(row["body"], 14, "body")
+                self.assertLessEqual(row["bodySentences"], 1, "body is one sentence or none")
+                self.assertLessEqual(row["links"], 1, "at most one action link")
+                if row["frame"]:
+                    self.assertGreaterEqual(len(row["legend"]), 1)
+                    self.assertLessEqual(len(row["legend"]), 3, "at most three legend lines")
+                    for count in row["legend"]:
+                        self.assertLessEqual(count, 12, "legend line")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_frames_are_labeled_examples_with_matching_callouts(self):
+        payload = self._run_tour("""
+process.stdout.write(JSON.stringify(frameSlides.map(({slide,index})=>{
+ const html=deckVisualHtml(index,'learn');
+ const stage=html.split('<div class=conceptFrameStage role=img aria-label="')[1]?.split('<figcaption>')[0]||'';
+ const legend=html.split('<figcaption>')[1]||'';
+ const markers=[...stage.matchAll(/<mark class=frameCallout(?: data-at=\\w+)? aria-hidden=true>(\\d)<\\/mark>/g)].map(m=>Number(m[1]));
+ const keys=[...legend.matchAll(/<li><mark class=frameCallout aria-hidden=true>(\\d)<\\/mark><span>/g)].map(m=>Number(m[1]));
+ return {id:slide.id,figure:html.startsWith('<figure class=conceptFrame')&&html.endsWith('</figure>'),
+  example:(html.match(/<span class=chip>Example<\\/span>/g)||[]).length,
+  head:html.includes('<div class=conceptFrameHead><span>'),alt:/^[^"<>]{12,}"/.test(stage),
+  markers:markers.sort(),keys,orderedList:legend.startsWith('<ol class=frameLegend role=list>'),
+  allMarkersHidden:(html.match(/class=frameCallout/g)||[]).length===(html.match(/class=frameCallout(?: data-at=\\w+)? aria-hidden=true>/g)||[]).length};
+})));
+""")
+        self.assertEqual(len(payload), 11)
+        for row in payload:
+            with self.subTest(frame=row["id"]):
+                self.assertTrue(row["figure"])
+                self.assertEqual(row["example"], 1, "one Example chip per frame, so nobody mistakes it for their numbers")
+                self.assertTrue(row["head"])
+                self.assertTrue(row["alt"], "the frame is one described image for screen readers")
+                self.assertTrue(row["orderedList"], "the legend is an ordered list")
+                self.assertTrue(row["allMarkersHidden"], "markers are visual; the legend carries the words")
+                count = len(row["keys"])
+                self.assertGreaterEqual(count, 1)
+                self.assertLessEqual(count, 3)
+                self.assertEqual(row["keys"], list(range(1, count + 1)))
+                self.assertEqual(row["markers"], list(range(1, count + 1)), "each legend number appears once on the frame")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_frames_never_show_live_numbers_or_talk_comparisons(self):
+        payload = self._run_tour("""
+const facts=[deckFacts({}),deckFacts(richState),deckFacts(null),deckFacts({xsession:{budget:{configured:true,budget:0}}})];
+const all=DECK_SLIDES.map((slide,i)=>facts.map(state=>deckCopyHtml(i,state,'learn')+deckVisualHtml(i,'learn')).join('')).join('');
+process.stdout.write(JSON.stringify({
+ facts,
+ visualsStable:DECK_SLIDES.every((slide,i)=>deckVisualHtml(i,'learn')===deckVisualHtml(i,'learn')),
+ copyStable:DECK_SLIDES.map((slide,i)=>new Set(facts.map(state=>deckCopyHtml(i,state,'learn'))).size),
+ personal:['2,179','2179','1,792','1792','8,940','8940','83,907','83907','38.59','claude-opus-5-5','gpt-5.6-sol'].filter(value=>all.includes(value)),
+ talk:['Yours','From the talk','talkChip','yoursChip','engineer’s laptop','$31.14','6% → 55%','83,907','5.1×'].filter(value=>all.includes(value)),
+}));
+""")
+        self.assertEqual(payload["facts"], [
+            {"budgetConfigured": False}, {"budgetConfigured": True},
+            {"budgetConfigured": False}, {"budgetConfigured": False},
+        ])
+        self.assertTrue(payload["visualsStable"])
+        self.assertEqual(payload["copyStable"], [1] * 11 + [2], "only the last slide's call to action reads live state")
+        self.assertEqual(payload["personal"], [], "frames carry sample values, never the user's numbers")
+        self.assertEqual(payload["talk"], [], "the deck explains concepts; no Yours or From the talk comparisons")
+        for retired in (
+            "learnEvidence", "learnOutputTrend", "figureHtml", "evidenceFigure", "TALK_CHIP", "YOURS_CHIP",
+            "TALK_NOTE", "TALK_OUTPUT_MONTHS", "talkChip", "yoursChip", "leverValue", "miniPreview",
+            "class=takeaway", "WELCOME_HOST", "deckPreviewHtml",
+        ):
+            self.assertNotIn(retired, self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_both_tour_hosts_render_the_same_slides(self):
+        payload = self._run_tour("""
+const facts=[deckFacts({}),deckFacts(richState)];
+const same=DECK_SLIDES.map((slide,i)=>facts.every(state=>
+ deckCopyHtml(i,state,'welcome').replaceAll('welcome-','HOST-')===deckCopyHtml(i,state,'learn').replaceAll('learn-','HOST-')&&
+ deckVisualHtml(i,'welcome').replaceAll('welcome-','HOST-')===deckVisualHtml(i,'learn').replaceAll('learn-','HOST-')));
+const agent=DECK_SLIDES.findIndex(slide=>slide.id==='agent'),last=DECK_SLIDES.length-1;
+process.stdout.write(JSON.stringify({same,agentAnchor:deckVisualHtml(agent,'learn').includes(' id=learn-agent-access>'),
+ cta:[deckCopyHtml(last,facts[0],'welcome').includes('>Set a monthly budget<'),deckCopyHtml(last,facts[1],'welcome').includes('>Review your budget<')]}));
+""")
+        self.assertEqual(payload["same"], [True] * 12)
+        self.assertTrue(payload["agentAnchor"])
+        self.assertEqual(payload["cta"], [True, True])
+        dialog = self.page.split("<dialog class=welcome id=welcome-dialog", 1)[1].split("</dialog>", 1)[0]
+        learn = self.page.split("<div class=view id=view-learn>", 1)[1].split("<div class=view id=view-capabilities>", 1)[0]
+        self.assertIn('<div class=deck id=welcome-deck data-deck-host=welcome></div>', dialog)
+        self.assertIn('<div class="deck deckInline" id=learn-deck data-deck-host=learn></div>', learn)
+        for host in (dialog, learn):
+            self.assertNotIn("<h2", host, "slide copy lives in DECK_SLIDES, not in host markup")
+            self.assertNotIn("conceptFrame", host)
+        self.assertIn("function renderWelcome(state=LATEST){paintDeck('welcome',state);}", self.page)
+        self.assertIn("if(ensureDeck('learn'))paintDeck('learn',state);", self.page)
+        self.assertIn("paintPreview(`${host}-deck-visual`,deckVisualHtml(current.index,host));", self.page)
+        for retired in ("WELCOME_PANELS", "data-welcome-panel", "learnQuestion", "learnBlock", "learn-replay-welcome", "welcomeDot"):
+            self.assertNotIn(retired, self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_keeps_privacy_estimate_and_agent_caveats(self):
+        payload = self._run_tour("""
+const legend=id=>DECK_SLIDES.find(slide=>slide.id===id).frame.legend.join(' ');
+process.stdout.write(JSON.stringify({tokens:legend('tokens'),privacy:DECK_SLIDES.find(slide=>slide.id==='tokens').body,agent:legend('agent'),
+ agentBody:DECK_SLIDES.find(slide=>slide.id==='agent').body,glance:DECK_SLIDES.find(slide=>slide.id==='glance').body,
+ places:['mac','windows','linux','other'].map(id=>({mac:'menu bar',windows:'notification area',linux:'tray'}[id]||'menu bar or tray'))}));
+""")
+        self.assertIn("estimate", payload["tokens"])
+        self.assertIn("not your bill", payload["tokens"])
+        self.assertIn("on your computer", payload["privacy"])
+        self.assertIn("never uploaded", payload["privacy"])
+        self.assertIn("numbers only, never your prompts or code", payload["agent"])
+        self.assertIn("session-budget changes need your OK", payload["agent"])
+        self.assertIn("AI provider sees those numbers", payload["agent"])
+        self.assertIn("(MCP)", payload["agentBody"])
+        self.assertEqual(payload["glance"], "It sits in your menu bar or tray, always on.")
+        self.assertIn("const COMPANION_PLACE={mac:'menu bar',windows:'notification area',linux:'tray'}[DECK_PLATFORM]||'menu bar or tray';", self.page)
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_escapes_every_interpolated_label(self):
+        payload = self._run_tour("""
+const bad='<img src=x onerror=alert(1)>';
+const frame=conceptFrameHtml({kind:'x',label:bad,alt:`"${bad}`,legend:[bad,bad],html:()=>''},'learn');
+const habits=HABITS.map(habit=>({...habit}));HABITS.length=0;HABITS.push({icon:'model',title:bad,page:bad,route:'models'});
+const list=habitsListHtml();HABITS.length=0;habits.forEach(habit=>HABITS.push(habit));
+const copy=DECK_SLIDES.map((slide,i)=>deckCopyHtml(i,deckFacts(richState),'learn')+deckVisualHtml(i,'learn')+deckResumeHtml(i,'learn')).join('');
+process.stdout.write(JSON.stringify({frame:frame.includes('<img'),quote:frame.includes('aria-label=""'),list:list.includes('<img'),copy:copy.includes('<img')}));
+""")
+        self.assertEqual(payload, {"frame": False, "quote": False, "list": False, "copy": False})
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_rail_states_and_skip_chapter_targets(self):
+        payload = self._run_tour("""
+const rail=deckRailHtml(6);
+process.stdout.write(JSON.stringify({
+ skip:DECK_SLIDES.map((_,i)=>deckChapterSkipTarget(i)),
+ steps:[...rail.matchAll(/data-deck-go=(\\d+) data-state=(\\w+)/g)].map(m=>m[2]),
+ chapters:[...rail.matchAll(/class=deckChapter data-state=(\\w+)/g)].map(m=>m[1]),
+ current:(rail.match(/aria-current=step/g)||[]).length,
+ glyphs:[rail.includes('aria-hidden=true>✓</i>'),rail.includes('aria-hidden=true>●</i>'),rail.includes('aria-hidden=true>○</i>')],
+}));
+""")
+        self.assertEqual(payload["skip"], [2, 2, 5, 5, 5, 10, 10, 10, 10, 10, -1, -1])
+        self.assertEqual(payload["steps"], ["done"] * 6 + ["current"] + ["upcoming"] * 5)
+        self.assertEqual(payload["chapters"], ["done", "done", "current", "upcoming"])
+        self.assertEqual(payload["current"], 1)
+        self.assertEqual(payload["glyphs"], [True, True, True])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_welcome_resume_and_auto_show_matrix(self):
+        payload = self._run_tour("""
+function run(entries,{read=false,write=false,requested=null,act=null}={}){
+ stored=new Map(entries);blocked={read,write};
+ const auto=welcomeShouldAutoShow(),start=welcomeStartSlide(requested);
+ if(act)act();
+ let saved=null;try{saved=JSON.parse(stored.get(WELCOME_KEY));}catch(error){}
+ const legacyKept=stored.has(LEGACY_ONBOARDING_KEY);
+ let after=null;if(!read&&!write){markWelcomeSeen(0);after=welcomeShouldAutoShow();}
+ return {auto,start,saved:saved&&{seen:saved.seen,stamped:Number(saved.dismissed_at)>0,last_slide:saved.last_slide},legacyKept,after};
+}
+const welcome=value=>[[WELCOME_KEY,typeof value==='string'?value:JSON.stringify(value)]];
+const legacy=value=>[[LEGACY_ONBOARDING_KEY,JSON.stringify(value)]];
+process.stdout.write(JSON.stringify({
+ fresh:run([],{act:()=>markWelcomeSeen(0)}),
+ progressing:run([],{act:()=>recordWelcomeSlide(4)}),
+ resume:run(welcome({seen:true,dismissed_at:1,last_slide:6})),
+ midTourReload:run(welcome({seen:false,last_slide:3})),
+ explicit:run(welcome({seen:true,dismissed_at:1,last_slide:6}),{requested:2}),
+ finished:run(welcome({seen:true,dismissed_at:1,last_slide:0})),
+ outOfRange:run(welcome({seen:true,dismissed_at:1,last_slide:99})),
+ negative:run(welcome({seen:true,dismissed_at:1,last_slide:-2})),
+ fractional:run(welcome({seen:true,dismissed_at:1,last_slide:2.5})),
+ corrupt:run(welcome('{nope')),
+ seenKeepsSeen:run(welcome({seen:true,dismissed_at:5,last_slide:1}),{act:()=>recordWelcomeSlide(8)}),
+ closeAt:run([],{act:()=>markWelcomeSeen(7)}),
+ legacyStep:run(legacy({completed:['current'],collapsed:false,completed_at:0})),
+ legacyCollapsed:run(legacy({completed:[],collapsed:true,completed_at:0})),
+ legacyFinished:run(legacy({completed:[],collapsed:false,completed_at:1700000000000})),
+ legacyUntouched:run(legacy({completed:[],collapsed:false,completed_at:0})),
+ readBlocked:run([],{read:true,act:()=>{recordWelcomeSlide(3);markWelcomeSeen(3);}}),
+ writeBlocked:run([],{write:true,act:()=>{recordWelcomeSlide(3);markWelcomeSeen(3);saveLearnSlide(3);}}),
+ learn:(()=>{stored=new Map([[LEARN_SLIDE_KEY,'9']]);blocked={read:false,write:false};const a=readLearnSlide();stored.set(LEARN_SLIDE_KEY,'x');const b=readLearnSlide();blocked.read=true;const c=readLearnSlide();return [a,b,c];})(),
+}));
+""")
+        start = lambda index, offer: {"index": index, "offer": offer}
+        self.assertEqual(payload["fresh"]["saved"], {"seen": True, "stamped": True, "last_slide": 0})
+        self.assertTrue(payload["fresh"]["auto"])
+        self.assertEqual(payload["fresh"]["start"], start(0, False))
+        for case in ("fresh", "legacyStep", "legacyUntouched", "corrupt", "resume"):
+            with self.subTest(after=case):
+                self.assertFalse(payload[case]["after"], "a seen tour never auto-shows again")
+        for case in ("legacyStep", "legacyCollapsed", "legacyFinished", "legacyUntouched"):
+            with self.subTest(legacy=case):
+                self.assertTrue(payload[case]["legacyKept"], "the legacy onboarding key stays readable")
+        self.assertEqual(payload["progressing"]["saved"], {"seen": False, "stamped": False, "last_slide": 4})
+        self.assertEqual(payload["resume"]["start"], start(6, True))
+        self.assertFalse(payload["resume"]["auto"])
+        self.assertTrue(payload["midTourReload"]["auto"], "a tour never closed reopens on the next launch")
+        self.assertEqual(payload["midTourReload"]["start"], start(3, True))
+        self.assertEqual(payload["explicit"]["start"], start(2, False))
+        for case in ("finished", "outOfRange", "negative", "fractional", "corrupt"):
+            with self.subTest(case=case):
+                self.assertEqual(payload[case]["start"], start(0, False))
+        self.assertTrue(payload["corrupt"]["auto"])
+        self.assertEqual(payload["seenKeepsSeen"]["saved"], {"seen": True, "stamped": True, "last_slide": 8})
+        self.assertEqual(payload["closeAt"]["saved"], {"seen": True, "stamped": True, "last_slide": 7})
+        for case in ("legacyStep", "legacyCollapsed", "legacyFinished"):
+            with self.subTest(case=case):
+                self.assertFalse(payload[case]["auto"])
+        self.assertTrue(payload["legacyUntouched"]["auto"])
+        self.assertEqual(payload["readBlocked"]["auto"], False)
+        self.assertEqual(payload["readBlocked"]["start"], start(0, False))
+        self.assertEqual(payload["writeBlocked"]["auto"], True)
+        self.assertEqual(payload["writeBlocked"]["start"], start(0, False))
+        self.assertIsNone(payload["writeBlocked"]["saved"])
+        self.assertEqual(payload["learn"], [9, 0, 0])
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_tour_controls_page_skip_chapters_and_close_the_overlay(self):
+        payload = self._run_tour(f"""
+function extract(name){{let s=page.indexOf(`function ${{name}}(`);if(s<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',s)+1,d=0;for(;i<page.length;i++){{if(page[i]==='{{')d++;else if(page[i]==='}}'&&--d===0)return page.slice(s,i+1);}}}}
+const els={{}};
+var document={{activeElement:null,querySelector:()=>null}};
+var $=id=>els[id]||(els[id]={{id,dataset:{{}},innerHTML:'',textContent:'',hidden:false,disabled:false,className:'',scrollTop:0,open:false,contains:()=>false,querySelector:()=>null,focus(){{}},scrollIntoView(){{}},close(){{this.open=false;closed.push(this.id);}}}});
+var requestAnimationFrame=fn=>fn(),deliveryPayload=null,closed=[],routes=[];
+var openTopLevelRoute=route=>routes.push(route),location={{hash:'#sessions'}},tourReturn=null;
+eval(['paintPreview','deckShellHtml','ensureDeck','paintDeck','showDeckSlide','openDeckRoute','deckAction','closeWelcome','showTourReturn','deckKey'].map(extract).join('\\n'));
+eval(page.slice(page.indexOf('const deckHosts='),page.indexOf(';',page.indexOf('const deckHosts='))+1).replace(/^const /,'var '));
+const log=[];
+showDeckSlide('welcome',0);log.push(deckHosts.welcome.index);
+deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
+deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
+deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
+const skipDisabled=$('welcome-deck-skip-chapter').disabled;
+deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
+deckAction('welcome','back');log.push(deckHosts.welcome.index);
+const recorded=JSON.parse(stored.get(WELCOME_KEY)).last_slide;
+const arrows=[];const key=k=>({{key:k,preventDefault(){{}},target:null}});
+deckKey('welcome',key('ArrowRight'));arrows.push(deckHosts.welcome.index);deckKey('welcome',key('ArrowLeft'));arrows.push(deckHosts.welcome.index);
+showDeckSlide('welcome',13);const doneLabel=[$('welcome-deck-next').textContent,$('welcome-deck-next').className];
+$('welcome-dialog').open=true;deckAction('welcome','next');
+showDeckSlide('learn',13);const learnLast=$('learn-deck-next').textContent;deckAction('learn','next');
+showDeckSlide('welcome',5,{{offer:true}});const offerFoot=$('welcome-deck-foot').hidden,offerStage=$('welcome-deck-stage').innerHTML;
+deckAction('welcome','restart');
+$('welcome-dialog').open=true;closeWelcome({{route:'settings',target:'agent-access'}});
+process.stdout.write(JSON.stringify({{log,skipDisabled,recorded,arrows,doneLabel,closed,learnAfterLast:deckHosts.learn.index,learnLast,offerFoot,offerResume:offerStage.includes('data-deck-action=resume')&&offerStage.includes('data-deck-action=restart'),afterRestart:[deckHosts.welcome.index,deckHosts.welcome.offer],routes,counter:$('welcome-deck-count').textContent}}));
+""")
+        self.assertEqual(payload["log"], [0, 2, 5, 10, 10, 9])
+        self.assertTrue(payload["skipDisabled"])
+        self.assertEqual(payload["recorded"], 9)
+        self.assertEqual(payload["arrows"], [10, 9])
+        self.assertEqual(payload["doneLabel"], ["Done", "tbtn"])
+        self.assertEqual(payload["closed"], ["welcome-dialog", "welcome-dialog"])
+        self.assertEqual(payload["learnLast"], "Back to start")
+        self.assertEqual(payload["learnAfterLast"], 0)
+        self.assertTrue(payload["offerFoot"])
+        self.assertTrue(payload["offerResume"])
+        self.assertEqual(payload["afterRestart"], [0, False])
+        self.assertEqual(payload["routes"], ["settings"])
+        self.assertEqual(payload["counter"], "1 / 12 · about 4 min")
+
+    def test_welcome_overlay_and_learn_deck_shells(self):
+        dialog = self.page.split("<dialog class=welcome id=welcome-dialog", 1)[1].split("</dialog>", 1)[0]
+        self.assertIn("aria-modal=true", dialog)
+        self.assertIn("aria-labelledby=welcome-label", dialog)
+        self.assertIn('<button class=welcomeClose id=welcome-close type=button aria-label="Close welcome"', dialog)
+        self.assertIn("aria-hidden=true>&#10005;</span>", dialog)
+        self.assertIn("id=welcome-skip type=button>Skip tour</button>", dialog)
+        for marker in (
+            "$('welcome-close').onclick=()=>closeWelcome();",
+            "$('welcome-skip').onclick=()=>closeWelcome();",
+            "$('welcome-dialog').addEventListener('cancel',event=>{event.preventDefault();closeWelcome();});",
+            "markWelcomeSeen(index>=DECK_SLIDES.length-1?0:index);",
+            "if($('welcome-dialog').open){handleWelcomeKey(event);return;}",
+            "handleLearnDeckKey(event);",
+            "if(welcomeShouldAutoShow())openWelcome(null,{auto:true});",
+            "data-deck-action=skip-chapter>Skip chapter</button>",
+            "{id:'welcome',label:'Open welcome tour'",
+            "if(command.action==='welcome'){const returnFocus=commandReturnFocus;commandReturnFocus=null;openWelcome(null,{returnFocus});return;}",
+            "$('learn-play').onclick=()=>openWelcome(deckHosts.learn.index,{fromLearn:true});",
+            "if(h==='learn-agent-access')showDeckSlide('learn',DECK_SLIDES.findIndex(slide=>slide.id==='agent'),{animate:false});",
+        ):
+            self.assertIn(marker, self.page)
+        self.assertIn("maybeAutoShowWelcome();", self.page.split("function applyLiveState(state){", 1)[1].split("\n}", 1)[0])
+        learn = self.page.split("<div class=view id=view-learn>", 1)[1].split("<div class=view id=view-capabilities>", 1)[0]
+        self.assertIn("<h1>Learn</h1>", learn)
+        self.assertIn("<p class=spectrumPageSubtitle>Spend tokens like money. Measure what you get back.</p>", learn)
+        self.assertIn("id=learn-play type=button>Play as full screen</button>", learn)
+        self.assertNotIn("learnSection", learn)
+        css = self.page[self.page.index("<style>"):self.page.index("</style>")]
+        self.assertIn(".welcome{", css)
+        self.assertRegex(css, r"@media\(prefers-reduced-motion:reduce\)\{[^\n]*\.deckEnter")
+        self.assertIn(".deck{display:grid;grid-template-columns:212px minmax(0,1fr)", css)
+        self.assertIn("const TOKENOMICS_URL='https://www.splunk.com/en_us/products/tokenomics.html';", self.page)
+        self.assertIn('target=_blank rel="noopener noreferrer">Read about Tokenomics', self.page)
+
+    def test_learn_omits_removed_model_and_agent_guidance(self):
+        for marker in (
+            "id=learn-model-guide",
+            "Compare model speed without fooling yourself",
+            "Should I keep this run going?",
+            "Why was the last phase expensive?",
+            "What should I change before the next phase?",
+        ):
+            self.assertNotIn(marker, self.page)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_health_quota.py b/tests/test_health_quota.py
new file mode 100644
index 00000000..3375104a
--- /dev/null
+++ b/tests/test_health_quota.py
@@ -0,0 +1,841 @@
+import unittest
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest import mock
+import meter
+from tests.meter_support import isolated_pricing_state
+
+
+class ProviderQuotaTests(unittest.TestCase):
+    def tearDown(self):
+        meter.reset_provider_quota_cache()
+
+    def test_pace_forecast_distinguishes_runout_reserve_and_early_window(self):
+        now = 1_000_000.0
+        base = {"window_seconds": 1000, "reset_at": now + 500}
+
+        runout = meter.quota_pace({**base, "used_percent": 70}, now=now)
+        reserve = meter.quota_pace({**base, "used_percent": 30}, now=now)
+        on_pace = meter.quota_pace({**base, "used_percent": 50}, now=now)
+        early = meter.quota_pace({"window_seconds": 1000, "reset_at": now + 980,
+                                  "used_percent": 20}, now=now)
+
+        self.assertEqual(runout["state"], "deficit")
+        self.assertFalse(runout["will_last_to_reset"])
+        self.assertIn("runs out in", runout["summary"])
+        self.assertEqual(reserve["state"], "reserve")
+        self.assertTrue(reserve["will_last_to_reset"])
+        self.assertEqual(on_pace["state"], "on_pace")
+        self.assertIsNone(early)
+
+    def test_codex_parser_preserves_main_and_named_spark_windows(self):
+        now = 1_000_000.0
+        payload = {
+            "rateLimits": {
+                "planType": "business",
+                "primary": {"usedPercent": 12, "windowDurationMins": 300,
+                            "resetsAt": now + 1800},
+                "secondary": {"usedPercent": 34, "windowDurationMins": 10080,
+                              "resetsAt": now + 3600},
+            },
+            "rateLimitsByLimitId": {
+                "codex-spark": {
+                    "limitName": "GPT-5.3-Codex-Spark",
+                    "primary": {"usedPercent": 56, "windowDurationMins": 300,
+                                "resetsAt": now + 1800},
+                    "secondary": {"usedPercent": 78, "windowDurationMins": 10080,
+                                  "resetsAt": now + 3600},
+                },
+            },
+        }
+
+        result = meter.parse_codex_quota(payload, now=now)
+
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(result["plan"], "business")
+        self.assertEqual(
+            [(row["label"], row["used_percent"]) for row in result["windows"]],
+            [("Session", 12.0), ("Weekly", 34.0),
+             ("Spark session", 56.0), ("Spark weekly", 78.0)],
+        )
+        self.assertEqual(result["coverage_note"], "")
+
+    def test_codex_parser_does_not_fabricate_absent_main_windows(self):
+        result = meter.parse_codex_quota({
+            "rate_limit": {"primary_window": None, "secondary_window": None},
+            "additional_rate_limits": [{
+                "metered_feature": "codex_spark",
+                "limit_name": "GPT-5.3-Codex-Spark",
+                "rate_limit": {
+                    "primary_window": {"used_percent": 4, "limit_window_seconds": 18000,
+                                       "reset_at": 1_001_000},
+                    "secondary_window": {"used_percent": 9, "limit_window_seconds": 604800,
+                                         "reset_at": 1_002_000},
+                },
+            }],
+        }, source="Codex OAuth API", now=1_000_000)
+
+        self.assertEqual([row["label"] for row in result["windows"]],
+                         ["Spark session", "Spark weekly"])
+        self.assertIn("Regular Session and Weekly limits were not reported by Codex",
+                      result["coverage_note"])
+        self.assertIn("missing does not mean 0%", result["coverage_note"])
+
+    def test_codex_app_server_uses_wrapper_safe_launchagent_environment(self):
+        process = mock.Mock()
+        process.stdin = mock.Mock()
+        process.stdout = mock.Mock()
+        process.poll.return_value = 0
+        selector = mock.Mock()
+        with mock.patch.object(meter, "provider_cli_path", return_value="/nvm/bin/codex"), \
+                mock.patch.object(meter, "agent_client_environment", return_value={"PATH": "/nvm/bin"}) as environment, \
+                mock.patch.object(meter.subprocess, "Popen", return_value=process) as popen, \
+                mock.patch.object(meter.selectors, "DefaultSelector", return_value=selector), \
+                mock.patch.object(meter, "_rpc_read_response", side_effect=[{}, {"rateLimits": {}}]):
+            result = meter.codex_app_server_rate_limits()
+
+        environment.assert_called_once_with("/nvm/bin/codex")
+        self.assertEqual(popen.call_args.kwargs["env"], {"PATH": "/nvm/bin"})
+        self.assertEqual(result, {"rateLimits": {}})
+
+    def test_claude_parser_maps_reported_and_scoped_windows(self):
+        now = 1_000_000.0
+        result = meter.parse_claude_quota({
+            "five_hour": {"utilization": 8, "resets_at": now + 3600},
+            "seven_day": {"utilization": 23, "resets_at": now + 7200},
+            "seven_day_opus": {"utilization": 41, "resets_at": now + 7200},
+            "limits": [{
+                "kind": "weekly_scoped", "is_active": True, "percent": 52,
+                "resets_at": now + 7200,
+                "scope": {"model": {"display_name": "Sonnet 4.5"}},
+            }],
+        }, credentials={"subscriptionType": "max"}, now=now)
+
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(result["plan"], "max")
+        self.assertEqual([row["label"] for row in result["windows"]],
+                         ["Session", "Weekly", "Opus weekly", "Sonnet 4.5 weekly"])
+        self.assertEqual(result["coverage_note"], "")
+
+    def test_claude_scoped_weekly_does_not_hide_missing_regular_weekly_limit(self):
+        result = meter.parse_claude_quota({
+            "five_hour": {"utilization": 8, "resets_at": 1_001_000},
+            "limits": [{
+                "kind": "weekly_scoped", "percent": 52, "resets_at": 1_002_000,
+                "scope": {"model": {"display_name": "Sonnet"}},
+            }],
+        }, now=1_000_000)
+
+        self.assertEqual([row["label"] for row in result["windows"]],
+                         ["Session", "Sonnet weekly"])
+        self.assertIn("Weekly limit was not reported by Claude", result["coverage_note"])
+
+    def test_third_party_claude_auth_is_explicitly_unavailable(self):
+        with mock.patch.object(meter, "claude_auth_status", return_value={
+            "loggedIn": True, "authMethod": "third_party", "apiProvider": "bedrock",
+        }), mock.patch.object(meter, "claude_oauth_credentials") as credentials:
+            result = meter.load_claude_quota(now=1_000_000)
+
+        credentials.assert_not_called()
+        self.assertEqual(result["status"], "unavailable")
+        self.assertEqual(result["plan"], "Bedrock")
+        self.assertIn("not exposed", result["error"])
+        self.assertIn("Session and Weekly limits were not reported by Claude",
+                      result["coverage_note"])
+
+    def test_cursor_parser_labels_monthly_individual_cap(self):
+        now = 1_000_000.0
+        result = meter.parse_cursor_quota({
+            "membershipType": "enterprise",
+            "billingCycleStart": now - 1000,
+            "billingCycleEnd": now + 2000,
+            "individualUsage": {
+                "plan": {"used": 0, "limit": 0},
+                "overall": {"used": 987, "limit": 100000},
+            },
+        }, now=now)
+
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(result["windows"][0]["kind"], "monthly")
+        self.assertEqual(result["windows"][0]["label"], "Plan")
+        self.assertAlmostEqual(result["windows"][0]["used_percent"], 0.99, places=2)
+        self.assertEqual(result["windows"][0]["window_seconds"], 3000)
+        self.assertIn("Session and Weekly limits were not reported by Cursor",
+                      result["coverage_note"])
+        self.assertIn("missing does not mean 0%", result["coverage_note"])
+
+    def test_cache_marks_old_provider_data_stale_and_recomputes_pace(self):
+        row = meter.quota_provider("codex", "Codex", "ok", "test", windows=[
+            meter.quota_window("codex", "codex-session", "session", "Session", 50,
+                               window_seconds=1000, reset_at=1_001_000, now=1_000_000),
+        ])
+        with meter._quota_lock:
+            meter._quota_cache["codex"] = {**row, "fetched_at": 1_000_000,
+                                            "attempted_at": 1_000_000}
+
+        result = meter.provider_quota_snapshots(
+            now=1_000_601, loaders={"codex": mock.Mock()}, start_refresh=False,
+        )[0]
+
+        self.assertEqual(result["status"], "stale")
+        self.assertTrue(result["stale"])
+        self.assertEqual(result["age_seconds"], 601)
+
+    def test_empty_cache_returns_loading_and_starts_only_one_worker(self):
+        loader = mock.Mock()
+        worker = mock.Mock()
+        with mock.patch.object(meter.threading, "Thread", return_value=worker) as thread:
+            first = meter.provider_quota_snapshots(now=1_000_000, loaders={"codex": loader})
+            second = meter.provider_quota_snapshots(now=1_000_001, loaders={"codex": loader})
+
+        self.assertEqual(first[0]["status"], "loading")
+        self.assertEqual(second[0]["status"], "loading")
+        thread.assert_called_once()
+        worker.start.assert_called_once()
+
+    def test_refresh_retains_last_good_windows_and_sanitizes_unexpected_errors(self):
+        good = meter.quota_provider("codex", "Codex", "ok", "test", windows=[
+            meter.quota_window("codex", "codex-session", "session", "Session", 44,
+                               window_seconds=1000, reset_at=1_001_000, now=1_000_000),
+        ])
+        meter.refresh_provider_quota("codex", lambda now: good, now=1_000_000)
+
+        def fail(now):
+            raise RuntimeError("secret bearer token")
+
+        result = meter.refresh_provider_quota("codex", fail, now=1_000_100)
+
+        self.assertEqual(result["status"], "error")
+        self.assertEqual(result["windows"][0]["used_percent"], 44.0)
+        self.assertEqual(result["fetched_at"], 1_000_000)
+        self.assertEqual(result["attempted_at"], 1_000_100)
+        self.assertEqual(result["error"], "Provider quota refresh failed.")
+        self.assertNotIn("secret", result["error"])
+
+
+class HealthStateTests(unittest.TestCase):
+    def test_health_uses_cached_inventory_without_discovering_sessions(self):
+        inventory = {
+            "ready": True,
+            "sources": (),
+            "count": 2400,
+            "clients": {"codex": 2300, "claude_code": 100},
+            "updated_at": 1,
+        }
+        with mock.patch.object(meter, "STATE", {"source": {"id": "ready"}}), \
+                mock.patch.object(meter, "_SOURCE_INVENTORY", inventory), \
+                mock.patch.object(meter, "page_path", return_value="/runtime/page.html"), \
+                mock.patch.object(
+                    meter, "all_session_sources",
+                    side_effect=AssertionError("health must not discover sessions"),
+                ):
+            payload, status = meter.health_state()
+
+        self.assertEqual(status, 200)
+        self.assertTrue(payload["ok"])
+        self.assertTrue(payload["state_ready"])
+        self.assertTrue(payload["inventory_ready"])
+        self.assertEqual(payload["sources"], 2400)
+        self.assertEqual(payload["source_clients"], {"codex": 2300, "claude_code": 100})
+
+    def test_health_never_exposes_local_paths(self):
+        page = os.path.join(os.path.expanduser("~"), "Library", "Token Meter", "runtime", "page.html")
+        candidates = [page, "/opt/token-meter/page.html"]
+        for found in (page, None):
+            with self.subTest(page_found=bool(found)), \
+                    mock.patch.object(meter, "STATE", {}), \
+                    mock.patch.object(meter, "page_path", return_value=found), \
+                    mock.patch.object(meter, "PAGE_CANDIDATES", candidates):
+                payload, status = meter.health_state()
+            self.assertNotIn("page_path", payload)
+            self.assertNotIn("page_candidates", payload)
+            text = json.dumps(payload)
+            for fragment in (os.path.expanduser("~"), "page.html", "/opt/token-meter"):
+                self.assertNotIn(fragment, text)
+            self.assertEqual(payload["page_ready"], bool(found))
+            self.assertEqual(status, 200 if found else 503)
+
+    def test_health_answers_runtime_ownership_without_revealing_the_path(self):
+        with tempfile.TemporaryDirectory() as directory:
+            runtime = os.path.join(directory, "runtime")
+            os.makedirs(runtime)
+            page = os.path.join(runtime, "page.html")
+            cases = (
+                (runtime, page, True),
+                (runtime + os.sep, page, True),
+                (os.path.join(directory, "other"), page, False),
+                (runtime + "-old", page, False),
+                (runtime, None, False),
+                ("relative/runtime", page, False),
+                ("x" * 5000, page, False),
+            )
+            for expected, found, owned in cases:
+                with self.subTest(expected=expected[:40], found=bool(found)), \
+                        mock.patch.object(meter, "STATE", {}), \
+                        mock.patch.object(meter, "page_path", return_value=found):
+                    payload, _ = meter.health_state(expected_runtime=expected)
+                self.assertIs(payload["runtime_matches"], owned)
+                self.assertNotIn(directory, json.dumps(payload))
+            with mock.patch.object(meter, "STATE", {}), \
+                    mock.patch.object(meter, "page_path", return_value=page):
+                self.assertNotIn("runtime_matches", meter.health_state()[0])
+
+    def test_health_route_reads_one_runtime_query_value(self):
+        def get(query):
+            handler = object.__new__(meter.H)
+            handler.path = "/health" + query
+            handler.headers = {"Host": "127.0.0.1:8722"}
+            handler._send = mock.Mock()
+            handler.send_error = mock.Mock()
+            with mock.patch.object(meter, "health_state", return_value=({"ok": True}, 200)) as health:
+                handler.do_GET()
+            return health.call_args
+
+        self.assertEqual(get(""), mock.call(expected_runtime=None))
+        self.assertEqual(get("?runtime=%2Fopt%2Ftm"), mock.call(expected_runtime="/opt/tm"))
+        self.assertEqual(get("?runtime=a&runtime=b"), mock.call(expected_runtime=""))
+
+    def test_health_marks_undiscovered_inventory_unavailable_instead_of_zero(self):
+        inventory = {
+            "ready": False, "sources": (), "count": None, "clients": {}, "updated_at": None,
+        }
+        with mock.patch.object(meter, "STATE", {}), \
+                mock.patch.object(meter, "_SOURCE_INVENTORY", inventory), \
+                mock.patch.object(meter, "page_path", return_value="/runtime/page.html"):
+            payload, status = meter.health_state()
+
+        self.assertEqual(status, 200)
+        self.assertTrue(payload["ok"])
+        self.assertFalse(payload["state_ready"])
+        self.assertFalse(payload["inventory_ready"])
+        self.assertIsNone(payload["sources"])
+        self.assertEqual(payload["source_clients"], {})
+
+    def test_current_state_returns_loading_without_competing_with_watcher(self):
+        inventory = {
+            "ready": True, "sources": (), "count": 5000, "clients": {"codex": 5000},
+            "updated_at": 1,
+        }
+        with mock.patch.object(meter, "STATE", {}), \
+                mock.patch.object(meter, "_SOURCE_INVENTORY", inventory), \
+                mock.patch.object(
+                    meter, "newest_source",
+                    side_effect=AssertionError("state request must not rediscover sessions"),
+                ), \
+                mock.patch.object(
+                    meter, "recompute",
+                    side_effect=AssertionError("state request must not rebuild history"),
+                ):
+            payload = meter.current_state()
+
+        self.assertTrue(payload["loading"])
+        self.assertIn("5,000 local sessions", payload["message"])
+
+    def test_watcher_publishes_ready_empty_state_when_no_logs_exist(self):
+        published = []
+        inventory_updates = []
+        with mock.patch.object(meter, "STATE", {}), \
+                mock.patch.object(meter, "all_session_sources", return_value=[]), \
+                mock.patch.object(
+                    meter, "publish_source_inventory",
+                    side_effect=lambda sources: inventory_updates.append(list(sources)),
+                ), \
+                mock.patch.object(
+                    meter, "refresh_cross_session_state",
+                    return_value={"sessions": [], "total_sessions": 0},
+                ), \
+                mock.patch.object(meter, "publish", side_effect=published.append), \
+                mock.patch.object(meter.time, "monotonic", return_value=3), \
+                mock.patch.object(meter.time, "sleep", side_effect=StopIteration), \
+                isolated_pricing_state():
+            with self.assertRaises(StopIteration):
+                meter.watcher()
+
+        self.assertEqual(inventory_updates, [[]])
+        self.assertEqual(len(published), 1)
+        self.assertFalse(published[0]["loading"])
+        self.assertEqual(published[0]["xsession"]["total_sessions"], 0)
+
+    def test_watcher_test_survives_leftover_repricing_state(self):
+        for leftover in ({"running": True}, {"cache_revision": "p_stale"}):
+            with self.subTest(leftover=leftover), \
+                    mock.patch.dict(meter._pricing_recalc, {"running": leftover.get("running", False)}), \
+                    mock.patch.dict(meter._pricing_state, {"cache_revision": leftover.get("cache_revision")}):
+                self.test_watcher_publishes_ready_empty_state_when_no_logs_exist()
+
+
+class DynamicCatalogTests(unittest.TestCase):
+    def test_flattens_namespace_and_legacy_functions(self):
+        catalog = meter.normalize_dynamic_tools([
+            {
+                "type": "namespace",
+                "name": "codex_app",
+                "tools": [
+                    {"name": "open_page", "deferLoading": False, "description": "Open a page"},
+                    {"name": "create_thread", "deferLoading": True, "description": "Create a thread"},
+                ],
+            },
+            {"name": "mcp__jira__search", "namespace": "jira", "deferLoading": True},
+        ])
+        self.assertEqual(
+            [row["name"] for row in catalog],
+            ["mcp__codex_app__open_page", "mcp__codex_app__create_thread", "mcp__jira__search"],
+        )
+        self.assertEqual(catalog[0]["namespace"], "codex_app")
+        self.assertEqual(catalog[2]["namespace"], "jira")
+        self.assertEqual(catalog[2]["kind"], "mcp")
+        self.assertEqual(meter.catalog_counts(catalog), {"advertised": 3, "eager": 1, "deferred": 2})
+
+    def test_embedded_image_bytes_are_not_counted_as_text(self):
+        chars = meter.observable_output_chars({"image_url": "data:image/png;base64," + "A" * 10000})
+        self.assertLess(chars, 100)
+
+
+class ClaudeDesktopDiscoveryTests(unittest.TestCase):
+    def test_default_discovery_scans_standard_and_third_party_roots(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            standard = Path(tmp) / "Claude"
+            third_party = Path(tmp) / "Claude-3p"
+            standard_metadata = standard / "claude-code-sessions" / "account" / "workspace" / "local_standard.json"
+            third_party_metadata = third_party / "local-agent-mode-sessions" / "account" / "workspace" / "local_bedrock.json"
+            standard_metadata.parent.mkdir(parents=True)
+            third_party_metadata.parent.mkdir(parents=True)
+            standard_metadata.write_text(json.dumps({"cliSessionId": "standard-cli"}))
+            third_party_metadata.write_text(json.dumps({"cliSessionId": "bedrock-cli"}))
+
+            with mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", [str(standard), str(third_party)]):
+                paths = set(meter.claude_desktop_metadata_paths())
+
+        self.assertEqual(paths, {str(standard_metadata), str(third_party_metadata)})
+
+    def test_default_discovery_recurses_below_known_session_roots(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            standard = Path(tmp) / "Claude"
+            third_party = Path(tmp) / "Claude-3p"
+            nested_metadata = (
+                standard / "local-agent-mode-sessions" / "account" / "workspace" /
+                "additional-level" / "local_nested.json"
+            )
+            unrelated_metadata = standard / "unrelated" / "local_ignore.json"
+            nested_metadata.parent.mkdir(parents=True)
+            unrelated_metadata.parent.mkdir(parents=True)
+            nested_metadata.write_text(json.dumps({"cliSessionId": "nested-cli"}))
+            unrelated_metadata.write_text(json.dumps({"cliSessionId": "ignore-cli"}))
+
+            with mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", [str(standard), str(third_party)]):
+                paths = set(meter.claude_desktop_metadata_paths())
+
+        self.assertEqual(paths, {str(nested_metadata)})
+
+    def test_default_discovery_prunes_the_non_session_skills_plugin_tree(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            standard = Path(tmp) / "Claude"
+            valid_metadata = (
+                standard / "local-agent-mode-sessions" / "account" /
+                "workspace" / "extra" / "local_session.json"
+            )
+            plugin_metadata = (
+                standard / "local-agent-mode-sessions" / "skills-plugin" /
+                "bundle" / "nested" / "local_not-a-session.json"
+            )
+            valid_metadata.parent.mkdir(parents=True)
+            plugin_metadata.parent.mkdir(parents=True)
+            valid_metadata.write_text(json.dumps({"cliSessionId": "session"}))
+            plugin_metadata.write_text(json.dumps({"cliSessionId": "plugin"}))
+
+            with mock.patch.object(
+                    meter, "CLAUDE_DESKTOP_DATA_ROOTS", [str(standard)]):
+                paths = set(meter.claude_desktop_metadata_paths())
+
+        self.assertEqual(paths, {str(valid_metadata)})
+
+    def test_indexes_desktop_metadata_by_cli_session(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "account" / "workspace" / "local_desktop-session.json"
+            path.parent.mkdir(parents=True)
+            path.write_text(json.dumps({
+                "sessionId": "local_desktop-session",
+                "cliSessionId": "cli-session-id",
+                "cwd": "/tmp/project",
+                "title": "Desktop project task",
+                "model": "claude-fable-5",
+                "lastActivityAt": 123456,
+            }))
+            idx = meter.claude_desktop_index(tmp)
+        self.assertIn("cli-session-id", idx)
+        self.assertEqual(idx["cli-session-id"]["label"], "Claude Desktop")
+        self.assertEqual(idx["cli-session-id"]["desktop_session_id"], "local_desktop-session")
+        self.assertEqual(idx["cli-session-id"]["cwd"], "/tmp/project")
+        self.assertEqual(idx["cli-session-id"]["title"], "Desktop project task")
+
+    def test_desktop_resume_id_is_the_cli_uuid_of_project_transcripts(self):
+        from token_meter.runtimes.claude import ClaudeRuntimeAdapter
+        cli_id = "0f9f0062-51be-4131-acfa-51034ef23f99"
+        cowork_id = "45892917-f18f-4f00-b89e-5e332838e372"
+        with tempfile.TemporaryDirectory() as tmp:
+            projects = Path(tmp) / "projects" / "-tmp-project"
+            projects.mkdir(parents=True)
+            (projects / f"{cli_id}.jsonl").write_text("{}\n")
+            (projects / "not-a-uuid.jsonl").write_text("{}\n")
+            agent_root = Path(tmp) / "Claude" / "local-agent-mode-sessions" / "account" / "org"
+            trace = agent_root / "local_cowork" / ".claude" / "projects" / "outputs" / f"{cowork_id}.jsonl"
+            trace.parent.mkdir(parents=True)
+            trace.write_text("{}\n")
+            (agent_root / "local_cowork.json").write_text(json.dumps({
+                "sessionId": "local_cowork", "cliSessionId": cowork_id,
+                "cwd": str(agent_root / "local_cowork" / "outputs"), "lastActivityAt": 1,
+            }))
+            adapter = ClaudeRuntimeAdapter(Path(tmp) / "projects", [Path(tmp) / "Claude"])
+            records = {row["id"]: row for row in adapter.discover_legacy(None)}
+        self.assertEqual(records[cli_id]["desktop_resume_id"], cli_id)
+        self.assertIsNone(records["not-a-uuid"]["desktop_resume_id"])
+        self.assertIsNone(records[cowork_id].get("desktop_resume_id"))
+
+    def test_discovers_no_project_agent_trace(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "local-agent-mode-sessions" / "account" / "org"
+            metadata = root / "local_agent-session.json"
+            trace = root / "local_agent-session" / ".claude" / "projects" / "outputs" / "cli-agent-id.jsonl"
+            trace.parent.mkdir(parents=True)
+            metadata.write_text(json.dumps({
+                "sessionId": "local_agent-session",
+                "cliSessionId": "cli-agent-id",
+                "cwd": str(root / "local_agent-session" / "outputs"),
+                "title": "No-project task",
+                "lastActivityAt": 123456,
+            }))
+            trace.write_text("{}\n")
+            idx = meter.claude_desktop_index(tmp)
+            sources = meter.claude_local_agent_sources(idx)
+        self.assertEqual(idx["cli-agent-id"]["source_kind"], "agent")
+        self.assertEqual(idx["cli-agent-id"]["project"], "No project")
+        self.assertEqual(len(sources), 1)
+        self.assertEqual(sources[0]["client"], "claude_desktop")
+        self.assertEqual(sources[0]["title"], "No-project task")
+
+    def test_agent_uses_user_selected_folder_as_project(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "local-agent-mode-sessions" / "account" / "org"
+            metadata = root / "local_agent-session.json"
+            metadata.parent.mkdir(parents=True)
+            metadata.write_text(json.dumps({
+                "sessionId": "local_agent-session",
+                "cliSessionId": "cli-agent-id",
+                "cwd": str(root / "local_agent-session" / "outputs"),
+                "userSelectedFolders": ["/tmp/selected-project"],
+                "lastActivityAt": 123456,
+            }))
+            idx = meter.claude_desktop_index(tmp)
+
+        self.assertEqual(idx["cli-agent-id"]["cwd"], "/tmp/selected-project")
+        self.assertEqual(idx["cli-agent-id"]["project"], "/tmp/selected-project")
+
+
+class ToolEvidenceTests(unittest.TestCase):
+    def test_tool_summary_reconciles_types_calls_and_per_execution_peak(self):
+        executions = [
+            {"idx": 1, "tools": [{"name": "exec", "namespace": "exec"}]},
+            {"idx": 2, "tools": [
+                {"name": "exec", "namespace": "exec"},
+                {"name": "wait", "namespace": "wait", "skills": ["browser"]},
+            ]},
+        ]
+        summary = meter.tool_summary(executions)
+        self.assertEqual(summary["activity"]["observed_unique"], 2)
+        self.assertEqual(summary["activity"]["total_calls"], 3)
+        self.assertEqual(summary["activity"]["peak_calls_per_execution"], 2)
+        self.assertEqual(summary["skills"], [{"name": "browser", "activations": 1}])
+        self.assertFalse(summary["execution_rows_truncated"])
+
+    def test_tool_summary_discloses_latest_execution_window(self):
+        executions = [{"idx": idx, "tools": [{"name": "exec", "namespace": "exec"}]}
+                      for idx in range(1, 82)]
+        summary = meter.tool_summary(executions)
+        self.assertEqual(summary["total_calls"], 81)
+        self.assertEqual(summary["execution_rows_total"], 81)
+        self.assertEqual(summary["execution_rows_shown"], 80)
+        self.assertEqual(summary["execution_calls_shown"], 80)
+        self.assertTrue(summary["execution_rows_truncated"])
+
+    def test_flags_tokens_once_across_oversize_repeat_and_error_rules(self):
+        calls = [
+            {**meter.tool_identity("exec_command"), "output_tokens": 9000, "ts": 100,
+             "args_fingerprint": "same", "error": False},
+            {**meter.tool_identity("exec_command"), "output_tokens": 100, "ts": 110,
+             "args_fingerprint": "same", "error": False},
+            {**meter.tool_identity("mcp__jira__search"), "output_tokens": 50, "ts": 120,
+             "args_fingerprint": "jira", "error": True},
+        ]
+        evidence = meter.summarize_tool_evidence(calls)
+        self.assertEqual(evidence["total_output_tokens"], 9150)
+        self.assertEqual(evidence["flagged_tokens"], 9150)
+        self.assertEqual(evidence["oversized_calls"], 1)
+        self.assertEqual(evidence["repeat_calls"], 1)
+        self.assertEqual(evidence["errors"], 1)
+
+    def test_global_aggregation_finds_reported_unused_mcp(self):
+        catalog = [{
+            "name": "mcp__salesforce__query", "namespace": "salesforce", "kind": "mcp",
+            "defer_loading": False, "definition_tokens": 100,
+        }]
+        rows = []
+        for idx in range(5):
+            calls = []
+            if idx == 0:
+                calls = [{**meter.tool_identity("exec_command"), "output_tokens": 9000, "ts": 100,
+                          "args_fingerprint": "one", "error": False}]
+            rows.append({
+                "id": f"s{idx}", "path": f"/tmp/s{idx}", "provider": "codex",
+                "project": "/repo", "_tool_evidence": meter.summarize_tool_evidence(calls, catalog),
+            })
+        waste = meter.global_tool_waste(rows)
+        self.assertEqual(waste["total_calls"], 1)
+        self.assertEqual(waste["oversized_calls"], 1)
+        candidate = next(row for row in waste["by_name"] if row["name"] == "mcp__salesforce__query")
+        self.assertEqual(candidate["recommendation"], "disable")
+        self.assertEqual(candidate["advertised_sessions"], 5)
+        self.assertEqual(candidate["sessions_used"], 0)
+
+    def test_tracks_eager_definition_tax_and_skill_trace_references(self):
+        calls = [{**meter.tool_identity("exec_command"), "output_tokens": 10, "ts": 100,
+                  "args_fingerprint": "x", "skills": ["execution-plan"]}]
+        catalog = [
+            {"name": "unused_eager", "namespace": "app", "kind": "tool",
+             "defer_loading": False, "definition_tokens": 120},
+            {"name": "later", "namespace": "app", "kind": "tool",
+             "defer_loading": True, "definition_tokens": 80},
+        ]
+        evidence = meter.summarize_tool_evidence(calls, catalog)
+        self.assertEqual(evidence["definition_tokens"], 200)
+        self.assertEqual(evidence["unused_eager_definition_tokens"], 120)
+        self.assertEqual(evidence["skills"][0]["name"], "execution-plan")
+
+    def test_plain_tool_names_stay_separate_by_runtime(self):
+        call = {**meter.tool_identity("read_file"), "output_tokens": 10, "ts": 100,
+                "args_fingerprint": "x", "error": False}
+        rows = [
+            {"id": "codex", "provider": "codex", "runtime": "Codex", "project": "/repo",
+             "_tool_evidence": meter.summarize_tool_evidence([call])},
+            {"id": "cursor", "provider": "cursor", "runtime": "Cursor", "project": "/repo",
+             "_tool_evidence": meter.summarize_tool_evidence([call])},
+        ]
+        waste = meter.global_tool_waste(rows)
+        tools = [row for row in waste["inventory_tools"] if row["name"] == "read_file"]
+        self.assertEqual({row["id"] for row in tools}, {"Codex::read_file", "Cursor::read_file"})
+        self.assertEqual({row["runtime"] for row in tools}, {"Codex", "Cursor"})
+        self.assertEqual(waste["provider_sessions"], {"codex": 1, "cursor": 1})
+        self.assertEqual(waste["runtime_sessions"], {"Codex": 1, "Cursor": 1})
+
+    def test_skill_name_is_inferred_from_skill_descriptor_path(self):
+        value = {"cmd": "sed -n '1,80p' /tmp/skills/execution-plan/SKILL.md"}
+        self.assertEqual(meter.skill_names_from_value(value), ["execution-plan"])
+
+    def test_native_skill_tool_input_records_the_invoked_skill(self):
+        value = {"skill": "documentation-skills:sharepoint-docs", "args": "find the policy"}
+        self.assertEqual(
+            meter.skill_names_from_value(value, "Skill"),
+            ["sharepoint-docs"],
+        )
+        self.assertEqual(meter.skill_names_from_value(value, "OtherTool"), [])
+
+    def test_native_claude_skill_call_excludes_its_pack_from_review_candidates(self):
+        objs = [{
+            "type": "assistant", "timestamp": "2026-08-05T00:00:00Z",
+            "message": {
+                "id": "message-1", "content": [{
+                    "type": "tool_use", "id": "tool-1", "name": "Skill",
+                    "input": {"skill": "sharepoint-docs"},
+                }],
+            },
+        }]
+        calls = meter.claude_tool_call_evidence(objs)
+        evidence = meter.summarize_tool_evidence(calls)
+        waste = meter.global_tool_waste([{
+            "id": "claude-session", "provider": "claude", "runtime": "Claude",
+            "project": "/repo", "_tool_evidence": evidence,
+        }])
+        usage = next(row for row in waste["skills"] if row["name"] == "sharepoint-docs")
+        groups = meter.capability_control_groups([], [{
+            "id": "sharepoint-docs", "name": "sharepoint-docs", "runtime": "Claude",
+            "plugin_id": "documentation-skills@skills-marketplace", "mutable": True,
+            "enabled": True, "reviewable": True, "used": bool(usage),
+            "activations": usage["activations"], "last_used": usage["last_used"],
+        }])
+        summary = meter.optional_capability_summary(groups)
+
+        self.assertEqual(calls[0]["skills"], ["sharepoint-docs"])
+        self.assertEqual(summary["used"], 1)
+        self.assertEqual(summary["review_candidates"], [])
+
+    def test_skill_frontmatter_parses_name_description_only(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: caveman\ndescription: Ultra-compressed communication mode\n---\n\nbody")
+            path = f.name
+        try:
+            fm = meter._skill_frontmatter(path)
+            self.assertEqual(fm, {"name": "caveman", "description": "Ultra-compressed communication mode"})
+        finally:
+            os.unlink(path)
+
+    def test_skill_frontmatter_parses_allowed_tools(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: firewall-manager\nallowed-tools: Bash, Read\n---\n\nbody")
+            path = f.name
+        try:
+            fm = meter._skill_frontmatter(path)
+            self.assertEqual(fm["allowed-tools"], "Bash, Read")
+        finally:
+            os.unlink(path)
+
+    def test_skill_frontmatter_returns_empty_for_missing_file(self):
+        fm = meter._skill_frontmatter("/nonexistent/path/SKILL.md")
+        self.assertEqual(fm, {})
+
+    def test_skill_has_measurable_capabilities_with_allowed_tools(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: firewall\ndescription: Manage firewall\nallowed-tools: Bash\n---\n\nbody")
+            path = f.name
+        try:
+            self.assertTrue(meter._skill_has_measurable_capabilities(path))
+        finally:
+            os.unlink(path)
+
+    def test_skill_without_capability_metadata_has_unknown_measurement(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: caveman\ndescription: Be terse\n---\n\nbody")
+            path = f.name
+        try:
+            self.assertFalse(meter._skill_has_measurable_capabilities(path))
+            self.assertEqual(meter._skill_measurability(path), "unknown")
+        finally:
+            os.unlink(path)
+
+    def test_skill_requires_mcp_block_is_measurable(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: sourcegraph-search\nrequires-mcp:\n  - sourcegraph\n---\n\nbody")
+            path = f.name
+        try:
+            self.assertEqual(meter._skill_measurability(path), "measurable")
+            self.assertTrue(meter._skill_has_measurable_capabilities(path))
+        finally:
+            os.unlink(path)
+
+    def test_skill_allowed_tools_block_is_measurable(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: firewall\nallowed-tools:\n  - Bash\n  - Read\n---\n\nbody")
+            path = f.name
+        try:
+            self.assertEqual(meter._skill_measurability(path), "measurable")
+        finally:
+            os.unlink(path)
+
+    def test_skill_empty_allowed_tools_is_instruction_only(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
+            f.write("---\nname: caveman\nallowed-tools: []\n---\n\nbody")
+            path = f.name
+        try:
+            self.assertEqual(meter._skill_measurability(path), "instruction")
+            self.assertFalse(meter._skill_has_measurable_capabilities(path))
+        finally:
+            os.unlink(path)
+
+    def test_instruction_only_skill_pack_excluded_from_review_candidates(self):
+        skill_items = [
+            {"id": "skill:claude:caveman:caveman", "name": "caveman", "runtime": "Claude",
+             "plugin_id": "caveman@skills-marketplace", "mutable": True, "enabled": True,
+             "used": False, "activations": 0, "measurement": "instruction", "reviewable": True},
+        ]
+        groups = meter.capability_control_groups([], skill_items)
+        self.assertEqual(groups[0]["unmeasurable"], True)
+        self.assertEqual(groups[0]["measurement"], "instruction")
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(summary["enabled"], 1)
+        self.assertEqual(summary["unused"], 0)
+        self.assertEqual(summary["unmeasurable_packs"], 1)
+        self.assertEqual(summary["instruction_packs"], 1)
+        self.assertEqual(summary["unknown_evidence_packs"], 0)
+        self.assertEqual(summary["review_candidates"], [])
+
+    def test_unknown_skill_pack_excluded_from_review_candidates(self):
+        skill_items = [
+            {"id": "skill:claude:unknown:unknown", "name": "unknown", "runtime": "Claude",
+             "plugin_id": "unknown@skills-marketplace", "mutable": True, "enabled": True,
+             "used": False, "activations": 0, "measurement": "unknown", "reviewable": True},
+        ]
+        groups = meter.capability_control_groups([], skill_items)
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(groups[0]["measurement"], "unknown")
+        self.assertTrue(groups[0]["unmeasurable"])
+        self.assertEqual(summary["unused"], 0)
+        self.assertEqual(summary["unknown_evidence_packs"], 1)
+        self.assertEqual(summary["review_candidates"], [])
+
+    def test_mixed_measurement_pack_is_not_a_review_candidate(self):
+        skill_items = [
+            {"id": "instruction", "name": "caveman", "runtime": "Claude",
+             "plugin_id": "mixed@skills-marketplace", "mutable": True, "enabled": True,
+             "used": False, "activations": 0, "measurement": "instruction", "reviewable": True},
+            {"id": "tool", "name": "sourcegraph", "runtime": "Claude",
+             "plugin_id": "mixed@skills-marketplace", "mutable": True, "enabled": True,
+             "used": False, "activations": 0, "measurement": "measurable", "reviewable": True},
+        ]
+        groups = meter.capability_control_groups([], skill_items)
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(groups[0]["measurement"], "unknown")
+        self.assertTrue(groups[0]["unmeasurable"])
+        self.assertEqual(summary["unused"], 0)
+        self.assertEqual(summary["review_candidates"], [])
+
+    def test_measurable_skill_pack_remains_review_candidate(self):
+        skill_items = [
+            {"id": "skill:codex:browser:browser", "name": "browser", "runtime": "Codex",
+             "plugin_id": "browser@personal", "mutable": True, "enabled": True,
+             "used": False, "activations": 0, "measurement": "measurable", "reviewable": True},
+        ]
+        groups = meter.capability_control_groups([], skill_items)
+        self.assertEqual(groups[0]["unmeasurable"], False)
+        self.assertEqual(groups[0]["measurement"], "measurable")
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(summary["unused"], 1)
+        self.assertEqual(summary["unmeasurable_packs"], 0)
+        self.assertEqual(len(summary["review_candidates"]), 1)
+
+    def test_used_skill_pack_never_unmeasurable(self):
+        skill_items = [
+            {"id": "skill:claude:caveman:caveman", "name": "caveman", "runtime": "Claude",
+             "plugin_id": "caveman@skills-marketplace", "mutable": True, "enabled": True,
+             "used": True, "activations": 3, "measurement": "instruction", "reviewable": True},
+        ]
+        groups = meter.capability_control_groups([], skill_items)
+        summary = meter.optional_capability_summary(groups)
+        self.assertEqual(groups[0]["measurement"], "measurable")
+        self.assertEqual(summary["used"], 1)
+        self.assertEqual(summary["unused"], 0)
+        self.assertEqual(summary["unmeasurable_packs"], 0)
+        self.assertEqual(len(summary["review_candidates"]), 0)
+
+    def test_token_meter_diagnostics_are_accounted_but_never_recommended_for_cleanup(self):
+        calls = [{**meter.tool_identity("mcp__tokenmeter__check"), "output_tokens": 50000,
+                  "ts": 100, "args_fingerprint": "one", "error": False}]
+        rows = [{
+            "id": "s1", "path": "/tmp/s1", "provider": "codex", "project": "/repo",
+            "_tool_evidence": meter.summarize_tool_evidence(calls),
+        }]
+        waste = meter.global_tool_waste(rows)
+        diagnostic = next(row for row in waste["by_name"] if row["namespace"] == "tokenmeter")
+        self.assertTrue(diagnostic["diagnostic"])
+        self.assertEqual(diagnostic["recommendation"], "keep")
+        self.assertFalse(any("tokenmeter" in row.get("key", "") for row in waste["insights"]))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_menubar_tray.py b/tests/test_menubar_tray.py
new file mode 100644
index 00000000..7c89b935
--- /dev/null
+++ b/tests/test_menubar_tray.py
@@ -0,0 +1,1036 @@
+import unittest
+import datetime
+import http.client
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class MenubarSourceTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.source = Path(meter.__file__).with_name("menubar").joinpath("TokenMeterMenuBar.swift").read_text()
+
+    def test_spend_action_opens_cross_session_spend_route(self):
+        self.assertIn('case .spend: return "Spend"', self.source)
+        self.assertIn('case .spend:\n                self.openDailyBrief()', self.source)
+        self.assertIn('@objc private func openDailyBrief()', self.source)
+        self.assertIn('openDashboardPanel("spend", includePinnedSession: false)', self.source)
+
+    def test_dashboard_opens_sessions_unless_a_session_is_pinned(self):
+        self.assertIn(
+            'tokenMeterDashboardURL = URL(string: "http://127.0.0.1:8722/#sessions")',
+            self.source,
+        )
+        self.assertIn("if pinnedSessionID?.isEmpty == false", self.source)
+        self.assertIn('openDashboardPanel("summary")', self.source)
+        self.assertIn('openDashboardPanel("sessions", includePinnedSession: false)', self.source)
+
+    def test_model_prices_setting_opens_dashboard_pricing_editor(self):
+        self.assertIn('NSMenuItem(title: "Model Prices", action: #selector(openModelPrices)', self.source)
+        self.assertIn('@objc private func openModelPrices()', self.source)
+        self.assertIn('openDashboardPanel("model-pricing", includePinnedSession: false)', self.source)
+
+    def test_enterprise_tokenomics_is_a_top_level_native_action_below_settings(self):
+        self.assertIn(
+            'private let tokenMeterEnterpriseTokenomicsURL = URL(string: "https://www.splunk.com/en_us/products/tokenomics.html")!',
+            self.source,
+        )
+        rebuild = self.source[
+            self.source.index("    private func rebuildMenu()"):
+            self.source.index("    private var activeShortcutKeyCode")
+        ]
+        self.assertIn(
+            'NSMenuItem(title: "Get Enterprise Tokenomics", action: #selector(openEnterpriseTokenomics)',
+            rebuild,
+        )
+        self.assertLess(
+            rebuild.index("menu.addItem(settingsItem)"),
+            rebuild.index('NSMenuItem(title: "Get Enterprise Tokenomics"'),
+        )
+        self.assertIn('@objc private func openEnterpriseTokenomics()', self.source)
+        self.assertIn('NSWorkspace.shared.open(tokenMeterEnterpriseTokenomicsURL)', self.source)
+
+    def test_native_menu_does_not_advertise_removed_session_trace_view(self):
+        for marker in (
+            'NSMenuItem(title: "Open Trace"', '#selector(openTrace)',
+            '@objc private func openTrace()', 'openDashboardPanel("activity")',
+        ):
+            self.assertNotIn(marker, self.source)
+
+    def test_output_speed_remains_available_without_a_standing_menu_row(self):
+        rebuild = self.source[
+            self.source.index("    private func rebuildMenu()"):
+            self.source.index("    private var activeShortcutKeyCode")
+        ]
+        self.assertNotIn('addMetricRow("Output', rebuild)
+        self.assertIn(r'· \(outputSpeedLabel) · \(model)', self.source)
+        self.assertIn('formatTokenRate(rate)', self.source)
+        self.assertIn(
+            'return "\\(formatTokenRate(rate)) tok/s\\(estimatedTokens ? " est" : "")"',
+            self.source,
+        )
+        self.assertNotIn('tok/s\\(live)', self.source)
+        self.assertIn('print(snapshot.outputSpeedLabel)', self.source)
+
+    def test_selected_session_cost_and_context_are_not_menu_rows(self):
+        rebuild = self.source[
+            self.source.index("    private func rebuildMenu()"):
+            self.source.index("    private var activeShortcutKeyCode")
+        ]
+        self.assertIn('return "\\(costLabel) · \\(contextLabel) · \\(outputSpeedLabel) · \\(model)"', self.source)
+        self.assertNotIn('return "\\(verdict.prefix) \\(formatMoney(totalCost))', self.source)
+        self.assertNotIn('addMetricRow("Cost", snapshot.costLabel', rebuild)
+        self.assertNotIn('"Context",\n                contextDetail', rebuild)
+        self.assertNotIn('addMetricRow("Status"', rebuild)
+        self.assertNotIn('"Now"', rebuild)
+        self.assertNotIn('"Action"', rebuild)
+
+    def test_cursor_uses_provider_identity_and_estimated_usage_labels(self):
+        self.assertIn('catalog[provider] ?? catalog["unknown-runtime"]', self.source)
+        self.assertIn('case "runtime.cursor": return "cursorarrow"', self.source)
+        self.assertIn('let costAvailable = metricAvailable(availability, "cost")', self.source)
+        self.assertIn('let tokensAvailable = metricAvailable(availability, "tokens")', self.source)
+        self.assertIn('let estimatedTokens = bool(source["token_estimate"])', self.source)
+        self.assertIn('var menuBarTodaySpendLabel: String', self.source)
+
+    def test_live_polling_bypasses_cached_menubar_responses(self):
+        self.assertIn('cachePolicy: .reloadIgnoringLocalCacheData', self.source)
+        self.assertIn('request.setValue("no-cache", forHTTPHeaderField: "Cache-Control")', self.source)
+        self.assertIn('request.setValue("no-cache", forHTTPHeaderField: "Pragma")', self.source)
+
+    def test_native_menu_surfaces_updates_and_installs_without_the_dashboard(self):
+        for marker in (
+            "struct SoftwareUpdateSnapshot",
+            'dict["software_update"] as? [String: Any]',
+            'title: "New update available",',
+            'action: #selector(installSoftwareUpdate),',
+            'NSMenuItem(title: "Updating Token Meter...", action: nil',
+            'title: "Update needs attention",',
+            'action: #selector(openUpdateSettings),',
+            '@objc private func installSoftwareUpdate()',
+            'request.httpMethod = "POST"',
+            'request.setValue("application/json", forHTTPHeaderField: "Content-Type")',
+            'request.setValue(softwareUpdate.actionToken, forHTTPHeaderField: "X-Token-Meter-Action")',
+            'request.httpBody = Data("{}".utf8)',
+            '@objc private func openUpdateSettings()',
+            'tokenMeterUpdateSettingsURL',
+        ):
+            self.assertIn(marker, self.source)
+        rebuild = self.source[
+            self.source.index("    private func rebuildMenu()"):
+            self.source.index("    private var activeShortcutKeyCode")
+        ]
+        self.assertLess(
+            rebuild.index("addQuickActions()"),
+            rebuild.index("addSoftwareUpdateItem()"),
+        )
+        self.assertLess(
+            rebuild.index("addSoftwareUpdateItem()"),
+            rebuild.index("addSessionPicker()"),
+        )
+        self.assertIn("if self.softwareUpdate.isUpdating", self.source)
+        self.assertIn('print("native-update=available updating attention")', self.source)
+
+    def test_status_item_owns_a_clean_native_menu(self):
+        app = self.source[
+            self.source.index("final class TokenMeterMenuBar"):
+            self.source.index("private func string(")
+        ]
+        self.assertIn('private let menu = NSMenu(title: "Token Meter")', app)
+        self.assertIn('statusItem.menu = menu', app)
+        self.assertIn('menu.delegate = self', app)
+        self.assertIn('func menuNeedsUpdate(_ menu: NSMenu)', app)
+        self.assertIn('func menuWillOpen(_ menu: NSMenu)', app)
+        self.assertIn('func menuDidClose(_ menu: NSMenu)', app)
+        self.assertIn('private var menuRefreshPending = false', app)
+        self.assertIn('guard !menuIsOpen else', app)
+        self.assertIn('func runMenuSmoke() throws', app)
+        self.assertIn('TOKEN_METER_MENUBAR_MENU_SMOKE', self.source)
+        self.assertIn('native-menu=ready sessions=direct follow-latest=direct', self.source)
+        self.assertIn('native-quick-actions=Dashboard,Spend,Tools,Settings height=26', self.source)
+        self.assertNotIn('private let popover = NSPopover()', app)
+        self.assertNotIn('popover.show(relativeTo: button.bounds', app)
+        self.assertIn('NSSegmentedControl', app)
+
+    def test_native_menu_exposes_direct_session_following(self):
+        self.assertIn('let selectedSessionID = string(selection["selected_id"])', self.source)
+        self.assertIn('let selectedSession = recentSessions.first { $0.id == snapshot.selectedSessionID }', self.source)
+        self.assertIn('NSMenuItem(title: "Follow latest", action: #selector(followLatest)', self.source)
+        self.assertIn('for session in recentSessions.prefix(5)', self.source)
+        self.assertIn('NSMenuItem(title: session.menuTitle, action: #selector(pinSession(_:))', self.source)
+        self.assertIn('item.state = pinnedSessionID == session.id ? .on : .off', self.source)
+        self.assertIn('item.representedObject = session.id', self.source)
+        self.assertIn('@objc private func followLatest()', self.source)
+        self.assertIn('@objc private func pinSession(_ sender: NSMenuItem)', self.source)
+        self.assertIn('let maximumNameLength = 36', self.source)
+
+    def test_provider_limits_and_budgets_use_separate_native_submenus(self):
+        self.assertIn('NSMenuItem(title: "Provider limits (Beta)", action: nil', self.source)
+        self.assertIn('description: "Provider limits (Beta)"', self.source)
+        self.assertIn('limitsItem.submenu = makeLimitsMenu()', self.source)
+        self.assertIn('private func makeLimitsMenu() -> NSMenu', self.source)
+        self.assertIn('for window in provider.windows', self.source)
+        self.assertIn('"\\(window.label) · \\(window.percentLabel) used"', self.source)
+        self.assertIn('coverageNote: string(dict["coverage_note"]) ?? ""', self.source)
+        self.assertIn('coverage=\\(coverage)', self.source)
+        self.assertIn('case "opencode": return "gearshape.2"', self.source)
+        self.assertIn('let budget = double(row["allocation"])', self.source)
+        self.assertIn('NSMenuItem(title: "Budgets", action: nil', self.source)
+        self.assertIn('budgetsItem.submenu = makeBudgetsMenu()', self.source)
+        self.assertIn('private func makeBudgetsMenu() -> NSMenu', self.source)
+        self.assertIn('let overallTitle = budget.configured', self.source)
+        self.assertIn('"Overall · \\(formatMoney(budget.spend)) of \\(formatMoney(budget.budget)) · \\(Int(budget.percent.rounded()))% used"', self.source)
+        self.assertIn('for scope in budget.scopes where scope.id != "overall"', self.source)
+        self.assertIn('"\\(scope.label) · \\(formatMoney(scope.spend)) of \\(formatMoney(scope.budget)) · \\(Int(scope.percent.rounded()))% used"', self.source)
+        self.assertIn('"\\(scope.label) · Not set"', self.source)
+        self.assertIn('action: #selector(openBudgetSettings)', self.source)
+        self.assertIn('Native budgets omitted the OpenCode monthly budget.', self.source)
+        self.assertIn('overallBudgetItems.count == 1', self.source)
+        self.assertIn('budgetActionItems.count == runtimeBudgetScopes.count + 1', self.source)
+
+        limits = self.source[
+            self.source.index("    private func makeLimitsMenu()"):
+            self.source.index("    private func makeBudgetsMenu()")
+        ]
+        self.assertNotIn("monthlyBudget", limits)
+        self.assertNotIn("budgetScope", limits)
+        self.assertNotIn("openBudgetSettings", limits)
+
+    def test_menu_bar_settings_are_visible_and_quota_threshold_is_explicit(self):
+        self.assertIn('case .settings: return "Settings"', self.source)
+        self.assertIn('case .settings:\n                self.openSettings()', self.source)
+        self.assertIn('NSMenuItem(title: "Menu bar settings", action: nil', self.source)
+        self.assertIn('settingsItem.submenu = makeSettingsMenu()', self.source)
+        self.assertNotIn('NSMenuItem(title: "More", action: nil', self.source)
+        self.assertIn('NSMenuItem(title: "Open Settings", action: #selector(openSettings)', self.source)
+        self.assertIn('addAction("Quit Token Meter", #selector(quit))', self.source)
+        self.assertNotIn('Quit Token Meter Menubar', self.source)
+        self.assertIn('NSMenuItem(title: "Quota alert threshold (\\(quotaAlertThreshold)%)"', self.source)
+        self.assertIn('NSMenu(title: "Quota alert threshold")', self.source)
+        self.assertIn('title: "\\(threshold)% used",', self.source)
+        self.assertNotIn('NSMenuItem(title: "Warn at"', self.source)
+
+    def test_configurable_title_and_quota_notifications_have_safe_defaults(self):
+        self.assertIn('enum TitleMetric: String, CaseIterable', self.source)
+        self.assertIn('metrics = [.cost, .speed]', self.source)
+        self.assertIn('for metric in TitleMetric.allCases', self.source)
+        self.assertIn('#selector(toggleTitleMetric(_:))', self.source)
+        self.assertIn('TitleMetric.allCases.filter(titleMetrics.contains).map(\\.rawValue)', self.source)
+        self.assertIn('let presentation = selectedStatusTitlePresentation()', self.source)
+        self.assertIn('let title = presentation.accessibilityTitle', self.source)
+        self.assertIn('let text = snapshot.menuBarCostLabel', self.source)
+        self.assertIn('let text = snapshot.menuBarOutputSpeedLabel', self.source)
+        self.assertIn('let text = snapshot.menuBarContextLabel', self.source)
+        self.assertIn('let text = snapshot.model', self.source)
+        self.assertIn('case .todaySpend:', self.source)
+        self.assertIn('let text = snapshot.menuBarTodaySpendLabel', self.source)
+        self.assertIn('case .todaySpend: return "Today spend"', self.source)
+        self.assertIn(
+            'return "\\(String(format: "$%.0f", todaySpendTotalCost))\\(todaySpendEstimated ? " est" : "")"',
+            self.source,
+        )
+        self.assertIn('parts[parts.count - 1].text = "· " + parts[parts.count - 1].text', self.source)
+        self.assertIn('metrics.insert(.todaySpend)', self.source)
+        self.assertIn('todaySpendTitlePreferenceDefaultsKey', self.source)
+        self.assertIn('todaySpendEstimated ? " est" : ""', self.source)
+        self.assertIn('metrics = [.limits]', self.source)
+        self.assertIn(
+            'tokenMeterDefaults.set(true, forKey: todaySpendTitlePreferenceDefaultsKey)',
+            self.source,
+        )
+        self.assertIn('let accessibilityText = limitsStatusTitle()', self.source)
+        self.assertIn('symbol: runtimeCatalog[constrained.provider.id]?.symbol', self.source)
+        self.assertNotIn('private func compactStatusTitle()', self.source)
+        self.assertIn('private func limitsStatusTitle() -> String?', self.source)
+        self.assertIn('return "\\(constrained.provider.label) \\(constrained.window.percentLabel)"', self.source)
+        self.assertNotIn('constrained.window.compactKind', self.source)
+        self.assertIn('Native menu still exposes hover tooltips.', self.source)
+        self.assertIn('guard statusItem.button?.toolTip == nil, !menuContainsToolTip(menu)', self.source)
+        self.assertIn('private var quotaAlertsEnabled: Bool { notificationFeed?.quotaAlerts ?? true }', self.source)
+        self.assertIn('saveQuotaAlertPreferences(enabled: !quotaAlertsEnabled, threshold: quotaAlertThreshold)', self.source)
+        self.assertIn('process.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")', self.source)
+        self.assertIn('"--", title, body', self.source)
+
+    def test_native_companion_only_claims_and_shows_server_notifications(self):
+        for removed in (
+            'evaluateQuotaNotifications', 'evaluateBudgetNotifications', 'evaluateLiveHintNotifications',
+            'struct QuotaNotificationState', 'struct BudgetNotificationState', 'firedThresholds',
+            'quotaObservationEstablished', 'deliveredLiveHintIDs', 'dict["live_hints"]',
+        ):
+            self.assertNotIn(removed, self.source)
+        for marker in (
+            'struct NotificationFeed', 'optionalDouble(dict["schema_version"]).map(Int.init) == 1',
+            'NotificationFeed.fromJSON(dict["notifications"] as? [String: Any])',
+            'private let notificationConsumer = "token-meter-menubar"',
+            'body: ["id": event.id, "consumer": notificationConsumer]',
+            'if ok, bool(response?["claimed"]) {',
+            'showNotification(title: event.title, body: event.body)',
+            '"http://127.0.0.1:8722/notifications/claim"', '"http://127.0.0.1:8722/settings/notifications"',
+            'body: ["quota_alerts": enabled, "quota_threshold": threshold, "migrate": true]',
+            'legacyNotificationDefaultsKeys.forEach(tokenMeterDefaults.removeObject(forKey:))',
+            '"TokenMeterQuotaNotificationStates", "TokenMeterBudgetNotificationStates"',
+            '"TokenMeterBudgetExceededNotificationMonths", "TokenMeterLiveHintNotificationIDs"',
+            'sampleFeed.deliverable.map(\\.id) == ["e5", "e4", "e3", "e2", "e1"]',
+            'events.filter(\\.claimable)',
+            'action: canEditQuotaAlerts ? #selector(toggleQuotaAlerts(_:)) : nil',
+        ):
+            self.assertIn(marker, self.source)
+
+    def test_status_item_uses_a_compact_cross_display_hit_target(self):
+        self.assertIn('NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)', self.source)
+        self.assertIn('private func splunkChevronImage(', self.source)
+        self.assertIn('private func statusTitleImage(_ presentation: StatusTitlePresentation) -> NSImage', self.source)
+        self.assertIn('private func runtimeMarkImage(symbol: String', self.source)
+        self.assertIn('var providerSymbol: String', self.source)
+        self.assertIn('var providerAccessibilityText: String', self.source)
+        self.assertIn('symbol: presentation.providerSymbol', self.source)
+        self.assertIn('let providerSymbol = runtimeCatalog[snapshot.provider]?.symbol ?? "runtime.generic"', self.source)
+        self.assertIn('let presentationWithoutLimits = selectedStatusTitlePresentation()', self.source)
+        self.assertIn('presentationWithoutLimits.providerSymbol == expectedProviderSymbol', self.source)
+        self.assertIn('button.image = splunkChevronImage()', self.source)
+        self.assertNotIn('systemSymbolName: "waveform.path.ecg"', self.source)
+        self.assertIn('button.imagePosition = .imageOnly', self.source)
+        self.assertIn('.foregroundColor: NSColor.black', self.source)
+        self.assertIn('image.isTemplate = true', self.source)
+        self.assertIn('let titleImage = statusTitleImage(presentation)', self.source)
+        self.assertIn('statusItem.length = titleImage.size.width + 8', self.source)
+        self.assertIn('button.contentTintColor = nil', self.source)
+        self.assertIn('button.setAccessibilityLabel("Token Meter")', self.source)
+        self.assertIn('button.setAccessibilityValue(title)', self.source)
+        self.assertNotIn('button.toolTip =', self.source)
+        self.assertIn('button.contentTintColor = budgetExceeded', self.source)
+        self.assertIn('enum StatusDisplayMode: String, CaseIterable', self.source)
+        self.assertIn('StatusDisplayMode.text.rawValue', self.source)
+        self.assertIn('screen.visibleFrame.width < 1200 ? .icon : .text', self.source)
+        self.assertIn('private func selectedStatusTitle() -> String', self.source)
+        self.assertIn('let renderedTitle = statusItem.button?.accessibilityValue() as? String', self.source)
+        self.assertIn('renderedTitle == expectedTitle', self.source)
+        self.assertIn('titleMetrics = Set(TitleMetric.allCases)', self.source)
+        self.assertIn('titleMetrics = originalTitleMetrics', self.source)
+        self.assertIn('statusItem.autosaveName = statusItemAutosaveName', self.source)
+        self.assertIn('"NSStatusItem Preferred Position \\(statusItemAutosaveName)"', self.source)
+        self.assertIn('statusItemInitialPreferredPosition = 50', self.source)
+        self.assertIn('object(forKey: statusItemPreferredPositionDefaultsKey) == nil', self.source)
+        self.assertNotIn('statusTitleColor(for:', self.source)
+        self.assertNotIn('NSWorkspace.didActivateApplicationNotification', self.source)
+
+    def test_native_menu_omits_cost_and_context_below_recent_sessions(self):
+        rebuild = self.source[
+            self.source.index("    private func rebuildMenu()"):
+            self.source.index("    private var activeShortcutKeyCode")
+        ]
+        sessions_position = rebuild.index('addSessionPicker()')
+        limits_position = rebuild.index('let limitsItem = NSMenuItem(title: "Provider limits (Beta)"')
+        self.assertLess(sessions_position, limits_position)
+        self.assertNotIn('addMetricRow("Cost", snapshot.costLabel', rebuild)
+        self.assertNotIn('"Context",\n                contextDetail', rebuild)
+        self.assertNotIn('addMetricRow("Tokens"', rebuild)
+        self.assertNotIn('addMetricRow("Cache"', rebuild)
+        self.assertNotIn('addMetricRow("Output', rebuild)
+        self.assertNotIn('ExecutionTraceView', rebuild)
+
+    def test_global_toggle_shortcut_is_configurable_and_persisted(self):
+        self.assertIn('import Carbon.HIToolbox', self.source)
+        self.assertIn('enum MenuBarShortcut: String, CaseIterable', self.source)
+        self.assertIn('case .controlOptionT: return "⌃⌥T"', self.source)
+        self.assertIn('private let globalShortcutDefaultsKey = "TokenMeterGlobalShortcut"', self.source)
+        self.assertIn('RegisterEventHotKey(', self.source)
+        self.assertIn('delegate.openMenu()', self.source)
+        self.assertIn('NSMenuItem(title: "Keyboard shortcut"', self.source)
+        self.assertIn('case .custom: return "Custom…"', self.source)
+        self.assertIn('@objc private func configureCustomShortcut(_ sender: NSMenuItem)', self.source)
+        self.assertIn('NSEvent.addLocalMonitorForEvents(matching: .keyDown)', self.source)
+        self.assertIn('tokenMeterDefaults.set(shortcut.rawValue, forKey: globalShortcutDefaultsKey)', self.source)
+
+    def test_native_menu_header_has_no_splunk_wordmark(self):
+        header = self.source[
+            self.source.index("    private func addHeader()"):
+            self.source.index("    private func addSessionPicker()")
+        ]
+        self.assertIn('titleText = selectedSession?.identifier ?? snapshot.menuTitle', header)
+        self.assertIn('"Following latest"', header)
+        self.assertIn('"Following this session"', header)
+        self.assertNotIn('splunkWordmarkImage', header)
+        self.assertNotIn('logo', header)
+
+    def test_monthly_budget_status_is_native_and_alerts_come_from_the_server(self):
+        for marker in (
+            'struct MonthlyBudget',
+            'let budgetExceeded = monthlyBudget?.anyExceeded == true',
+            'description: budgetExceeded ? "Budget alert" : "Budgets"',
+            'budgetsItem.submenu = makeBudgetsMenu()',
+            'tokenMeterBudgetSettingsURL',
+            'action: #selector(openBudgetSettings)',
+            'var exceeded: Bool { configured && percent >= 100 }',
+            'var anyExceeded: Bool { exceeded || !exceededRuntimeScopes.isEmpty }',
+            'if let scope = exceededRuntimeScopes.first',
+            'return "\\(scope.label) · \\(Int(scope.percent.rounded()))%"',
+            'warning: monthlyBudget?.anyExceeded == true',
+            'button.contentTintColor = budgetExceeded',
+            'NSColor.systemRed',
+            'button.setAccessibilityLabel("Token Meter")',
+            'let activeTitle = budget?.anyExceeded == true ? "⚠︎ \\(baseTitle)" : baseTitle',
+            'print("budget-state=\\(budget?.compactLabel ?? "unconfigured") exceeded=\\(budget?.anyExceeded == true)")',
+        ):
+            self.assertIn(marker, self.source)
+        self.assertNotIn("· over budget", self.source)
+        self.assertNotIn(
+            'monthlyBudget?.exceeded == true ? NSColor.systemRed : NSColor.labelColor',
+            self.source,
+        )
+        self.assertNotIn(
+            'valueColor: budget.exceeded ? .systemRed : .labelColor',
+            self.source,
+        )
+
+
+class TrayLogicTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        import importlib.util
+        tray_path = Path(meter.__file__).with_name("menubar").joinpath("token_meter_tray.py")
+        spec = importlib.util.spec_from_file_location("token_meter_tray", tray_path)
+        cls.tray = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(cls.tray)
+
+    def test_dashboard_url_opens_sessions_unless_pinned(self):
+        self.assertEqual(
+            self.tray.dashboard_url("#sessions", pinned_session=None, include_pinned_session=False),
+            "http://127.0.0.1:8722/#sessions",
+        )
+        self.assertEqual(
+            self.tray.dashboard_url("#summary", pinned_session="abc"),
+            "http://127.0.0.1:8722/sessions/abc#summary",
+        )
+
+    def test_status_display_mode_selects_or_hides_the_tray_label(self):
+        label = "$1 · 12 tok/s"
+        self.assertEqual(self.tray.normalize_status_display_mode(None), "automatic")
+        self.assertEqual(self.tray.normalize_status_display_mode("invalid"), "automatic")
+        self.assertEqual(self.tray.normalize_status_display_mode({"mode": "icon"}), "automatic")
+        self.assertEqual(self.tray.status_display_label(label, "automatic"), label)
+        self.assertEqual(self.tray.status_display_label(label, "text"), label)
+        self.assertEqual(self.tray.status_display_label(label, "icon"), "")
+
+    def test_update_tray_label_keeps_title_when_icon_mode_hides_label(self):
+        tray = object.__new__(self.tray.TokenMeterTray)
+        tray.error = ""
+        tray.title_metrics = set()
+        tray.snapshot = {}
+        tray.provider_quotas = []
+        tray.monthly_budget = None
+        tray.indicator = mock.Mock()
+        tray.status_display_mode = "icon"
+
+        tray.update_tray_label()
+
+        tray.indicator.set_label.assert_called_once_with(
+            "", "⚠︎ $999.99 · 999 tok/s · 100% ctx",
+        )
+        tray.indicator.set_title.assert_called_once_with("Token Meter")
+
+    def test_update_tray_label_uses_descriptive_tooltip_but_keeps_compact_status(self):
+        tray = object.__new__(self.tray.TokenMeterTray)
+        tray.error = ""
+        tray.title_metrics = {"cost", "speed", "today_spend"}
+        tray.snapshot = {
+            "availability": {"cost": True, "throughput": True, "tokens": True},
+            "source": {"label": "Claude", "token_estimate": False},
+            "total_cost": 1.25,
+            "throughput": {"available": True, "output_tps": 12.3},
+            "today_spend": {"available": True, "total_cost": 2.75, "estimated": True},
+        }
+        tray.provider_quotas = []
+        tray.monthly_budget = None
+        tray.indicator = mock.Mock()
+        tray.status_display_mode = "automatic"
+
+        tray.update_tray_label()
+
+        tray.indicator.set_label.assert_called_once_with(
+            "$1 · 12 tok/s · $3 est", "⚠︎ $999.99 · 999 tok/s · 100% ctx",
+        )
+        tray.indicator.set_title.assert_called_once_with(
+            "Current session cost: $1.25\nOutput speed: 12.3 tok/s\n"
+            "Today's spend across sessions: $2.75 est",
+        )
+
+    def test_update_tray_label_explains_offline_status_in_tooltip(self):
+        tray = object.__new__(self.tray.TokenMeterTray)
+        tray.error = "server unavailable"
+        tray.title_metrics = {"cost", "speed"}
+        tray.indicator = mock.Mock()
+        tray.status_display_mode = "automatic"
+
+        tray.update_tray_label()
+
+        tray.indicator.set_label.assert_called_once_with(
+            "TM off", "⚠︎ $999.99 · 999 tok/s · 100% ctx",
+        )
+        tray.indicator.set_title.assert_called_once_with("Token Meter · Server offline")
+
+    def test_display_mode_selection_persists_and_refreshes_the_tray(self):
+        tray = object.__new__(self.tray.TokenMeterTray)
+        tray.status_display_mode = "automatic"
+        tray.save_state = mock.Mock()
+        tray.update_tray_label = mock.Mock()
+        tray.refresh_menu_content = mock.Mock()
+        item = mock.Mock()
+        item.get_active.return_value = True
+        item.token_meter_status_display_mode = "icon"
+
+        tray._on_display_mode_toggled(item)
+
+        self.assertEqual(tray.status_display_mode, "icon")
+        tray.save_state.assert_called_once_with()
+        tray.update_tray_label.assert_called_once_with()
+        tray.refresh_menu_content.assert_called_once_with()
+
+    def test_tray_status_title_uses_selected_metrics_and_budget_warning(self):
+        state = {
+            "availability": {"cost": True, "throughput": True, "cache": True, "tokens": True},
+            "source": {"label": "Claude", "token_estimate": False},
+            "total_cost": 1.25,
+            "model": "claude-test",
+            "context": {"latest_pct": 0.42},
+            "throughput": {"available": True, "output_tps": 12.3},
+        }
+        providers = [{
+            "id": "claude",
+            "label": "Claude",
+            "status": "ok",
+            "stale": False,
+            "windows": [{"id": "weekly", "kind": "weekly", "label": "Weekly", "used_percent": 88}],
+        }]
+        budget = {
+            "configured": True,
+            "percent": 110,
+            "spend": 11,
+            "budget": 10,
+            "month": "2026-07",
+            "lower_bound": False,
+            "scopes": [{
+                "id": "overall", "label": "Overall", "spend": 11, "budget": 10, "percent": 110,
+            }],
+        }
+        title = self.tray.tray_status_title(
+            state, {"cost", "speed", "limits"}, providers, budget,
+        )
+        self.assertTrue(title.startswith("⚠︎ "))
+        self.assertIn("$1", title)
+        self.assertIn("12 tok/s", title)
+        self.assertIn("Claude 88% · weekly", title)
+
+    def test_tray_status_title_includes_today_spend_with_native_compact_labels(self):
+        state = {
+            "availability": {"cost": True, "throughput": True, "tokens": True},
+            "source": {"label": "Claude", "token_estimate": False},
+            "total_cost": 1.25,
+            "cost_approx": True,
+            "context": {"latest_pct": 0.42},
+            "throughput": {"available": True, "output_tps": 12.3},
+            "live_throughput": {"available": True, "output_tps": 24.6},
+            "today_spend": {"available": True, "total_cost": 2.75, "estimated": True},
+        }
+        title = self.tray.tray_status_title(
+            state, {"cost", "speed", "context", "today_spend"}, [], None,
+        )
+        self.assertEqual(title, "$1 · 25 tok/s · 42% · $3 est")
+        self.assertNotIn("$1 est", title)
+
+        unavailable_context = dict(state)
+        unavailable_context["context"] = {}
+        unavailable_title = self.tray.tray_status_title(
+            unavailable_context, {"context"}, [], None,
+        )
+        self.assertEqual(unavailable_title, "--%")
+
+    def test_load_state_persists_today_spend_migration(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "tray.json"
+            path.write_text(json.dumps({
+                "title_metrics": ["cost", "speed"],
+                "selected_tab": "run",
+            }), encoding="utf-8")
+            with mock.patch.object(self.tray, "STATE_PATH", str(path)):
+                loaded = self.tray.TokenMeterTray.load_state(object.__new__(
+                    self.tray.TokenMeterTray,
+                ))
+            self.assertIn("today_spend", loaded["title_metrics"])
+            persisted = json.loads(path.read_text(encoding="utf-8"))
+            self.assertEqual(persisted["title_metrics"], [
+                "cost", "speed", "today_spend",
+            ])
+            self.assertTrue(persisted["today_spend_title_preference"])
+
+    def test_load_state_migrates_and_preserves_status_display_mode(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "tray.json"
+            path.write_text(json.dumps({
+                "today_spend_title_preference": True,
+                "title_metrics": ["cost", "speed"],
+            }), encoding="utf-8")
+            with mock.patch.object(self.tray, "STATE_PATH", str(path)):
+                loaded = self.tray.TokenMeterTray.load_state(object.__new__(
+                    self.tray.TokenMeterTray,
+                ))
+            self.assertEqual(loaded["status_display_mode"], "automatic")
+            self.assertEqual(
+                json.loads(path.read_text(encoding="utf-8"))["status_display_mode"],
+                "automatic",
+            )
+
+            path.write_text(json.dumps({
+                "today_spend_title_preference": True,
+                "title_metrics": ["cost"],
+                "status_display_mode": "icon",
+            }), encoding="utf-8")
+            with mock.patch.object(self.tray, "STATE_PATH", str(path)):
+                loaded = self.tray.TokenMeterTray.load_state(object.__new__(
+                    self.tray.TokenMeterTray,
+                ))
+            self.assertEqual(loaded["status_display_mode"], "icon")
+
+    def test_parse_monthly_budget_preserves_unconfigured_runtime_scopes(self):
+        budget = self.tray.parse_monthly_budget({
+            "configured": True,
+            "month": "2026-07",
+            "spend": 6.5,
+            "budget": 1000,
+            "percent": 0.0065,
+            "runtimes": [
+                {
+                    "provider": "claude", "label": "Claude", "spend": 0,
+                    "allocation": 0, "percent": None,
+                },
+                {
+                    "provider": "codex", "label": "Codex", "spend": 6.5,
+                    "allocation": 1000, "percent": 0.0065,
+                },
+            ],
+        })
+        self.assertEqual([scope["id"] for scope in budget["scopes"]], [
+            "overall", "claude", "codex",
+        ])
+        self.assertEqual(budget["scopes"][1]["percent"], 0)
+        self.assertAlmostEqual(budget["scopes"][2]["percent"], 0.65)
+
+    def feed(self, **prefs):
+        return {
+            "schema_version": 1,
+            "events": [
+                {"id": f"e{i}", "title": f"t{i}", "body": "b", "created_at": 100 - i, "claimable": i != 6}
+                for i in range(7)
+            ],
+            "prefs": {"source": "saved", "quota_alerts": True, "quota_threshold": 90, **prefs},
+            "actions": {"token": "tok"},
+        }
+
+    def tray_instance(self, settings=None):
+        tray = object.__new__(self.tray.TokenMeterTray)
+        tray.settings = dict(settings or {})
+        tray.notification_feed = None
+        tray.legacy_notification_prefs_handled = False
+        tray.pinned_session = None
+        tray.selected_tab = "run"
+        tray.title_metrics = set(self.tray.DEFAULT_TITLE_METRICS)
+        tray.status_display_mode = "automatic"
+        return tray
+
+    def test_notification_feed_is_parsed_and_delivered_oldest_first(self):
+        feed = self.tray.parse_notification_feed(self.feed())
+        self.assertEqual(feed["quota_threshold"], 90)
+        self.assertEqual([e["id"] for e in self.tray.deliverable_notifications(feed)],
+                         ["e5", "e4", "e3", "e2", "e1"])
+        self.assertIsNone(self.tray.parse_notification_feed({"schema_version": 2}))
+        self.assertIsNone(self.tray.parse_notification_feed(None))
+        self.assertEqual(self.tray.parse_notification_feed(self.feed(quota_threshold=85))["quota_threshold"], 80)
+
+    def test_tray_shows_only_events_it_claimed(self):
+        tray = self.tray_instance()
+        claimed = {"e5", "e3"}
+        calls = []
+
+        def post(path, body, token):
+            calls.append((path, body, token))
+            return True, {"ok": True, "claimed": body["id"] in claimed}
+
+        with mock.patch.object(self.tray, "post_json", side_effect=post), \
+                mock.patch.object(self.tray, "deliver_notification") as deliver:
+            tray._handle_notifications(self.tray.parse_notification_feed(self.feed()))
+        self.assertEqual([c[1]["consumer"] for c in calls], ["token-meter-tray"] * 5)
+        self.assertEqual({c[0] for c in calls}, {"/notifications/claim"})
+        self.assertEqual([c.args for c in deliver.call_args_list], [("t5", "b"), ("t3", "b")])
+        self.assertTrue(tray.quota_alerts_enabled)
+        self.assertEqual(tray.quota_alert_threshold, 90)
+
+    def test_tray_stops_claiming_for_this_poll_after_a_failed_post(self):
+        tray = self.tray_instance()
+        with mock.patch.object(self.tray, "post_json", return_value=(False, {})) as post, \
+                mock.patch.object(self.tray, "deliver_notification") as deliver:
+            tray._handle_notifications(self.tray.parse_notification_feed(self.feed()))
+        self.assertEqual(post.call_count, 1)
+        deliver.assert_not_called()
+        self.assertLessEqual(self.tray.NOTIFICATION_POST_TIMEOUT_S, 2)
+
+    def test_tray_migrates_local_quota_prefs_once_then_drops_legacy_keys(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = os.path.join(directory, "tray.json")
+            tray = self.tray_instance({
+                "quota_alerts_enabled": False, "quota_alert_threshold": 95,
+                "quota_notification_states": {"codex:primary": {}}, "budget_exceeded_notification_months": [],
+            })
+            feed = self.tray.parse_notification_feed(self.feed(source="default"))
+            feed["events"] = []
+            with mock.patch.object(self.tray, "STATE_PATH", path), \
+                    mock.patch.object(self.tray, "post_json", return_value=(True, {"ok": True})) as post:
+                tray._handle_notifications(feed)
+                tray._handle_notifications(feed)
+            post.assert_called_once_with("/settings/notifications", {
+                "quota_alerts": False, "quota_threshold": 95, "migrate": True,
+            }, "tok")
+            with open(path, encoding="utf-8") as fh:
+                saved = json.load(fh)
+            for key in self.tray.LEGACY_NOTIFICATION_KEYS:
+                self.assertNotIn(key, saved)
+                self.assertNotIn(key, tray.settings)
+
+    def test_tray_keeps_local_prefs_until_the_server_takes_them(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = os.path.join(directory, "tray.json")
+            tray = self.tray_instance({"quota_alerts_enabled": False, "quota_alert_threshold": 95})
+            feed = self.tray.parse_notification_feed(self.feed(source="default"))
+            feed["events"] = []
+            with mock.patch.object(self.tray, "STATE_PATH", path), \
+                    mock.patch.object(self.tray, "post_json", return_value=(False, {})):
+                tray._handle_notifications(feed)
+                tray.save_state()
+            with open(path, encoding="utf-8") as fh:
+                saved = json.load(fh)
+            self.assertEqual(saved["quota_alerts_enabled"], False)
+            self.assertEqual(saved["quota_alert_threshold"], 95)
+            self.assertFalse(tray.legacy_notification_prefs_handled)
+
+
+class TraySourceTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.source = (
+            Path(meter.__file__).with_name("menubar").joinpath("token_meter_tray.py").read_text()
+        )
+
+    def test_linux_tray_matches_native_dashboard_routing_and_actions(self):
+        for marker in (
+            "def open_dashboard(self):",
+            'self.open_url("#sessions", include_pinned_session=False)',
+            'self.open_url("#summary")',
+            "Open Budget Settings",
+            "#settings-budgets",
+            "Open Settings",
+            "#settings",
+            "Model Prices",
+            "#model-pricing",
+            "Budgets",
+            "Get Enterprise Tokenomics",
+            "TOKENOMICS_URL",
+            "open_external_url",
+        ):
+            self.assertIn(marker, self.source)
+
+    def test_linux_tray_does_not_advertise_removed_session_trace_view(self):
+        self.assertNotIn('"Open Trace"', self.source)
+        self.assertNotIn('self.open_url("#activity")', self.source)
+
+    def test_linux_tray_exposes_tabs_title_metrics_and_notifications(self):
+        for marker in (
+            '("overview", "All")',
+            '("claude", "Claude")',
+            '("today_spend", "Today spend")',
+            'DEFAULT_TITLE_METRICS = ("cost", "speed", "today_spend")',
+            "_apply_budget_menu",
+            "for index, scope in enumerate(scopes):",
+            "self.budget_scope_items.append(item)",
+            "Menu bar title",
+            "Quota notifications",
+            "Warn at",
+            "parse_notification_feed",
+            'NOTIFICATION_CONSUMER = "token-meter-tray"',
+            '["notify-send", title, body]',
+            "Output speed:",
+            "Monthly budget:",
+            "Most constrained:",
+        ):
+            self.assertIn(marker, self.source)
+
+    def test_linux_tray_has_no_local_notification_rules(self):
+        for removed in ("def evaluate_quota_notifications", "def evaluate_budget_notifications",
+                        "fired_thresholds", '"quota_notification_states": {}'):
+            self.assertNotIn(removed, self.source)
+
+    def test_linux_tray_exposes_persisted_status_display_modes(self):
+        for marker in (
+            '"status_display_mode": "automatic"',
+            'self.status_display_mode = normalize_status_display_mode',
+            '"status_display_mode": self.status_display_mode',
+            'self.display_mode_item, self.display_mode_menu = self._submenu_item("Menu bar display")',
+            '("automatic", "Automatic")',
+            '("text", "Cost + speed text")',
+            '("icon", "Icon only")',
+            'def _on_display_mode_toggled(self, item):',
+            'status_display_label(label, self.status_display_mode)',
+        ):
+            self.assertIn(marker, self.source)
+
+
+class MenubarSessionTests(unittest.TestCase):
+    def test_menubar_state_projects_today_cross_session_spend(self):
+        today = datetime.date.today().isoformat()
+        source = {
+            "id": "live", "provider": "codex", "label": "Codex",
+            "path": "/tmp/live.jsonl", "session": "live.jsonl", "project": "/repo",
+        }
+        state = {
+            "provider": "codex", "source": source, "session": "live.jsonl",
+            "project": "/repo", "context": {}, "cache": {}, "executions": [], "insights": [],
+        }
+        cross = {
+            "daily": [{
+                "day": today, "cost": 1.25,
+                "availability": {"cost": True},
+                "provenance": {"estimated_cost": 0.25},
+            }],
+        }
+        with mock.patch.object(meter, "STATE", state), \
+                mock.patch.object(meter, "cached_session_sources", return_value=([source], True)), \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]), \
+                mock.patch.dict(meter._xsess, {"data": cross}, clear=False):
+            payload = meter.menubar_state()
+
+        self.assertEqual(payload["today_spend"], {
+            "available": True,
+            "total_cost": 1.25,
+            "estimated": True,
+        })
+
+    def test_menubar_today_spend_keeps_unavailable_cost_unavailable(self):
+        today = datetime.date.today()
+
+        projection = meter.menubar_today_spend({"daily": [{
+            "day": today.isoformat(), "cost": 0,
+            "availability": {"cost": False},
+        }]}, today=today)
+
+        self.assertEqual(projection, {
+            "available": False,
+            "total_cost": None,
+            "estimated": False,
+        })
+
+    def test_recommendations_always_target_the_single_run_surface(self):
+        states = (
+            {"context": {"latest_pct": 0.9}, "executions": [], "insights": []},
+            {"context": {}, "last_turn_cost": 0, "executions": [],
+             "insights": [{"kind": "warn", "text": "Check this signal"}]},
+        )
+        for state in states:
+            with self.subTest(state=state):
+                self.assertEqual(meter.menubar_recommendation(state)["target"], "summary")
+
+    def test_menubar_reuses_watcher_state_for_the_live_selected_session(self):
+        source = {
+            "id": "live", "provider": "codex", "label": "Codex",
+            "path": "/tmp/live.jsonl", "session": "live.jsonl",
+            "project": "/repo", "mtime": 1,
+        }
+        state = {
+            "provider": "codex", "source": source, "session": "live.jsonl",
+            "project": "/repo", "context": {}, "cache": {},
+            "executions": [], "insights": [],
+        }
+        with mock.patch.object(meter, "STATE", state), \
+                mock.patch.object(
+                    meter, "cached_session_sources", return_value=([source], True),
+                ), \
+                mock.patch.object(
+                    meter, "recompute",
+                    side_effect=AssertionError("menu poll must reuse watcher state"),
+                ), \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
+            payload = meter.menubar_state("live")
+
+        self.assertTrue(payload["ok"])
+        self.assertEqual(payload["selection"]["selected_id"], "live")
+
+    def test_context_pulse_is_bounded_numeric_only_and_does_not_leak_trace_content(self):
+        state = {
+            "executions": [
+                {"context_pct": -0.5, "detail": "private prompt"},
+                {"context_pct": 0.251234, "tool_input": "private arguments"},
+                {"context_pct": 1.5, "path": "/private/logs/trace.jsonl"},
+                {"context_pct": None},
+                {"context_pct": "not a number"},
+                {"context_pct": True},
+            ],
+        }
+        pulse = meter.menubar_context_pulse(state, limit=2)
+
+        self.assertEqual(pulse, [0.2512, 1.0])
+        encoded = json.dumps(pulse)
+        self.assertNotIn("private", encoded)
+        self.assertNotIn("trace.jsonl", encoded)
+
+    def test_recent_sessions_are_limited_and_keep_an_older_pin_visible(self):
+        sources = [{
+            "id": f"s{idx}", "provider": "codex" if idx % 2 else "claude",
+            "label": "Codex" if idx % 2 else "Claude Code", "path": f"/tmp/s{idx}.jsonl",
+            "session": f"s{idx}.jsonl", "project": f"/repo/project-{idx}", "mtime": idx,
+            "title": f"Task {idx}",
+        } for idx in range(7)]
+
+        latest = meter.menubar_recent_sessions(sources)
+        pinned = meter.menubar_recent_sessions(sources, selected_id="s0")
+
+        self.assertEqual([row["id"] for row in latest], ["s6", "s5", "s4", "s3", "s2"])
+        self.assertEqual([row["id"] for row in pinned], ["s0", "s6", "s5", "s4", "s3"])
+        self.assertEqual(pinned[0]["name"], "Task 0")
+        self.assertNotIn("project", pinned[0])
+
+    def test_recent_sessions_use_sanitized_summary_name_when_discovery_has_no_title(self):
+        sources = [{
+            "id": "claude-session", "provider": "claude", "label": "Claude Code",
+            "path": "/tmp/claude-session.jsonl", "session": "claude-session.jsonl",
+            "project": "/repo/token-meter", "mtime": 10, "title": None,
+        }]
+        summaries = [{
+            "id": "claude-session", "provider": "claude",
+            "session_name": "Default model configuration opus 5",
+        }]
+
+        recent = meter.menubar_recent_sessions(sources, summaries=summaries)
+
+        self.assertEqual(recent[0]["name"], "Default model configuration opus 5")
+
+    def test_menubar_state_joins_recent_session_names_from_cross_session_summaries(self):
+        source = {
+            "id": "claude-session", "provider": "claude", "label": "Claude Code",
+            "path": "/tmp/claude-session.jsonl", "session": "claude-session.jsonl",
+            "project": "/repo/token-meter", "mtime": 10, "title": None,
+        }
+        state = {
+            "provider": "claude", "source": source, "session": "claude-session.jsonl",
+            "project": "/repo/token-meter", "context": {}, "cache": {}, "trace": [],
+            "insights": [], "executions": [], "throughput": {}, "live_throughput": {},
+        }
+        cross = {
+            "current_sessions": [{
+                "id": "claude-session", "provider": "claude",
+                "session_name": "Default model configuration opus 5",
+            }],
+            "sessions": [],
+        }
+        with mock.patch.object(meter, "STATE", state), \
+                mock.patch.object(meter, "cached_session_sources", return_value=([source], True)), \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]), \
+                mock.patch.dict(meter._xsess, {"data": cross}, clear=False):
+            payload = meter.menubar_state()
+
+        self.assertEqual(
+            payload["recent_sessions"][0]["name"],
+            "Default model configuration opus 5",
+        )
+
+    def test_menubar_state_uses_requested_session_and_marks_pin(self):
+        sources = [{
+            "id": "pinned", "provider": "codex", "label": "Codex", "path": "/tmp/pinned.jsonl",
+            "session": "pinned.jsonl", "project": "/repo/pinned-project", "mtime": 1, "title": "Pinned task",
+        }]
+        state = {
+            "provider": "codex", "source": sources[0], "session": "pinned.jsonl",
+            "project": "/repo/pinned-project", "context": {}, "cache": {}, "trace": [], "insights": [],
+            "executions": [{"idx": 1, "model": "gpt-5.6-sol", "context_pct": 0.2}],
+            "throughput": {"available": True, "output_tps": 42.5, "basis": "end_to_end",
+                           "sample_count": 2, "timing_coverage": 0.75},
+            "live_throughput": {"available": True, "output_tps": 18.25,
+                                "basis": "live_end_to_end", "completed_steps": 3,
+                                "measured_output_tokens": 365, "measured_seconds": 20},
+        }
+        with mock.patch.object(meter, "STATE", {"source": {"id": "live"}}), \
+                mock.patch.object(meter, "cached_session_sources", return_value=(sources, True)), \
+                mock.patch.object(meter, "cached_session_state", return_value=state), \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
+            payload = meter.menubar_state("pinned")
+
+        self.assertTrue(payload["selection"]["pinned"])
+        self.assertFalse(payload["selection"]["missing"])
+        self.assertEqual(payload["selection"]["selected_id"], "pinned")
+        self.assertEqual(payload["recent_sessions"][0]["name"], "Pinned task")
+        self.assertEqual(payload["model"], "gpt-5.6-sol")
+        self.assertEqual(payload["provider_quotas"], [])
+        self.assertEqual(payload["context_pulse"], [0.2])
+        self.assertEqual(payload["project"], "pinned-project")
+        self.assertEqual(payload["source"]["project"], "pinned-project")
+        self.assertNotIn("/repo/pinned-project", json.dumps(payload))
+        self.assertEqual(payload["throughput"], {
+            "available": True, "output_tps": 42.5, "basis": "end_to_end",
+            "sample_count": 2, "timing_coverage": 0.75,
+        })
+        self.assertEqual(payload["live_throughput"], {
+            "available": True, "output_tps": 18.25, "basis": "live_end_to_end",
+            "completed_steps": 3, "measured_output_tokens": 365,
+            "measured_seconds": 20,
+        })
+
+    def test_cold_start_does_not_rebuild_all_history_for_each_menu_poll(self):
+        with mock.patch.object(meter, "STATE", {}), \
+                mock.patch.object(meter, "cached_session_sources", return_value=([], False)), \
+                mock.patch.object(
+                    meter, "all_session_sources",
+                    side_effect=AssertionError("menu polling must not discover sessions"),
+                ), \
+                mock.patch.object(meter, "recompute") as recompute, \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
+            payload = meter.menubar_state()
+
+        recompute.assert_not_called()
+        self.assertFalse(payload["ok"])
+        self.assertEqual(payload["provider_quotas"], [])
+
+    def test_cold_start_does_not_recompute_a_persisted_pinned_session(self):
+        sources = [{
+            "id": "pinned", "provider": "codex", "label": "Codex",
+            "path": "/tmp/pinned.jsonl", "session": "pinned.jsonl",
+            "project": "/repo", "mtime": 1,
+        }]
+        with mock.patch.object(meter, "STATE", {}), \
+                mock.patch.object(meter, "cached_session_sources", return_value=(sources, True)), \
+                mock.patch.object(meter, "recompute") as recompute, \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
+            payload = meter.menubar_state("pinned")
+
+        recompute.assert_not_called()
+        self.assertTrue(payload["selection"]["pinned"])
+        self.assertEqual(payload["selection"]["selected_id"], "pinned")
+        self.assertFalse(payload["selection"]["missing"])
+
+    def test_menubar_uses_published_monthly_budget_when_cross_cache_rotates(self):
+        budget = {
+            "month": "2026-07", "configured": True, "budget": 1000,
+            "spend": 420, "percent": 0.42, "settings": {
+                "monthly_total": 1000, "allocations": {}, "thresholds": [80, 90, 100],
+                "native_notifications": True,
+            },
+        }
+        with mock.patch.object(meter, "STATE", {"xsession": {"budget": budget}}), \
+                mock.patch.object(meter, "cached_session_sources", return_value=([], True)), \
+                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]), \
+                mock.patch.dict(meter._xsess, {"data": None}, clear=False):
+            payload = meter.menubar_state()
+        self.assertEqual(payload["budget"], budget)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_meter.py b/tests/test_meter.py
deleted file mode 100644
index a842d6ed..00000000
--- a/tests/test_meter.py
+++ /dev/null
@@ -1,26005 +0,0 @@
-import unittest
-import contextlib
-import datetime
-import http.client
-import io
-import json
-import os
-import plistlib
-import re
-import shutil
-import sqlite3
-import subprocess
-import tempfile
-import threading
-import time
-from html.parser import HTMLParser
-from pathlib import Path
-from unittest import mock
-
-import meter
-from token_meter.contracts import DiscoveryContext
-from token_meter.projections import agent_usage_projection
-from token_meter.runtimes.codex import CodexRuntimeAdapter
-from token_meter.runtimes import pi as pi_runtime
-from token_meter.services import git_delivery as git_delivery_service_module
-from tests.dashboard_page import DASHBOARD_PAGE
-
-
-class _TrackingSqliteConnection:
-    """Wrap a real sqlite3 connection and record whether close() ever ran."""
-
-    def __init__(self, connection):
-        object.__setattr__(self, "_connection", connection)
-        object.__setattr__(self, "closed", False)
-
-    def __getattr__(self, name):
-        return getattr(self._connection, name)
-
-    def __setattr__(self, name, value):
-        setattr(self._connection, name, value)
-
-    def close(self):
-        object.__setattr__(self, "closed", True)
-        return self._connection.close()
-
-    def __enter__(self):
-        self._connection.__enter__()
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        return self._connection.__exit__(exc_type, exc, tb)
-
-
-def isolated_pricing_state():
-    """Isolate module-level repricing state for tests that run the watcher.
-
-    Another test can leave a stale pricing revision or a running recalculation;
-    the watcher would then start a real background reprice or skip its
-    cross-session refresh. Use as a context manager around ``meter.watcher()``.
-    """
-    stack = contextlib.ExitStack()
-    stack.enter_context(mock.patch.dict(
-        meter._pricing_state, {"cache_revision": None, "fingerprint_key": None, "fingerprint": None}))
-    stack.enter_context(mock.patch.dict(
-        meter._pricing_recalc, {"running": False, "pending": False, "thread": None}))
-    stack.enter_context(mock.patch.object(meter, "pricing_watch_tick", return_value=False))
-    return stack
-
-
-class GitDeliveryLedgerConnectionTests(unittest.TestCase):
-    """The ledger must close every sqlite connection it opens."""
-
-    def test_ledger_operations_close_every_connection(self):
-        from token_meter.services.git_delivery import GitDeliveryLedger
-
-        created = []
-        real_connect = sqlite3.connect
-
-        def tracking_connect(*args, **kwargs):
-            tracker = _TrackingSqliteConnection(real_connect(*args, **kwargs))
-            created.append(tracker)
-            return tracker
-
-        with tempfile.TemporaryDirectory() as directory:
-            path = os.path.join(directory, "ledger.sqlite3")
-            with mock.patch.object(
-                    git_delivery_service_module.sqlite3, "connect",
-                    side_effect=tracking_connect):
-                ledger = GitDeliveryLedger(path)
-                ledger.record("repo-key", "object-key", 1, 2, 3)
-                ledger.mark_seen("repo-key", "object-key")
-                self.assertTrue(ledger.has_seen("repo-key", "object-key"))
-                ledger.rows()
-                ledger.daily_rows(["repo-key"], "2026-09-01", "2026-09-30")
-                ledger.map_project("project-key", "repo-key")
-                ledger.repo_key_for_project("project-key")
-                ledger.set_repository_coverage("repo-key", 12, 1)
-                ledger.repository_coverage("repo-key")
-                ledger.set_last_checked(123)
-                ledger.last_checked()
-                ledger.baseline_at()
-                ledger.coalesce_repository("repo-key", "canonical-key")
-                ledger.clear(123)
-        self.assertTrue(created, "ledger operations should open connections")
-        leaked = [connection for connection in created if not connection.closed]
-        self.assertEqual(
-            [], leaked,
-            f"{len(leaked)} of {len(created)} ledger connections were never closed",
-        )
-
-
-class BuilderRecapDomainTests(unittest.TestCase):
-    def test_antigravity_is_a_public_recap_runtime(self):
-        from token_meter.domain.builder_recap import _safe_runtime
-
-        self.assertEqual(_safe_runtime("Antigravity"), "Antigravity")
-        self.assertEqual(_safe_runtime("Antigravity private"), "")
-
-    TODAY = datetime.date(2026, 9, 13)
-
-    def row(self, last, daily=(), **values):
-        return {
-            "last": last,
-            "runtime": "Codex",
-            "duration_s": 0,
-            "duration_available": False,
-            "output_tokens": 0,
-            "availability": {},
-            "_model_daily": list(daily),
-            "_performance_samples": [],
-            "_tool_evidence": {},
-            **values,
-        }
-
-    def recap(self, rows, days=7, git_days=(), previous_git_lines=None,
-              previous_git_commits=None):
-        from token_meter.domain.builder_recap import build_builder_recap
-        return build_builder_recap(
-            rows, None if git_days is None else list(git_days), days,
-            today=self.TODAY, generated_at=1_757_718_400,
-            previous_git_lines=previous_git_lines,
-            previous_git_commits=previous_git_commits,
-        )
-
-    def supporting(self, result, stat_id):
-        return next(stat for stat in result["supporting"] if stat["id"] == stat_id)
-
-    def spotlight(self, result, stat_id):
-        return next(stat for stat in result["spotlights"] if stat["id"] == stat_id)
-
-    def test_windows_are_inclusive_equal_and_local_calendar_based(self):
-        result = self.recap([], days=7)
-        self.assertEqual(result["current"], {
-            "start_day": "2026-09-07", "end_day": "2026-09-13",
-        })
-        self.assertEqual(result["previous"], {
-            "start_day": "2026-08-31", "end_day": "2026-09-06",
-        })
-        self.assertEqual(len(result["activity_days"]), 7)
-
-    def test_invalid_range_is_rejected_before_aggregation(self):
-        with self.assertRaisesRegex(ValueError, "7, 30, or 90"):
-            self.recap([], days=14)
-
-    def test_30_and_90_day_windows_remain_equal_length_and_inclusive(self):
-        recap_30 = self.recap([], days=30)
-        recap_90 = self.recap([], days=90)
-        self.assertEqual(recap_30["current"], {
-            "start_day": "2026-08-15", "end_day": "2026-09-13",
-        })
-        self.assertEqual(recap_30["previous"], {
-            "start_day": "2026-07-16", "end_day": "2026-08-14",
-        })
-        self.assertEqual(recap_90["current"], {
-            "start_day": "2026-06-16", "end_day": "2026-09-13",
-        })
-        self.assertEqual(recap_90["previous"], {
-            "start_day": "2026-03-18", "end_day": "2026-06-15",
-        })
-
-    def test_core_aggregates_use_day_level_paired_coverage(self):
-        paired = lambda day, output, cost: {
-            "day": day, "model": "gpt-5", "output_tokens": output,
-            "cost_covered_output_tokens": output, "cost_covered_cost": cost,
-        }
-        mixed = {
-            "day": "2026-09-13", "model": "gpt-5", "output_tokens": 900,
-            "cost_covered_output_tokens": 0, "cost_covered_cost": 9,
-        }
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [
-                paired("2026-09-13", 200, 1), paired("2026-08-31", 100, 1),
-            ]),
-            self.row("2026-09-12T18:00:00", [
-                paired("2026-09-12", 100, 0.5), paired("2026-09-10", 100, 0.5),
-            ]),
-            self.row("2026-09-01T18:00:00", [mixed]),
-        ])
-
-        self.assertEqual(result["activity_days"][-1], {
-            "day": "2026-09-13", "recorded_session": True,
-        })
-        self.assertEqual(self.spotlight(result, "build_streak")["current"], 2)
-        self.assertEqual(self.spotlight(result, "efficiency_change")["current"], 200.0)
-        self.assertEqual(self.spotlight(result, "efficiency_change")["previous"], 100.0)
-        self.assertEqual(self.spotlight(result, "efficiency_change")["delta_pct"], 100.0)
-
-    def test_covered_spend_sums_paired_cost_and_stays_unavailable_when_absent(self):
-        paired = lambda day, output, cost: {
-            "day": day, "model": "gpt-5", "output_tokens": output,
-            "cost_covered_output_tokens": output, "cost_covered_cost": cost,
-        }
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [
-                paired("2026-09-13", 200, 1.25), paired("2026-09-12", 100, 0.75),
-                paired("2026-08-31", 100, 2.5),
-            ]),
-        ])
-
-        spend = self.supporting(result, "covered_spend")
-        self.assertEqual(spend["family"], "cost")
-        self.assertTrue(spend["available"])
-        self.assertAlmostEqual(spend["current"], 2.0)
-        self.assertAlmostEqual(spend["previous"], 2.5)
-        self.assertEqual(spend["unit"], "USD")
-        self.assertEqual(spend["basis"], "paired cost-covered output and cost")
-        self.assertEqual(spend["sample_count"], 2)
-
-        # Output with no paired cost must not become a measured zero.
-        uncovered = self.recap([
-            self.row("2026-09-13T18:00:00", [{
-                "day": "2026-09-13", "model": "gpt-5", "output_tokens": 900,
-                "cost_covered_output_tokens": 0, "cost_covered_cost": 0,
-            }]),
-        ])
-        self.assertEqual(
-            [stat["id"] for stat in uncovered["supporting"]
-             if stat["id"] == "covered_spend"],
-            [],
-        )
-
-    def test_every_supporting_stat_id_has_a_deterministic_sort_position(self):
-        paired = lambda day, output, cost: {
-            "day": day, "model": "gpt-5", "output_tokens": output,
-            "cost_covered_output_tokens": output, "cost_covered_cost": cost,
-        }
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [
-                paired("2026-09-13", 200, 1.25), paired("2026-08-31", 100, 2.5),
-            ], duration_s=120, duration_available=True, _performance_samples=[
-                {"day": "2026-09-13", "output_tokens": 400, "generation_s": 4},
-                {"day": "2026-08-31", "output_tokens": 300, "generation_s": 5},
-            ], _tool_evidence={"tools": [{"daily": [
-                {"day": "2026-09-13", "calls": 12},
-            ]}]}),
-        ], git_days=[
-            {"day": "2026-09-13", "available": True, "active": True,
-             "changed_lines": 400},
-        ])
-
-        ordered = [stat["id"] for stat in result["supporting"]]
-        self.assertEqual(ordered, sorted(set(ordered), key=ordered.index))
-        self.assertIn("covered_spend", ordered)
-
-    def test_efficiency_comparison_is_unavailable_with_prior_zero_cost(self):
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [{
-                "day": "2026-09-13", "model": "gpt-5", "output_tokens": 100,
-                "cost_covered_output_tokens": 100, "cost_covered_cost": 1,
-            }, {
-                "day": "2026-08-31", "model": "gpt-5", "output_tokens": 100,
-                "cost_covered_output_tokens": 100, "cost_covered_cost": 0,
-            }]),
-        ])
-
-        efficiency = self.spotlight(result, "efficiency_change")
-        self.assertFalse(efficiency["available"])
-        self.assertIsNone(efficiency["delta_pct"])
-
-    def test_malformed_non_finite_evidence_is_ignored(self):
-        result = self.recap([self.row("not-a-date", [{
-            "day": "2026-09-13", "model": "gpt-5", "output_tokens": 100,
-            "cost_covered_output_tokens": float("nan"),
-            "cost_covered_cost": float("inf"),
-        }], mtime=float("inf"), _performance_samples=[{
-            "day": "2026-09-13", "output_tokens": float("inf"),
-            "duration_s": float("nan"),
-        }], _tool_evidence={"tools": [{"daily": [{
-            "day": "2026-09-13", "calls": float("inf"),
-        }]}]})])
-
-        self.assertEqual(result["activity_days"][-1], {
-            "day": "2026-09-13", "recorded_session": True,
-        })
-        self.assertFalse(self.spotlight(result, "efficiency_change")["available"])
-        self.assertNotIn("output_pace", [stat["id"] for stat in result["supporting"]])
-        self.assertEqual(result["coverage"]["tools"]["eligible"], 0)
-
-    def test_float_conversion_overflow_is_ignored_as_unavailable_evidence(self):
-        class OverflowingFloat:
-            def __float__(self):
-                raise OverflowError("malformed numeric evidence")
-
-        overflow = OverflowingFloat()
-        result = self.recap([
-            self.row("not-a-date", [], mtime=overflow),
-            self.row("2026-09-13T18:00:00", [{
-                "day": "2026-09-13", "model": "gpt-5",
-                "cost_covered_output_tokens": overflow,
-                "cost_covered_cost": overflow,
-            }]),
-        ])
-
-        self.assertEqual(result["activity_days"][-1], {
-            "day": "2026-09-13", "recorded_session": True,
-        })
-        self.assertFalse(self.spotlight(result, "efficiency_change")["available"])
-
-    def test_git_coverage_requires_explicit_available_evidence_and_counts_only_active_days(self):
-        unavailable = self.recap([], git_days=None)
-        no_measured_rows = self.recap([], git_days=())
-        measured_inactive = self.recap([], git_days=[
-            {"day": f"2026-09-{day:02d}", "available": True, "active": False}
-            for day in range(7, 14)
-        ] + [{"day": "2026-09-12", "available": False, "active": True}])
-
-        self.assertFalse(unavailable["coverage"]["git"]["available"])
-        self.assertFalse(unavailable["coverage"]["git"]["projection_available"])
-        self.assertFalse(no_measured_rows["coverage"]["git"]["available"])
-        self.assertTrue(no_measured_rows["coverage"]["git"]["projection_available"])
-        self.assertEqual(no_measured_rows["coverage"]["git"]["eligible"], 0)
-        self.assertFalse(self.spotlight(no_measured_rows, "lines_pushed")["available"])
-        self.assertNotIn("delivery_active_days", [
-            stat["id"] for stat in no_measured_rows["supporting"]
-        ])
-        self.assertTrue(measured_inactive["coverage"]["git"]["available"])
-        self.assertTrue(measured_inactive["coverage"]["git"]["projection_available"])
-        self.assertEqual(measured_inactive["coverage"]["git"]["eligible"], 7)
-        self.assertEqual(
-            self.supporting(measured_inactive, "delivery_active_days")["current"], 0
-        )
-        delivery = self.supporting(measured_inactive, "delivery_active_days")
-        self.assertIsNone(delivery["previous"])
-        self.assertIsNone(delivery["delta"])
-
-    def test_lines_pushed_sums_only_measured_nonnegative_integer_change_volume(self):
-        result = self.recap([], previous_git_lines=120_000, git_days=[
-            {"day": "2026-09-13", "available": True, "active": True,
-             "changed_lines": 184_392},
-            {"day": "2026-09-12", "available": True, "active": True,
-             "changed_lines": True},
-            {"day": "2026-09-11", "available": True, "active": True,
-             "changed_lines": -1},
-            {"day": "2026-09-10", "available": True, "active": True,
-             "changed_lines": 1.5},
-            {"day": "2026-09-09", "available": True, "active": True,
-             "changed_lines": float("inf")},
-            {"day": "2026-09-08", "available": True, "active": True,
-             "changed_lines": "999999"},
-            {"day": "2026-09-08", "available": True, "active": True,
-             "changed_lines": 10 ** 1000},
-            {"day": "2026-09-07", "available": False, "active": True,
-             "changed_lines": 999_999},
-        ])
-
-        lines = self.spotlight(result, "lines_pushed")
-        self.assertTrue(lines["available"])
-        self.assertEqual(lines["current"], 184_392)
-        self.assertEqual(lines["previous"], 120_000)
-        self.assertEqual(lines["delta"], 64_392)
-        self.assertAlmostEqual(lines["delta_pct"], 53.66, places=2)
-        self.assertEqual(lines["unit"], "lines")
-        self.assertEqual(
-            lines["basis"],
-            "added plus deleted text lines from successful local pushes",
-        )
-        self.assertEqual(lines["sample_count"], 1)
-
-    def test_commits_pushed_sums_only_measured_nonnegative_integer_commit_counts(self):
-        result = self.recap([], previous_git_commits=94, git_days=[
-            {"day": "2026-09-13", "available": True, "active": True,
-             "changed_lines": 900, "commits": 7},
-            {"day": "2026-09-12", "available": True, "active": True,
-             "changed_lines": 400, "commits": 5},
-            {"day": "2026-09-11", "available": True, "active": True,
-             "changed_lines": 300, "commits": True},
-            {"day": "2026-09-10", "available": True, "active": True,
-             "changed_lines": 200, "commits": -1},
-            {"day": "2026-09-09", "available": True, "active": True,
-             "changed_lines": 100, "commits": 2.5},
-            {"day": "2026-09-08", "available": True, "active": True,
-             "changed_lines": 100, "commits": "12"},
-            {"day": "2026-09-07", "available": False, "active": True,
-             "changed_lines": 100, "commits": 999},
-        ])
-
-        commits = self.spotlight(result, "commits_pushed")
-        self.assertTrue(commits["available"])
-        self.assertEqual(commits["current"], 12)
-        self.assertEqual(commits["previous"], 94)
-        self.assertEqual(commits["delta"], -82)
-        self.assertEqual(commits["unit"], "commits")
-        self.assertEqual(
-            commits["basis"],
-            "own non-merge commits introduced by successful local pushes",
-        )
-        self.assertEqual(commits["sample_count"], 2)
-
-    def test_commits_pushed_is_unavailable_without_measured_commit_evidence(self):
-        missing_projection = self.recap([], git_days=None)
-        no_commit_field = self.recap([], git_days=[
-            {"day": "2026-09-13", "available": True, "active": True,
-             "changed_lines": 120},
-        ])
-
-        for result in (missing_projection, no_commit_field):
-            commits = self.spotlight(result, "commits_pushed")
-            self.assertFalse(commits["available"])
-            self.assertIsNone(commits["current"])
-            self.assertEqual(commits["sample_count"], 0)
-        self.assertTrue(
-            self.spotlight(no_commit_field, "lines_pushed")["available"]
-        )
-
-    def test_public_labels_reject_paths_urls_controls_and_credentialish_values(self):
-        sentinels = ("/private/repo", "https://secret.example", "sk-live-secret",
-                     "api_key=secret", "builder@example.com", "<private>", "bad\x00label",
-                     "Untrusted runtime narrative", "Untrusted model narrative",
-                     "Please upload your credentials")
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [{
-                "day": "2026-09-13", "model": sentinels[0], "executions": 9,
-            }, {
-                "day": "2026-09-12", "model": "gpt-5.2-codex", "executions": 3,
-            }], runtime=sentinels[1], _tool_evidence={"tools": [
-                {"name": "read_file", "display": sentinels[2], "daily": [{
-                    "day": "2026-09-13", "calls": 9,
-                }]},
-                {"name": "read_file", "display": sentinels[9], "daily": [{
-                    "day": "2026-09-12", "calls": 3,
-                }]},
-            ]}),
-            self.row("2026-09-13T17:00:00", [{
-                "day": "2026-09-13", "model": sentinels[3], "executions": 9,
-            }], runtime=sentinels[4]),
-            self.row("2026-09-13T16:00:00", [{
-                "day": "2026-09-13", "model": sentinels[5], "executions": 9,
-            }], runtime=sentinels[6]),
-            self.row("2026-09-11T16:00:00", [{
-                "day": "2026-09-11", "model": "gpt-5.2-codex", "executions": 3,
-            }], runtime="Codex"),
-            self.row("2026-09-10T16:00:00", [{
-                "day": "2026-09-10", "model": sentinels[8], "executions": 3,
-            }], runtime=sentinels[7]),
-        ])
-
-        payload = json.dumps(result, sort_keys=True)
-        for sentinel in sentinels:
-            self.assertNotIn(sentinel, payload)
-        self.assertIn("gpt-5.2-codex", payload)
-        self.assertIn("Read file", payload)
-
-    def test_public_model_projection_rejects_project_like_identifiers(self):
-        private_models = (
-            "customer-acme-project", "project-alpha", "repo-token-meter",
-            "workspace-client-a", "internal-app", "my-secret-build",
-            "gpt-5.6-customer-acme-project", "claude-project-alpha",
-            "gpt5customer", "qwen3customer", "llama3project",
-            "gemma3tenant", "starcoder2internal", "gpt5acme",
-        )
-        daily = [{
-            "day": "2026-09-13", "model": model, "executions": 9,
-        } for model in private_models]
-        daily.append({
-            "day": "2026-09-13", "model": "gpt-5.6-sol", "executions": 3,
-        })
-
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", daily, runtime="Codex"),
-        ])
-
-        payload = json.dumps(result, sort_keys=True)
-        for model in private_models:
-            self.assertNotIn(model, payload)
-        self.assertIn("gpt-5.6-sol", payload)
-
-    def test_public_model_projection_preserves_versioned_family_labels(self):
-        public_models = (
-            "qwen3-coder", "starcoder2", "llama3.3", "gemma3",
-            "deepseek-v3", "o3", "claude-sonnet-4-6", "gpt-5.6-sol",
-        )
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [{
-                "day": "2026-09-13", "model": model, "executions": 1,
-            } for model in public_models], runtime="Codex"),
-        ])
-
-        self.assertEqual(
-            {row["model"] for row in result["stack"]["models"]},
-            set(public_models),
-        )
-
-    def test_output_pace_models_and_dated_tools_are_aggregated_by_period(self):
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [{
-                "day": "2026-09-13", "model": "gpt-5.5",
-            }], runtime="Codex", _performance_samples=[{
-                "day": "2026-09-13", "output_tokens": 300, "duration_s": 30,
-            }, {
-                "day": "2026-08-31", "output_tokens": 100, "duration_s": 20,
-            }], _tool_evidence={"tools": [{"name": "read_file", "display": "Read file", "daily": [{
-                "day": "2026-09-13", "calls": 4,
-            }, {"day": "2026-08-31", "calls": 2}]}]}),
-            self.row("2026-09-12T18:00:00", [{
-                "day": "2026-09-12", "model": "gpt-5.5",
-            }], runtime="Claude"),
-        ])
-
-        pace = self.supporting(result, "output_pace")
-        self.assertEqual(pace["current"], 10.0)
-        self.assertEqual(pace["previous"], 5.0)
-        self.assertEqual(pace["delta_pct"], 100.0)
-        self.assertEqual(result["stack"]["models"], [
-            {"runtime": "Claude", "model": "gpt-5.5"},
-            {"runtime": "Codex", "model": "gpt-5.5"},
-        ])
-        self.assertEqual(result["coverage"]["tools"]["eligible"], 1)
-
-    def test_usage_rankings_are_capped_scoped_and_private(self):
-        rows = []
-        fixtures = [
-            ("Codex", "gpt-5.3-codex", (4, 3, 2, 1)),
-            ("Claude", "gpt-5.5", (3, 2, 1)),
-            ("Cursor", "cursor-small", (2, 2)),
-            ("OpenCode", "gpt-5.5", (3,)),
-        ]
-        serial = 0
-        for runtime, model, executions in fixtures:
-            for count in executions:
-                serial += 1
-                day = 13 - ((serial - 1) % 7)
-                rows.append(self.row(
-                    f"2026-09-{day:02d}T12:00:00",
-                    [{"day": f"2026-09-{day:02d}", "model": model,
-                      "executions": count}],
-                    id=f"private-session-{serial}", runtime=runtime,
-                ))
-
-        result = self.recap(rows)
-
-        self.assertEqual(result["usage"]["agents"], [
-            {"label": "Codex", "count": 4, "share": 40.0},
-            {"label": "Claude", "count": 3, "share": 30.0},
-            {"label": "Cursor", "count": 2, "share": 20.0},
-        ])
-        self.assertEqual(result["usage"]["models"], [
-            {"label": "gpt-5.3-codex", "runtime": "Codex",
-             "count": 10, "share": 43.47826086956522},
-            {"label": "gpt-5.5", "runtime": "Claude",
-             "count": 6, "share": 26.08695652173913},
-            {"label": "cursor-small", "runtime": "Cursor",
-             "count": 4, "share": 17.391304347826086},
-        ])
-        serialized = json.dumps(result["usage"], sort_keys=True)
-        self.assertNotIn("private-session", serialized)
-        self.assertNotIn("OpenCode", serialized)
-
-    def test_spotlight_eligibility_uses_safe_period_evidence(self):
-        def daily(day, model, executions=1, output=0, cost=0):
-            return {"day": day, "model": model, "executions": executions,
-                    "output_tokens": output, "cost_covered_output_tokens": output,
-                    "cost_covered_cost": cost}
-
-        result = self.recap([
-            self.row("2026-09-13T18:00:00", [
-                daily("2026-09-13", "gpt-5", 5, 900, 3),
-                daily("2026-09-12", "gpt-5", 2, 100, 1),
-            ], id="session-secret", runtime="Codex", duration_s=50,
-                wall_duration_s=9_999, duration_available=True,
-                _performance_samples=[
-                    {"day": "2026-09-13", "model": "gpt-5", "output_tokens": 600, "generation_s": 30},
-                    {"day": "2026-09-12", "model": "gpt-5", "output_tokens": 500, "generation_s": 20},
-                    {"day": "2026-09-11", "model": "gpt-5", "output_tokens": 400, "generation_s": 10},
-                ], _tool_evidence={"tools": [
-                    {"name": "read_file", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 8}]},
-                    {"name": "Token Meter diagnostics", "daily": [{"day": "2026-09-13", "calls": 99}]},
-                ]}),
-            self.row("2026-09-13T17:00:00", [daily("2026-09-13", "claude", 5, 600, 3)],
-                id="codex-second", runtime="Codex", duration_s=10, duration_available=True),
-            self.row("2026-09-12T17:00:00", [daily("2026-09-12", "claude", 5, 600, 3)],
-                id="claude-first", runtime="Claude", duration_s=20, duration_available=True),
-            self.row("2026-09-11T17:00:00", [daily("2026-09-11", "unknown-model", 9)],
-                id="claude-second", runtime="unknown", duration_s=30, duration_available=False,
-                wall_duration_s=10_000),
-            self.row("2026-09-10T17:00:00", [daily("2026-09-10", "unknown", 9)],
-                runtime="unknown", id="unknown-session"),
-        ])
-
-        self.assertEqual({row["id"] for row in result["spotlights"]}, {
-            "efficiency_record", "efficiency_change", "marathon_session",
-            "speed_champion", "build_streak", "daily_driver", "go_to_model",
-            "lines_pushed", "commits_pushed", "biggest_build", "tool_mvp",
-            "stack_explorer",
-        })
-        self.assertEqual(self.spotlight(result, "marathon_session")["current"], 50)
-        self.assertEqual(self.spotlight(result, "speed_champion")["current"], 25.0)
-        self.assertEqual(self.spotlight(result, "speed_champion")["leaders"], [
-            {"runtime": "Codex", "model": "gpt-5"},
-        ])
-        self.assertEqual(self.spotlight(result, "daily_driver")["leaders"], [
-            {"runtime": "Codex"},
-        ])
-        self.assertEqual(self.spotlight(result, "go_to_model")["leaders"], [
-            {"runtime": "Codex", "model": "gpt-5"},
-        ])
-        biggest = self.spotlight(result, "biggest_build")
-        self.assertEqual(biggest["current"], 1_000)
-        self.assertEqual(biggest["leaders"], [{"runtime": "Codex"}])
-        self.assertEqual(self.spotlight(result, "tool_mvp")["leaders"], [
-            {"tool": "Read file"},
-        ])
-        self.assertEqual(self.spotlight(result, "stack_explorer")["current"], 5)
-
-    def test_record_ties_and_auto_selection_follow_the_contract(self):
-        def paired(day, output, cost):
-            return {"day": day, "model": "gpt-5", "executions": 1,
-                    "cost_covered_output_tokens": output, "cost_covered_cost": cost}
-
-        record_rows = [self.row("2026-09-13T12:00:00", [paired("2026-09-13", 400, 1)])]
-        for day in ("2026-09-06", "2026-08-30", "2026-08-23"):
-            record_rows[0]["_model_daily"].append(paired(day, 100, 1))
-        record_result = self.recap(record_rows)
-        self.assertTrue(self.spotlight(record_result, "efficiency_record")["available"])
-        self.assertEqual(record_result["spotlight_default"], "efficiency_change")
-
-        tied = self.recap([
-            self.row("2026-09-13T12:00:00", id="a", runtime="Codex"),
-            self.row("2026-09-12T12:00:00", id="b", runtime="Claude"),
-        ])
-        self.assertEqual(self.spotlight(tied, "daily_driver")["leaders"], [
-            {"runtime": "Claude"}, {"runtime": "Codex"},
-        ])
-        three_way = self.recap([
-            self.row("2026-09-13T12:00:00", id="a", runtime="Codex"),
-            self.row("2026-09-12T12:00:00", id="b", runtime="Claude"),
-            self.row("2026-09-11T12:00:00", id="c", runtime="Cursor"),
-        ])
-        self.assertFalse(self.spotlight(three_way, "daily_driver")["available"])
-
-        tied_record = self.recap([self.row("2026-09-13T12:00:00", [
-            paired("2026-09-13", 100, 1), paired("2026-09-06", 100, 1),
-            paired("2026-08-30", 50, 1), paired("2026-08-23", 50, 1),
-        ])])
-        self.assertFalse(self.spotlight(tied_record, "efficiency_record")["available"])
-
-        streak_result = self.recap([
-            self.row("2026-09-13T12:00:00", id="a"),
-            self.row("2026-09-12T12:00:00", id="b"),
-        ])
-        self.assertEqual(streak_result["spotlight_default"], "build_streak")
-        self.assertIsNone(self.recap([])["spotlight_default"])
-
-    def test_public_recap_is_a_recursive_privacy_allowlist(self):
-        def recursive_keys(value, path=()):
-            if isinstance(value, dict):
-                for key, item in value.items():
-                    yield path + (key,)
-                    yield from recursive_keys(item, path + (key,))
-            elif isinstance(value, list):
-                for item in value:
-                    yield from recursive_keys(item, path + ("*",))
-
-        result = self.recap([self.row("2026-09-13T12:00:00", [{
-            "day": "2026-09-13", "model": "gpt-5", "executions": 1,
-            "cost_covered_output_tokens": 100, "cost_covered_cost": 1,
-            "path": "/private/repo", "project": "SECRET_PROMPT",
-        }], id="session-secret", path="/private/repo", project="SECRET_PROMPT",
-            title="commit subject", session_name="session-secret",
-            desktop_session_id="session-secret", args_fingerprint="tool result secret",
-            raw_error="tool result secret", _tool_evidence={"tools": [{
-                "name": "read_file", "id": "tool-secret", "args_fingerprint": "tool result secret",
-                "daily": [{"day": "2026-09-13", "calls": 1, "raw_error": "tool result secret"}],
-            }]} )])
-        forbidden = {"path", "project", "title", "session_name", "desktop_session_id",
-                     "args_fingerprint", "raw_error"}
-        for path in recursive_keys(result):
-            self.assertNotIn(path[-1], forbidden)
-            if path[-1] == "id":
-                self.assertIn(path[:-1], {("spotlights", "*"), ("supporting", "*"),
-                                          ("headlines", "*")})
-        payload = json.dumps(result, sort_keys=True)
-        for sentinel in ("SECRET_PROMPT", "/private/repo", "session-secret",
-                         "commit subject", "tool result secret"):
-            self.assertNotIn(sentinel, payload)
-
-    def test_tool_mvp_excludes_token_meter_mcp_and_projects_safe_display(self):
-        result = self.recap([self.row("2026-09-13T12:00:00", [], _tool_evidence={
-            "tools": [{
-                "name": "mcp__tokenmeter__diagnose", "display": "diagnose",
-                "namespace": "tokenmeter", "kind": "mcp",
-                "daily": [{"day": "2026-09-13", "calls": 99}],
-            }, {
-                "name": "read_file_v2", "display": "Read file", "namespace": "filesystem",
-                "kind": "tool", "daily": [{"day": "2026-09-13", "calls": 3}],
-            }, {
-                "name": "secret", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
-            }, {
-                "name": "password", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
-            }, {
-                "name": "authorization", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
-            }, {
-                "name": "access_token", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
-            }, {
-                "name": "mcp__safe__access_token", "display": "Read file", "daily": [{"day": "2026-09-13", "calls": 99}],
-            }],
-        })])
-
-        tool = self.spotlight(result, "tool_mvp")
-        self.assertTrue(tool["available"])
-        self.assertEqual(tool["leaders"], [{"tool": "Read file"}])
-        self.assertEqual(result["coverage"]["tools"]["eligible"], 1)
-        payload = json.dumps(result, sort_keys=True)
-        for sentinel in ("mcp__tokenmeter__diagnose", "read_file_v2", "Secret", "Password",
-                         "Authorization", "Access token"):
-            self.assertNotIn(sentinel, payload)
-
-    def test_tool_mvp_projects_unknown_provider_identifiers_to_fixed_generic_labels(self):
-        private_names = (
-            "mcp__repo__private-project-alpha",
-            "mcp__workspace__customer_acme",
-            "git_private_repo",
-        )
-        result = self.recap([self.row("2026-09-13T12:00:00", [], _tool_evidence={
-            "tools": [
-                {"name": "read_file_v2", "display": "untrusted display", "daily": [
-                    {"day": "2026-09-13", "calls": 5},
-                ]},
-                *[{"name": name, "display": "untrusted display", "daily": [
-                    {"day": "2026-09-13", "calls": 1},
-                ]} for name in private_names],
-            ],
-        })])
-
-        self.assertEqual(self.spotlight(result, "tool_mvp")["leaders"], [{"tool": "Read file"}])
-        self.assertEqual(self.spotlight(result, "tool_mvp")["current"], 5)
-        self.assertEqual(result["coverage"]["tools"]["eligible"], 3)
-        payload = json.dumps(result, sort_keys=True)
-        for private_name in private_names:
-            self.assertNotIn(private_name, payload)
-        for fragment in ("private-project-alpha", "customer_acme", "private repo"):
-            self.assertNotIn(fragment, payload)
-
-    def headline(self, result, headline_id):
-        return next((item for item in result["headlines"] if item["id"] == headline_id), None)
-
-    def test_headlines_are_absent_without_evidence(self):
-        result = self.recap([], days=30)
-        self.assertEqual(result["headlines"], [])
-        # One session and one day prove no identity, streak, week, or cache claim.
-        single = self.recap([self.row("2026-09-13T12:00:00", [{
-            "day": "2026-09-13", "model": "gpt-5", "executions": 1,
-            "input_tokens": 100, "cache_read_tokens": 0,
-            "cost_covered_output_tokens": 100, "cost_covered_cost": 1,
-        }], id="only")], days=30)
-        self.assertEqual(single["headlines"], [])
-
-    def test_identity_headline_requires_sixty_percent_of_sessions(self):
-        rows = [self.row(f"2026-09-{13 - index:02d}T12:00:00", id=f"claude-{index}",
-                         runtime="Claude Code") for index in range(6)]
-        rows += [self.row("2026-09-01T12:00:00", id=f"codex-{index}") for index in range(4)]
-        at_threshold = self.headline(self.recap(rows, days=30), "identity")
-        self.assertEqual(at_threshold, {
-            "id": "identity", "title": "A Claude person", "value": "60%",
-            "detail": "of sessions on Claude Code",
-        })
-        below = self.recap(rows + [self.row("2026-09-02T12:00:00", id="codex-x")], days=30)
-        self.assertIsNone(self.headline(below, "identity"))
-        vowel = self.headline(self.recap([
-            self.row("2026-09-13T12:00:00", id=f"oc-{index}", runtime="OpenCode")
-            for index in range(3)
-        ], days=7), "identity")
-        self.assertEqual((vowel["title"], vowel["value"]), ("An OpenCode person", "100%"))
-        # Rounding never overstates a share.
-        rows = [self.row("2026-09-13T12:00:00", id=f"c-{index}", runtime="Claude Code")
-                for index in range(2)] + [self.row("2026-09-13T12:00:00", id="x")]
-        self.assertEqual(self.headline(self.recap(rows), "identity")["value"], "66%")
-
-    def test_streak_headline_reports_the_longest_run_of_three_or_more_days(self):
-        two = self.recap([self.row("2026-09-13T12:00:00", id="a"),
-                          self.row("2026-09-12T12:00:00", id="b")])
-        self.assertIsNone(self.headline(two, "streak"))
-        four = self.recap([self.row(f"2026-09-{day:02d}T12:00:00", id=str(day))
-                           for day in (13, 12, 11, 10, 8)])
-        self.assertEqual(self.headline(four, "streak"), {
-            "id": "streak", "title": "Longest streak", "value": "4 days",
-            "detail": "consecutive active days",
-        })
-
-    def test_best_week_headline_compares_comparable_weeks_and_says_estimate(self):
-        def day(value, output, cost):
-            return {"day": value, "model": "gpt-5", "executions": 1,
-                    "cost_covered_output_tokens": output, "cost_covered_cost": cost}
-        rows = [self.row("2026-09-13T12:00:00", [
-            day("2026-09-13", 3000, 1), day("2026-09-05", 1000, 1),
-            day("2026-08-29", 1000, 1),
-        ], id="weeks")]
-        best = self.headline(self.recap(rows, days=30), "best_week")
-        self.assertEqual(best["title"], "Best week")
-        self.assertEqual(best["value"], "3.0×")
-        self.assertIn("estimate", best["detail"])
-        # A 7-day period has one week, so there is nothing to compare against.
-        self.assertIsNone(self.headline(self.recap(rows, days=7), "best_week"))
-        flat = [self.row("2026-09-13T12:00:00", [
-            day("2026-09-13", 1000, 1), day("2026-09-05", 1000, 1),
-        ], id="flat")]
-        self.assertIsNone(self.headline(self.recap(flat, days=30), "best_week"))
-
-    def test_cache_share_headline_uses_only_cache_covered_input(self):
-        rows = [self.row("2026-09-13T12:00:00", [{
-            "day": "2026-09-13", "model": "gpt-5", "executions": 2,
-            "input_tokens": 1000, "cache_read_tokens": 875,
-        }, {
-            "day": "2026-09-13", "model": "gpt-5-mini", "executions": 1,
-            "input_tokens": 5000, "cache_read_tokens": 0,
-            "availability": {"cache": False},
-        }], id="cached")]
-        self.assertEqual(self.headline(self.recap(rows), "cache_share"), {
-            "id": "cache_share", "title": "Cache-powered", "value": "87%",
-            "detail": "of input tokens read from cache",
-        })
-        uncovered = [self.row("2026-09-13T12:00:00", [{
-            "day": "2026-09-13", "model": "gpt-5", "executions": 1,
-            "input_tokens": 1000, "cache_read_tokens": 900,
-        }], id="none", availability={"cache": False})]
-        self.assertIsNone(self.headline(self.recap(uncovered), "cache_share"))
-
-    def test_headlines_are_bounded_ordered_and_content_free(self):
-        rows = [self.row(f"2026-09-{13 - index:02d}T12:00:00", [{
-            "day": f"2026-09-{13 - index:02d}", "model": "claude-sonnet-4-5", "executions": 1,
-            "input_tokens": 1000, "cache_read_tokens": 900,
-            "cost_covered_output_tokens": 1000 * (index + 1), "cost_covered_cost": 1,
-        }], id=f"secret-session-{index}", runtime="Claude Code",
-            project="/private/repo", title="SECRET_PROMPT") for index in range(12)]
-        result = self.recap(rows, days=30)
-        self.assertEqual([item["id"] for item in result["headlines"]],
-                         ["identity", "best_week", "streak", "cache_share"])
-        self.assertLessEqual(len(result["headlines"]), 4)
-        for item in result["headlines"]:
-            self.assertEqual(sorted(item), ["detail", "id", "title", "value"])
-            self.assertTrue(all(isinstance(item[key], str) and len(item[key]) <= 48
-                                for key in item))
-        payload = json.dumps(result["headlines"])
-        for sentinel in ("secret-session", "/private/repo", "SECRET_PROMPT", "percentile"):
-            self.assertNotIn(sentinel, payload)
-
-
-class BuilderRecapEndpointTests(unittest.TestCase):
-    def setUp(self):
-        self.saved_cache = dict(meter._xsess)
-
-    def tearDown(self):
-        meter._xsess.clear()
-        meter._xsess.update(self.saved_cache)
-
-    def test_builder_recap_state_reduces_git_evidence_before_public_build(self):
-        expected = {"ok": True, "generated_at": 123, "privacy": {
-            "content_included": False, "project_identity_included": False,
-        }}
-        meter._xsess["internal_rows"] = [{"id": "private"}]
-        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
-                mock.patch.object(meter, "git_delivery_state", return_value={
-                    "ok": True,
-                    "previous": {
-                        "changed_lines": 8, "commits": 2,
-                        "availability": {"code_pushed": True},
-                        "project": "/private/previous", "subject": "secret previous",
-                    },
-                    "days": [{
-                        "day": "2026-09-13", "changed_lines": 12, "commits": 3,
-                        "availability": {"code_pushed": True},
-                        "project": "/private/repo", "subject": "secret",
-                    }],
-                }), \
-                mock.patch.object(meter, "_domain_build_builder_recap", return_value=expected) as build:
-            payload, status = meter.builder_recap_state("30")
-
-        self.assertEqual(status, 200)
-        self.assertEqual(payload, expected)
-        build.assert_called_once()
-        self.assertEqual(build.call_args.args[0], [{"id": "private"}])
-        self.assertEqual(build.call_args.args[1], [{
-            "day": "2026-09-13", "available": True, "active": True,
-            "changed_lines": 12, "commits": 3,
-        }])
-        self.assertEqual(build.call_args.args[2], 30)
-        self.assertEqual(build.call_args.kwargs["generated_at"], 123)
-        self.assertEqual(build.call_args.kwargs["previous_git_lines"], 8)
-        self.assertEqual(build.call_args.kwargs["previous_git_commits"], 2)
-        self.assertNotIn("/private/repo", json.dumps(build.call_args.args[1]))
-        self.assertNotIn("secret", json.dumps(build.call_args.args[1]))
-        self.assertNotIn("private/previous", json.dumps(build.call_args.kwargs))
-
-    def test_builder_recap_state_fails_closed_on_malformed_changed_line_counts(self):
-        meter._xsess["internal_rows"] = []
-        malformed = (True, -1, 1.5, float("inf"), "999", 10 ** 1000)
-        days = [{
-            "day": f"2026-09-{13 - index:02d}", "changed_lines": value,
-            "commits": value, "availability": {"code_pushed": True},
-        } for index, value in enumerate(malformed)]
-        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
-                mock.patch.object(meter, "git_delivery_state", return_value={
-                    "ok": True, "days": days,
-                    "previous": {
-                        "changed_lines": "999", "commits": 1.5,
-                        "availability": {"code_pushed": True},
-                    },
-                }), \
-                mock.patch.object(meter, "_domain_build_builder_recap", return_value={"ok": True}) as build:
-            payload, status = meter.builder_recap_state("30")
-
-        self.assertEqual((payload, status), ({"ok": True}, 200))
-        projected = build.call_args.args[1]
-        self.assertEqual(len(projected), len(malformed))
-        self.assertTrue(all(row["changed_lines"] is None for row in projected))
-        self.assertTrue(all(row["commits"] is None for row in projected))
-        self.assertIsNone(build.call_args.kwargs["previous_git_lines"])
-        self.assertIsNone(build.call_args.kwargs["previous_git_commits"])
-
-    def test_builder_recap_state_marks_git_failures_unavailable(self):
-        meter._xsess["internal_rows"] = [{"id": "private"}]
-        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
-                mock.patch.object(meter, "git_delivery_state", return_value={
-                    "ok": False, "error": "private git failure",
-                }), \
-                mock.patch.object(meter, "_domain_build_builder_recap", return_value={"ok": True}) as build:
-            payload, status = meter.builder_recap_state("7")
-
-        self.assertEqual((payload, status), ({"ok": True}, 200))
-        self.assertIsNone(build.call_args.args[1])
-
-    def test_builder_recap_state_rejects_invalid_ranges_without_discovery(self):
-        for value in ("", "14", "30.0", "seven"):
-            with self.subTest(value=value), \
-                    mock.patch.object(meter, "cross_session") as cross, \
-                    mock.patch.object(meter, "git_delivery_state") as git, \
-                    mock.patch.object(meter, "_domain_build_builder_recap") as build:
-                payload, status = meter.builder_recap_state(value)
-            self.assertEqual(status, 400)
-            self.assertEqual(payload, {
-                "ok": False, "error": "A valid recap range is required.",
-            })
-            cross.assert_not_called()
-            git.assert_not_called()
-            build.assert_not_called()
-
-    def request(self, path):
-        server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
-        thread = threading.Thread(target=server.serve_forever, daemon=True)
-        thread.start()
-        try:
-            conn = http.client.HTTPConnection("127.0.0.1", server.server_port, timeout=5)
-            conn.request("GET", path)
-            response = conn.getresponse()
-            payload = json.loads(response.read())
-            status = response.status
-            content_type = response.getheader("Content-Type")
-            conn.close()
-            return payload, status, content_type
-        finally:
-            server.shutdown()
-            server.server_close()
-            thread.join(timeout=5)
-
-    def test_builder_recap_http_route_defaults_validates_and_returns_json(self):
-        meter._xsess["internal_rows"] = [{
-            "id": "private-session", "path": "/private/trace.jsonl",
-            "project": "/private/repo", "title": "private title",
-            "last": "2026-09-13T12:00:00", "runtime": "Codex",
-        }]
-        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}) as cross, \
-                mock.patch.object(meter, "git_delivery_state", return_value={"ok": True, "days": []}) as git:
-            valid, valid_status, valid_type = self.request("/builder-recap?range=7")
-            default, default_status, _ = self.request("/builder-recap")
-            invalid, invalid_status, _ = self.request("/builder-recap?range=14")
-            repeated, repeated_status, _ = self.request("/builder-recap?range=7&range=30")
-            cross.reset_mock()
-            git.reset_mock()
-            blanks = [
-                self.request("/builder-recap?range="),
-                self.request("/builder-recap?range=7&range="),
-                self.request("/builder-recap?range=&range=30"),
-            ]
-
-        self.assertEqual((valid_status, valid_type), (200, "application/json"))
-        self.assertEqual(valid["range_days"], 7)
-        self.assertEqual(valid["privacy"], {
-            "content_included": False, "project_identity_included": False,
-        })
-        for sentinel in ("private-session", "/private/trace.jsonl", "/private/repo", "private title"):
-            self.assertNotIn(sentinel, json.dumps(valid, sort_keys=True))
-        self.assertEqual((default_status, default["range_days"]), (200, 30))
-        for payload, status in ((invalid, invalid_status), (repeated, repeated_status)):
-            self.assertEqual(status, 400)
-            self.assertEqual(payload, {
-                "ok": False, "error": "A valid recap range is required.",
-            })
-            self.assertNotIn("private", json.dumps(payload))
-        for payload, status, _ in blanks:
-            self.assertEqual(status, 400)
-            self.assertEqual(payload, {
-                "ok": False, "error": "A valid recap range is required.",
-            })
-        cross.assert_not_called()
-        git.assert_not_called()
-
-        source = Path(meter.IMPLEMENTATION_FILE).read_text()
-        self.assertIn('elif req_path == "/builder-recap":', source)
-        self.assertIn("builder_recap_state(range_values[0])", source)
-        post_source = source[source.index("def do_POST"):source.index("def do_GET")]
-        self.assertNotIn('req_path == "/builder-recap"', post_source)
-
-    def test_builder_recap_http_payload_rejects_unsafe_runtime_model_and_tool_labels(self):
-        sentinels = ("https://private.example", "/private/model", "sk-live-secret",
-                     "api_key=private", "<private-label>")
-        meter._xsess["internal_rows"] = [{
-            "last": "2026-09-13T12:00:00", "runtime": sentinels[0],
-            "_model_daily": [{"day": "2026-09-13", "model": sentinels[1], "executions": 3}],
-            "_performance_samples": [{"day": "2026-09-13", "model": sentinels[2],
-                                      "output_tokens": 1000, "duration_s": 10}],
-            "_tool_evidence": {"tools": [{"name": "read_file", "display": sentinels[3],
-                                              "daily": [{"day": "2026-09-13", "calls": 2}]},
-                                             {"name": "read_file", "display": sentinels[4],
-                                              "daily": [{"day": "2026-09-13", "calls": 2}]}]},
-        }]
-        with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}), \
-                mock.patch.object(meter, "git_delivery_state", return_value={"ok": True, "days": []}):
-            payload, status, _ = self.request("/builder-recap?range=7")
-
-        self.assertEqual(status, 200)
-        serialized = json.dumps(payload, sort_keys=True)
-        for sentinel in sentinels:
-            self.assertNotIn(sentinel, serialized)
-
-
-class BuilderRecapStandalonePageTests(unittest.TestCase):
-    def request(self, method, path):
-        server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
-        thread = threading.Thread(target=server.serve_forever, daemon=True)
-        thread.start()
-        try:
-            conn = http.client.HTTPConnection(
-                "127.0.0.1", server.server_port, timeout=5,
-            )
-            conn.request(method, path)
-            response = conn.getresponse()
-            body = response.read()
-            result = {
-                "status": response.status,
-                "type": response.getheader("Content-Type"),
-                "length": response.getheader("Content-Length"),
-                "cache": response.getheader("Cache-Control"),
-                "body": body,
-            }
-            conn.close()
-            return result
-        finally:
-            server.shutdown()
-            server.server_close()
-            thread.join(timeout=5)
-
-    def test_performance_document_routes_and_manifest(self):
-        manifest = Path(meter.__file__).with_name("runtime-manifest.txt").read_text()
-        self.assertIn("required performance.html", manifest.splitlines())
-
-        with tempfile.TemporaryDirectory() as tmp:
-            page = Path(tmp) / "performance.html"
-            page.write_text("<!doctype html><title>Builder recap</title>")
-            with mock.patch.object(
-                    meter, "performance_page_path", return_value=str(page),
-                    create=True):
-                direct = self.request("GET", "/performance")
-                alias = self.request("GET", "/performance.html")
-                head = self.request("HEAD", "/performance")
-
-            for response in (direct, alias):
-                self.assertEqual(response["status"], 200)
-                self.assertEqual(response["type"], "text/html; charset=utf-8")
-                self.assertEqual(response["cache"], "no-store, max-age=0")
-                self.assertEqual(response["body"], page.read_bytes())
-            self.assertEqual(head["status"], 200)
-            self.assertEqual(head["body"], b"")
-            self.assertEqual(head["length"], str(page.stat().st_size))
-            self.assertEqual(head["cache"], "no-store, max-age=0")
-
-            with mock.patch.object(
-                    meter, "performance_page_path", return_value=None,
-                    create=True):
-                missing = self.request("GET", "/performance")
-            self.assertEqual(missing["status"], 503)
-            self.assertIn(b"performance.html is missing", missing["body"])
-            self.assertNotIn(str(tmp).encode(), missing["body"])
-
-    def test_standalone_page_declares_inline_svg_favicon(self):
-        class IconInventory(HTMLParser):
-            def __init__(self):
-                super().__init__()
-                self.icons = []
-
-            def handle_starttag(self, tag, attrs):
-                attributes = dict(attrs)
-                if tag == "link" and "icon" in attributes.get("rel", "").split():
-                    self.icons.append(attributes)
-
-        page = Path(meter.__file__).with_name("performance.html").read_text()
-        markup = IconInventory()
-        markup.feed(page)
-
-        self.assertEqual(len(markup.icons), 1)
-        self.assertEqual(markup.icons[0]["type"], "image/svg+xml")
-        self.assertTrue(markup.icons[0]["href"].startswith("data:image/svg+xml,"))
-
-    def test_standalone_studio_has_the_approved_controls_and_no_remote_assets(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        self.assertTrue(page_path.is_file())
-        page = page_path.read_text()
-        for marker in (
-            'href="/#subagents"', 'href="/#efficiency"', 'id=range-controls', 'data-range=7',
-            'data-range=30', 'data-range=90',
-            '<span>Name</span><input id=builder-name maxlength=40',
-            'id=include-usage type=checkbox', 'id=reset type=button',
-            'id=retry type=button hidden',
-            'id=download type=button disabled>Download PNG</button>',
-            'id=poster width=1080 height=1350 role=img',
-            'id=status role=status aria-live=polite',
-            'function drawBuilderRecap(', 'function loadRecap(',
-            '/builder-recap?range=', 'github.com/splunk/token-meter',
-            '@media(max-width:1024px)',
-        ):
-            self.assertIn(marker, page)
-        self.assertEqual(page.count("function drawBuilderRecap("), 1)
-        self.assertNotRegex(page, r'<(?:script|img|link)[^>]+(?:src|href)=["\']https?://')
-        self.assertNotIn("foreignObject", page)
-        # Only the shared theme boot script may read storage; the studio never persists builder input.
-        self.assertNotIn("localStorage", re.sub(r"<script id=theme-boot>.*?</script>", "", page, flags=re.S))
-        self.assertNotIn("Display name", page)
-        self.assertNotIn("id=spotlight", page)
-        self.assertNotIn("id=include-git", page)
-
-    def test_standalone_studio_uses_the_spectrum_shell_and_compact_editor(self):
-        class MarkupInventory(HTMLParser):
-            def __init__(self):
-                super().__init__()
-                self.body_classes = set()
-                self.by_id = {}
-
-            def handle_starttag(self, tag, attrs):
-                attributes = dict(attrs)
-                if tag == "body":
-                    self.body_classes.update(attributes.get("class", "").split())
-                if attributes.get("id"):
-                    self.by_id[attributes["id"]] = (tag, attributes)
-
-        page = Path(meter.__file__).with_name("performance.html").read_text()
-        markup = MarkupInventory()
-        markup.feed(page)
-
-        self.assertTrue({"spectrumApp", "performanceApp"}.issubset(markup.body_classes))
-        self.assertEqual(markup.by_id["performance-rail"][0], "aside")
-        self.assertEqual(
-            markup.by_id["performance-rail"][1]["aria-label"],
-            "Token Meter navigation",
-        )
-        self.assertEqual(markup.by_id["performance-navigation"][0], "nav")
-        performance = markup.by_id["tab-performance"]
-        self.assertEqual(performance[0], "a")
-        self.assertEqual(performance[1]["href"], "/performance")
-        self.assertEqual(performance[1]["aria-current"], "page")
-        self.assertEqual(markup.by_id["performance-surface"][0], "main")
-        self.assertEqual(markup.by_id["performance-header"][0], "header")
-        self.assertIn("<title>Token Meter — Performance card</title>", page)
-        self.assertIn("<h1>Performance card</h1>", page)
-        self.assertIn("<span class=railLabel>Performance</span>", page)
-        self.assertNotIn("headerMeta", page)
-        self.assertNotIn("<strong>4:5</strong>", page)
-        self.assertEqual(markup.by_id["performance-controls"][0], "section")
-        self.assertEqual(
-            markup.by_id["performance-controls"][1]["aria-label"],
-            "Performance controls",
-        )
-        self.assertEqual(markup.by_id["performance-preview"][0], "section")
-        logo = markup.by_id["performance-card-logo"]
-        self.assertEqual(logo[0], "img")
-        self.assertEqual(
-            logo[1]["src"], "/assets/brand/logo-splunk-by-cisco-rgb-w.png",
-        )
-        self.assertIn("hidden", logo[1])
-        self.assertIn("<div class=studioWorkspace>", page)
-        workspace_start = page.index("<div class=studioWorkspace>")
-        controls_start = page.index(
-            "<section class=controlDock id=performance-controls",
-        )
-        preview_start = page.index(
-            "<section class=stage id=performance-preview",
-        )
-        self.assertLess(workspace_start, controls_start)
-        self.assertLess(controls_start, preview_start)
-        self.assertIn(
-            ".studioWorkspace{display:grid;grid-template-columns:220px minmax(0,1fr)",
-            page,
-        )
-        self.assertNotIn("evidence-note", markup.by_id)
-        self.assertEqual(markup.by_id["status"][1]["role"], "status")
-        primary = page.split("<div class=railPrimary>", 1)[1].split("</div>", 1)[0]
-        self.assertLess(primary.index('href="/#models"'), primary.index('href="/#subagents"'))
-        self.assertLess(primary.index('href="/#subagents"'), primary.index('href="/#efficiency"'))
-        self.assertLess(primary.index('href="/#efficiency"'), primary.index('href="/#work"'))
-        self.assertLess(primary.index('href="/#work"'), primary.index('href="/#git"'))
-        self.assertLess(primary.index('href="/#git"'), primary.index("id=tab-performance"))
-        # Work appears only where the dashboard shows it.
-        self.assertIn('id=rail-work href="/#work" aria-label=Work title=Work hidden>', primary)
-        self.assertIn("$('rail-work').hidden=payload?.settings?.supported!==true;", page)
-        self.assertNotIn("Make it yours.", page)
-        self.assertNotIn("Builder Recap Studio", page)
-
-    def assert_measured_grid(self, cells):
-        """Equal columns span 72-1008 exactly and share every text baseline."""
-        self.assertTrue(cells)
-        self.assertEqual(cells[0]["x"], 72)
-        self.assertEqual(cells[-1]["x"] + cells[-1]["width"], 1008)
-        self.assertLessEqual(max(c["width"] for c in cells) - min(c["width"] for c in cells), 1)
-        gaps = [b["x"] - (a["x"] + a["width"]) for a, b in zip(cells, cells[1:])]
-        if gaps:
-            self.assertLessEqual(max(gaps) - min(gaps), 1)
-        for key in ("valueY", "labelY", "subY", "size"):
-            self.assertEqual(len({cell[key] for cell in cells}), 1, key)
-        for cell in cells:
-            self.assertIsNotNone(cell["value"], cell)
-            self.assertIsNotNone(cell["label"], cell)
-            self.assertIn(f"{cell['size']}px", cell["font"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for canvas verification")
-    def test_standalone_canvas_formats_and_aligns_metric_values(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap'])eval(extract(name));
-class Gradient{{constructor(kind,coords){{this.kind=kind;this.coords=coords;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
-class Context{{constructor(){{this.ops=[];this.font='';}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}drawImage(image,...v){{this.ops.push(['image',image.src,...v]);}}createLinearGradient(...c){{return new Gradient('linear',c);}}createRadialGradient(...c){{return new Gradient('radial',c);}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}arc(){{}}stroke(){{}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}}}
-class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
-const payload={{range_days:30,current:{{end_day:'2026-09-13'}},spotlights:[
- {{id:'lines_pushed',available:true,current:184392,unit:'lines'}},
- {{id:'efficiency_change',label:'Output efficiency',available:true,current:2680,unit:'output tokens/$'}},
- {{id:'speed_champion',label:'Fastest model',available:true,current:42.8,unit:'output tokens/s',leaders:[{{model:'gpt-5.3'}}]}},
- {{id:'marathon_session',label:'Longest session',available:true,current:24120,unit:'seconds'}},
- {{id:'build_streak',available:true,current:14,unit:'days'}}
-],supporting:[{{id:'sessions',label:'AI coding sessions',available:true,current:126,unit:'sessions'}},{{id:'covered_spend',label:'Covered equivalent spend',family:'cost',available:true,current:2176.88,previous:null,delta_pct:null,unit:'USD'}}],activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<24}})),usage:{{agents:[],models:[]}}}};
-const canvas=new Canvas();
-function cellsOf(target,result){{return result.layout.stats.map(cell=>{{const at=(y)=>target.ctx.ops.find(op=>op[0]==='text'&&op[2]===cell.x&&op[3]===y);const value=at(cell.valueY),label=at(cell.labelY),sub=at(cell.subY);return {{id:cell.id,x:cell.x,width:cell.width,valueY:cell.valueY,labelY:cell.labelY,subY:cell.subY,size:cell.size,value:value&&value[1],font:value&&value[4],label:label&&label[1],sub:sub?sub[1]:''}};}});}}
-const mainResult=drawBuilderRecap(canvas,payload,{{name:'Ada Builder',includeUsage:true,logo:{{src:'/assets/brand/logo-splunk-by-cisco-rgb-w.png',complete:true,naturalWidth:1024}}}});
-const textOps=canvas.ctx.ops.filter(op=>op[0]==='text');
-const missingPayload=JSON.parse(JSON.stringify(payload));missingPayload.supporting=[];const missingCanvas=new Canvas(),missingResult=drawBuilderRecap(missingCanvas,missingPayload,{{name:'',includeUsage:true}});
-const unavailableSpeedPayload=JSON.parse(JSON.stringify(payload));unavailableSpeedPayload.spotlights.find(stat=>stat.id==='speed_champion').available=false;const unavailableSpeedCanvas=new Canvas(),unavailableSpeedResult=drawBuilderRecap(unavailableSpeedCanvas,unavailableSpeedPayload,{{name:'',includeUsage:true}});
-const pickedCanvas=new Canvas(),pickedResult=drawBuilderRecap(pickedCanvas,payload,{{name:'',includeUsage:true,stats:['marathon_session','tool_calls','active_days']}});
-const sixCanvas=new Canvas(),sixResult=drawBuilderRecap(sixCanvas,payload,{{name:'',includeUsage:true,stats:['active_days','efficiency_change','speed_champion','sessions','covered_spend','marathon_session']}});
-const longPayload=JSON.parse(JSON.stringify(payload));longPayload.supporting.find(stat=>stat.id==='sessions').current=1.2345678901234567e20;const longCanvas=new Canvas(),longResult=drawBuilderRecap(longCanvas,longPayload,{{name:'',includeUsage:true}});
-class InkContext extends Context{{measureText(v){{return {{...super.measureText(v),actualBoundingBoxLeft:-6,actualBoundingBoxRight:-3}};}}}}
-const inkCanvas=new Canvas();inkCanvas.ctx=new InkContext();drawBuilderRecap(inkCanvas,payload,{{name:'',includeUsage:true}});const inkOps=inkCanvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===486).map(op=>[op[1],op[2]]);
-console.log(JSON.stringify({{texts:textOps.map(op=>op[1]),logos:canvas.ctx.ops.filter(op=>op[0]==='image'),cells:cellsOf(canvas,mainResult),missingCells:cellsOf(missingCanvas,missingResult),unavailableSpeedCells:cellsOf(unavailableSpeedCanvas,unavailableSpeedResult),pickedCells:cellsOf(pickedCanvas,pickedResult),pickedTexts:pickedCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),sixCells:cellsOf(sixCanvas,sixResult),longCells:cellsOf(longCanvas,longResult),inkOps,ghost:textOps.filter(op=>String(op[4]).includes('330px')),aria:canvas.attrs['aria-label'],missingAria:missingCanvas.attrs['aria-label'],missingTexts:missingCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),commitOp:textOps.find(op=>op[2]===1008&&op[3]===486)}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        cells = rendered["cells"]
-        self.assertEqual(
-            [(cell["label"], cell["value"]) for cell in cells],
-            [("ACTIVE DAYS", "24/30"), ("OUTPUT EFFICIENCY", "2.68 K/$"),
-             ("FASTEST MODEL", "42.8 TOK/S"), ("AI SESSIONS", "126"),
-             ("EQUIV. SPEND", "$2.18K")],
-        )
-        self.assert_measured_grid(cells)
-        self.assertEqual([cell["sub"] for cell in cells],
-                         ["14 DAY STREAK", "", "GPT-5.3", "", "ESTIMATE"])
-        self.assertIn("30D", rendered["texts"])
-        self.assertEqual(rendered["ghost"], [])
-        visible = " ".join(rendered["texts"])
-        self.assertNotIn("LONGEST SESSION", visible)
-        self.assertNotIn("6H 42M", visible)
-        self.assertEqual(rendered["texts"].count("LINES PUSHED"), 1)
-        self.assertNotIn("LINES", rendered["texts"])
-        self.assertEqual(rendered["logos"], [[
-            "image", "/assets/brand/logo-splunk-by-cisco-rgb-w.png",
-            72, 46, 148, 54,
-        ]])
-        self.assertIn("TOKEN METER", rendered["texts"])
-        self.assertIn("PERFORMANCE CARD", rendered["texts"])
-        self.assertNotIn("TOKEN METER / PERFORMANCE", rendered["texts"])
-        self.assertNotIn("2.68K", rendered["texts"])
-        self.assertNotIn("Longest session", rendered["aria"])
-        self.assertIn("AI sessions 126.", rendered["aria"])
-        self.assertIn(
-            "Covered equivalent spend $2.18K, an estimate.", rendered["aria"],
-        )
-        self.assertIn("AI sessions unavailable.", rendered["missingAria"])
-        self.assertIn(
-            "Covered equivalent spend unavailable.", rendered["missingAria"],
-        )
-        # Unavailable evidence is omitted, not drawn as a zero or a dash, and the
-        # remaining columns redistribute across the full content measure.
-        self.assertEqual([cell["id"] for cell in rendered["missingCells"]],
-                         ["active_days", "efficiency_change", "speed_champion"])
-        self.assert_measured_grid(rendered["missingCells"])
-        self.assertNotIn("—", [cell["value"] for cell in rendered["missingCells"]])
-        self.assertNotIn("EQUIV. SPEND", rendered["missingTexts"])
-        self.assertEqual([cell["id"] for cell in rendered["unavailableSpeedCells"]],
-                         ["active_days", "efficiency_change", "sessions", "covered_spend"])
-        self.assert_measured_grid(rendered["unavailableSpeedCells"])
-        # Toggles pick cells in catalog order; unavailable picks drop out.
-        self.assertEqual([(cell["label"], cell["value"]) for cell in rendered["pickedCells"]],
-                         [("ACTIVE DAYS", "24/30"), ("LONGEST SESSION", "6H 42M")])
-        self.assert_measured_grid(rendered["pickedCells"])
-        self.assertNotIn("OUTPUT EFFICIENCY", rendered["pickedTexts"])
-        self.assertEqual(len(rendered["sixCells"]), 5)
-        self.assertNotIn("marathon_session", [cell["id"] for cell in rendered["sixCells"]])
-        # A value that cannot fit steps the whole row down to the floor before
-        # it ellipsizes; it never overflows its column.
-        long_cells = rendered["longCells"]
-        self.assertEqual({cell["size"] for cell in long_cells}, {24})
-        self.assertTrue(long_cells[3]["value"].endswith("…"))
-        self.assertEqual(long_cells[0]["value"], "24/30")
-        # Display numerals align by measured ink, not by their advance box.
-        self.assertEqual(rendered["inkOps"], [["184,392", 66], ["—", 1011]])
-        # Absent commit evidence must read as unavailable, never a measured zero.
-        self.assertEqual(rendered["commitOp"][1:4], ["—", 1008, 486])
-        self.assertIn("Commits pushed unavailable.", rendered["aria"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for headline verification")
-    def test_standalone_headline_band_rhythm_and_controls(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        names = ['safeArray', 'sanitizeBuilderName', 'compactNumber', 'durationLabel', 'formatStat',
-                 'formatSpend', 'ellipsize', 'fitText', 'gradientFill', 'radialFill', 'fillRoundedRect',
-                 'setTracking', 'cardPalette', 'ditherRegion', 'supportingStats', 'inkX', 'posterStatLimit',
-                 'defaultPosterStats', 'posterStatCatalog', 'findRecapStat', 'posterStatCells',
-                 'resolveHeadline', 'paperLayout', 'headlineBandHeight', 'statRowHeight',
-                 'usageBlockHeight', 'drawHeadlineBand', 'drawStatRow', 'drawUsageGroup',
-                 'drawBuilderRecap', 'renderControls', 'resetRecap']
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-for(const name of {json.dumps(names)})eval(extract(name));
-class Gradient{{constructor(kind){{this.kind=kind;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
-class Context{{constructor(){{this.ops=[];this.font='';}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}drawImage(){{}}createLinearGradient(){{return new Gradient('linear');}}createRadialGradient(){{return new Gradient('radial');}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}roundRect(...v){{this.ops.push(['round',...v]);}}fill(){{}}}}
-class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
-const payload={{range_days:30,current:{{end_day:'2026-09-13'}},spotlights:[{{id:'lines_pushed',available:true,current:184392,unit:'lines'}},{{id:'efficiency_change',available:true,current:2680,unit:'output tokens/$'}},{{id:'speed_champion',available:true,current:42.8,unit:'output tokens/s',leaders:[{{model:'gpt-5.3'}}]}},{{id:'build_streak',available:true,current:14,unit:'days'}}],supporting:[{{id:'sessions',available:true,current:126,unit:'sessions'}},{{id:'covered_spend',available:true,current:2176.88,unit:'USD'}}],
- headlines:[{{id:'identity',title:'A Claude person',value:'92%',detail:'of sessions on Claude Code'}},{{id:'streak',title:'Longest streak',value:'14 days',detail:'consecutive active days'}}],
- activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<24}})),usage:{{agents:[{{label:'Claude Code',share:92}},{{label:'Codex',share:8}}],models:[{{label:'sonnet-4.5',runtime:'Claude Code',share:70}},{{label:'opus-4.1',runtime:'Claude Code',share:20}},{{label:'gpt-5.3',runtime:'Codex',share:10}}]}}}};
-function draw(options){{const canvas=new Canvas(),result=drawBuilderRecap(canvas,payload,options);return {{result,texts:canvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),aria:canvas.attrs['aria-label'],ops:canvas.ctx.ops}};}}
-const auto=draw({{name:'',includeUsage:true}}),streak=draw({{name:'',includeUsage:true,headline:'streak'}}),none=draw({{name:'',includeUsage:true,headline:'none'}}),stale=draw({{name:'',includeUsage:true,headline:'best_week'}}),bare=draw({{name:'',includeUsage:false,headline:'none'}});
-const band=auto.result.layout.headline,bandRect=auto.ops.find(op=>op[0]==='round'&&op[1]===72&&op[3]===936);
-class Control{{constructor(stat){{this.disabled=false;this.checked=false;this.value='';this.textContent='';this.children=[];this.dataset=stat?{{stat}}:{{}};}}appendChild(child){{this.children.push(child);}}}}
-const statInputs=posterStatCatalog().map(entry=>new Control(entry.id)),controls={{'builder-name':new Control(),'include-usage':new Control(),'headline-select':new Control()}},$=id=>controls[id];
-const document={{querySelectorAll:selector=>selector==='[data-stat]'?statInputs:[],createElement:()=>new Control()}};
-const builderRecapState={{range:30,name:'',includeUsage:true,headline:'streak',stats:defaultPosterStats(),payload}};
-renderControls(payload);
-const select=controls['headline-select'],controlState={{options:select.children.map(option=>[option.value,option.textContent]),value:select.value,stats:statInputs.map(input=>[input.dataset.stat,input.checked,input.disabled])}};
-builderRecapState.headline='gone';renderControls(payload);const staleValue=select.value;
-builderRecapState.stats=['active_days'];builderRecapState.headline='none';let loads=0;function loadRecap(){{loads++;}}resetRecap();
-console.log(JSON.stringify({{auto:{{texts:auto.texts,aria:auto.aria,layout:auto.result.layout}},band,bandRect,streakTexts:streak.texts,noneLayout:none.result.layout,noneTexts:none.texts,staleTexts:stale.texts,bareLayout:bare.result.layout,controlState,staleValue,reset:{{headline:builderRecapState.headline,stats:builderRecapState.stats,loads}}}}));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=False)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        # Auto picks the first (highest-priority) candidate and draws it as a band.
-        for text in ("92%", "A CLAUDE PERSON", "OF SESSIONS ON CLAUDE CODE"):
-            self.assertIn(text, rendered["auto"]["texts"])
-        self.assertIn("Headline A Claude person: 92% of sessions on Claude Code.", rendered["auto"]["aria"])
-        band = rendered["band"]
-        self.assertEqual((band["left"], band["width"]), (72, 936))
-        self.assertEqual(rendered["bandRect"][1:5], [72, band["top"], 936, 96])
-        self.assertEqual(band["valueY"], band["detailY"])
-        self.assertLess(band["titleY"], band["valueY"])
-        self.assertGreater(band["textEdge"], band["valueEdge"])
-        # One spacing-scale gap separates every paper block, and the stack is
-        # centered with equal padding no smaller than that gap.
-        layout = rendered["auto"]["layout"]
-        blocks = layout["blocks"]
-        self.assertIn(layout["gap"], (16, 24, 32, 40, 48))
-        order = ["headline", "stats", "rule", "usage"]
-        self.assertEqual(sorted(blocks), sorted(order))
-        for upper, lower in zip(order, order[1:]):
-            self.assertEqual(
-                blocks[lower]["top"] - (blocks[upper]["top"] + blocks[upper]["height"]),
-                layout["gap"], (upper, lower))
-        top_pad = blocks["headline"]["top"] - 720
-        bottom_pad = 1220 - (blocks["usage"]["top"] + blocks["usage"]["height"])
-        self.assertLessEqual(abs(top_pad - bottom_pad), 1)
-        self.assertGreaterEqual(min(top_pad, bottom_pad), layout["gap"])
-        self.assertLess(band["top"], layout["stats"][0]["valueY"])
-        # Explicit choice, None, and a stale choice that is no longer available.
-        self.assertIn("14 days", rendered["streakTexts"])
-        self.assertNotIn("A CLAUDE PERSON", rendered["streakTexts"])
-        self.assertIsNone(rendered["noneLayout"]["headline"])
-        self.assertNotIn("headline", rendered["noneLayout"]["blocks"])
-        self.assertNotIn("A CLAUDE PERSON", rendered["noneTexts"])
-        self.assertIn("A CLAUDE PERSON", rendered["staleTexts"])
-        self.assertEqual(sorted(rendered["bareLayout"]["blocks"]), ["stats"])
-        # Controls: Auto, each candidate, None; stat toggles cap at five.
-        self.assertEqual(rendered["controlState"]["options"], [
-            ["auto", "Auto"], ["identity", "A Claude person · 92%"],
-            ["streak", "Longest streak · 14 days"], ["none", "None"],
-        ])
-        self.assertEqual(rendered["controlState"]["value"], "streak")
-        self.assertEqual(rendered["staleValue"], "auto")
-        stats = {stat_id: (checked, disabled) for stat_id, checked, disabled in rendered["controlState"]["stats"]}
-        for stat_id in ("active_days", "efficiency_change", "speed_champion", "sessions", "covered_spend"):
-            self.assertEqual(stats[stat_id], (True, False), stat_id)
-        # Five shown: no sixth choice; stats without evidence cannot be picked.
-        for stat_id in ("marathon_session", "output_pace", "tool_calls", "models"):
-            self.assertEqual(stats[stat_id], (False, True), stat_id)
-        self.assertEqual(rendered["reset"], {
-            "headline": "auto",
-            "stats": ["active_days", "efficiency_change", "speed_champion", "sessions", "covered_spend"],
-            "loads": 1,
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for headline verification")
-    def test_standalone_auto_headline_skips_facts_the_poster_already_shows(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}}}
-eval(extract('safeArray'));eval(extract('resolveHeadline'));
-const payload={{headlines:[{{id:'identity',title:'A Claude person',value:'92%'}},{{id:'streak',title:'Longest streak',value:'14 days'}},{{id:'cache_share',title:'Cache-powered',value:'87%'}}]}};
-const pick=(choice,shown)=>(resolveHeadline(payload,choice,shown)||{{}}).id||null;
-console.log(JSON.stringify({{
- fresh:pick('auto',[]),
- skipOne:pick('auto',['identity']),
- skipTwo:pick('auto',['identity','streak']),
- allShown:pick('auto',['identity','streak','cache_share']),
- explicit:pick('identity',['identity']),
- none:pick('none',[])
-}}));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=False)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), {
-            "fresh": "identity", "skipOne": "streak", "skipTwo": "cache_share",
-            "allShown": "identity", "explicit": "identity", "none": None,
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for texture verification")
-    def test_standalone_texture_helpers_dither_gradients_and_degrade_safely(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-for(const name of ['gradientFill','radialFill','fillRoundedRect','ditherRegion'])eval(extract(name));
-const put=[];
-const readable={{
- getImageData(x,y,width,height){{const data=new Uint8ClampedArray(width*height*4);for(let i=0;i<data.length;i+=4){{data[i]=data[i+1]=data[i+2]=40;data[i+3]=255;}}return {{width,height,data}};}},
- putImageData(image,x,y){{put.push([x,y,Array.from(image.data)]);}},
-}};
-const dithered=ditherRegion(readable,12,34,16,16,4);
-const channels=put[0][2].filter((_,index)=>index%4!==3),alphas=[...new Set(put[0][2].filter((_,index)=>index%4===3))];
-const missing=ditherRegion({{}},0,0,4,4,4);
-const tainted=ditherRegion({{getImageData(){{throw new Error('tainted');}},putImageData(){{}}}},0,0,4,4,4);
-const roundedOps=[],rounded={{roundRect(...v){{roundedOps.push(['roundRect',...v]);}},beginPath(){{roundedOps.push(['beginPath']);}},fill(){{roundedOps.push(['fill']);}},fillRect(...v){{roundedOps.push(['fillRect',...v]);}}}};
-const usedRound=fillRoundedRect(rounded,10,20,200,12,6);
-const plainOps=[],plain={{fillRect(...v){{plainOps.push(['fillRect',...v]);}}}};
-const usedPlain=fillRoundedRect(plain,10,20,200,12,6);
-console.log(JSON.stringify({{
- dithered,target:[put[0][0],put[0][1]],levels:[...new Set(channels)].sort((a,b)=>a-b),alphas,
- missing,tainted,usedRound,roundedOps,usedPlain,plainOps,
- gradientFallback:gradientFill({{}},0,0,1,1,[[0,'#111111'],[1,'#222222']]),
- radialFallback:radialFill({{}},0,0,10,[[0,'#333333'],[1,'#444444']]),
-}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertTrue(rendered["dithered"])
-        self.assertEqual(rendered["target"], [12, 34])
-        self.assertEqual(rendered["levels"], [0, 85])
-        self.assertEqual(rendered["alphas"], [255])
-        self.assertFalse(rendered["missing"])
-        self.assertFalse(rendered["tainted"])
-        self.assertTrue(rendered["usedRound"])
-        self.assertEqual(rendered["roundedOps"], [
-            ["beginPath"], ["roundRect", 10, 20, 200, 12, 6], ["fill"],
-        ])
-        self.assertFalse(rendered["usedPlain"])
-        self.assertEqual(rendered["plainOps"], [["fillRect", 10, 20, 200, 12]])
-        self.assertEqual(rendered["gradientFallback"], "#222222")
-        self.assertEqual(rendered["radialFallback"], "#444444")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dither wiring verification")
-    def test_standalone_canvas_dithers_each_band_before_drawing_any_text(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap'])eval(extract(name));
-const stops={{addColorStop(){{}}}};
-class Context{{
- constructor(){{this.ops=[];this.font='';this.bands=[];}}
- fillRect(...v){{this.ops.push(['rect',...v]);}}
- fillText(v){{this.ops.push(['text',String(v)]);}}
- drawImage(){{this.ops.push(['image']);}}
- createLinearGradient(){{return stops;}}
- createRadialGradient(){{return stops;}}
- getImageData(x,y,width,height){{const data=new Uint8ClampedArray(width*height*4);data.fill(100);return {{width,height,data}};}}
- putImageData(image,x,y){{this.ops.push(['dither',x,y,image.width,image.height]);this.bands.push([x,y,image.width,image.height,[...new Set(image.data.filter((_,i)=>i%4!==3))].sort((a,b)=>a-b)]);}}
- measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}
- beginPath(){{}}arc(){{}}stroke(){{}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}
-}}
-class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
-const payload={{range_days:30,current:{{end_day:'2026-09-13'}},spotlights:[{{id:'lines_pushed',available:true,current:39425,unit:'lines'}}],supporting:[],activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<26}})),usage:{{agents:[{{label:'Codex',share:71}}],models:[{{label:'gpt-5.6',runtime:'Codex',share:69}}]}}}};
-const canvas=new Canvas();drawBuilderRecap(canvas,payload,{{name:'Ada',includeUsage:true}});
-const kinds=canvas.ctx.ops.map(op=>op[0]);
-console.log(JSON.stringify({{
- bands:canvas.ctx.bands,
- lastDither:kinds.lastIndexOf('dither'),
- firstText:kinds.indexOf('text'),
-}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertEqual(
-            [band[:4] for band in rendered["bands"]],
-            [[0, 0, 1080, 720], [0, 720, 1080, 500], [0, 1220, 1080, 130]],
-        )
-        # Distinct output values pin each band's quantization step, so changing a
-        # band's `levels` cannot pass silently.
-        self.assertEqual(
-            [band[4] for band in rendered["bands"]],
-            [[98, 118], [85, 102], [98, 118]],
-        )
-        self.assertGreater(rendered["firstText"], -1)
-        self.assertLess(rendered["lastDither"], rendered["firstText"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for rhythm verification")
-    def test_standalone_canvas_groups_long_ranges_into_active_rhythm_bars(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap'])eval(extract(name));
-class Gradient{{constructor(kind){{this.kind=kind;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
-class Context{{constructor(){{this.ops=[];this.font='';}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}drawImage(){{}}createLinearGradient(){{return new Gradient('linear');}}createRadialGradient(){{return new Gradient('radial');}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}arc(){{}}stroke(){{}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}}}
-class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
-const payload={{range_days:90,current:{{end_day:'2026-09-13'}},spotlights:[{{id:'lines_pushed',available:true,current:140514,unit:'lines'}}],supporting:[],activity_days:Array.from({{length:90}},(_,i)=>({{recorded_session:i<76}})),usage:{{agents:[],models:[]}}}};
-const canvas=new Canvas();drawBuilderRecap(canvas,payload,{{name:'',includeUsage:true}});
-const rhythmBars=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[2]>=72&&op[2]<1008&&op[3]+op[5]===694);
-console.log(JSON.stringify({{
- total:rhythmBars.length,
- active:rhythmBars.filter(op=>op[1]&&op[1].kind==='linear').length,
- inactive:rhythmBars.filter(op=>op[1]==='rgba(159,180,189,.3)').map(op=>op[5]),
- texts:canvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),
- aria:canvas.attrs['aria-label'],
-}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["total"], 30)
-        self.assertEqual(rendered["active"], 26)
-        self.assertEqual(rendered["inactive"], [8, 8, 8, 8])
-        self.assertIn("76/90", rendered["texts"])
-        self.assertIn("LAST 90 DAYS", rendered["texts"])
-        # Bucketed bars must disclose their grouping instead of implying one day each.
-        self.assertIn("Rhythm chart groups 3 days per bar.", rendered["aria"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for canvas verification")
-    def test_standalone_canvas_is_a_linkedin_scale_builder_signal(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);if(page.slice(start-6,start)==='async ')start-=6;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-	for(const name of ['safeArray','sanitizeBuilderName','compactNumber','durationLabel','formatStat','formatSpend','ellipsize','fitText','gradientFill','radialFill','fillRoundedRect','setTracking','cardPalette','ditherRegion','supportingStats','inkX','posterStatLimit','defaultPosterStats','posterStatCatalog','findRecapStat','posterStatCells','resolveHeadline','paperLayout','headlineBandHeight','statRowHeight','usageBlockHeight','drawHeadlineBand','drawStatRow','drawUsageGroup','drawBuilderRecap','hasActivity'])eval(extract(name));
-class Gradient{{constructor(kind,coords){{this.kind=kind;this.coords=coords;this.stops=[];}}addColorStop(offset,color){{this.stops.push([offset,color]);}}}}
-class Context{{constructor(){{this.ops=[];this.font='';this.lineWidth=1;}}fillRect(...v){{this.ops.push(['rect',this.fillStyle,...v]);}}fillText(...v){{this.ops.push(['text',String(v[0]),...v.slice(1),this.font]);}}createLinearGradient(...c){{return new Gradient('linear',c);}}createRadialGradient(...c){{return new Gradient('radial',c);}}measureText(v){{const size=Number((/([0-9.]+)px/.exec(this.font)||[])[1])||14,narrow=/Narrow|Condensed/.test(this.font);return {{width:String(v).length*size*(narrow?.45:.55)}};}}beginPath(){{}}arc(...v){{this.ops.push(['arc',this.strokeStyle,...v]);}}stroke(){{this.ops.push(['stroke',this.strokeStyle,this.lineWidth]);}}save(){{}}restore(){{}}translate(){{}}rotate(){{}}}}
-class Canvas{{constructor(){{this.ctx=new Context();this.attrs={{}};this.width=1;this.height=1;}}getContext(){{return this.ctx;}}setAttribute(k,v){{this.attrs[k]=String(v);}}}}
-	const payload={{ok:true,private_sentinel:'prompt://must-not-draw',range_days:30,current:{{start_day:'2026-08-15',end_day:'2026-09-13'}},spotlight_default:'efficiency_change',spotlights:[{{id:'efficiency_change',label:'Output efficiency',family:'efficiency',available:true,current:2680,previous:1942,delta_pct:38,unit:'output tokens/$',basis:'paired cost-covered output and cost'}},{{id:'speed_champion',label:'Fastest model',family:'efficiency',available:true,current:42.8,previous:null,delta_pct:null,unit:'output tokens/s',basis:'weighted measured generation samples',leaders:[{{runtime:'Codex',model:'gpt-5.3'}}]}},{{id:'lines_pushed',label:'Lines pushed',family:'delivery',available:true,current:184392,previous:120000,delta_pct:53.66,unit:'lines',basis:'added plus deleted text lines from successful local pushes'}},{{id:'commits_pushed',label:'Commits pushed',family:'delivery',available:true,current:1284,previous:940,delta_pct:36.6,unit:'commits',basis:'own non-merge commits introduced by successful local pushes'}},{{id:'marathon_session',label:'Longest session',family:'activity',available:true,current:24120,previous:18000,delta_pct:34,unit:'seconds',basis:'active execution duration'}},{{id:'build_streak',label:'Build streak',family:'consistency',available:true,current:14,previous:8,delta_pct:75,unit:'days',basis:'consecutive local days'}}],supporting:[{{id:'active_days',label:'Active days',family:'consistency',available:true,current:24,previous:20,delta_pct:20,unit:'days'}},{{id:'sessions',label:'AI coding sessions',family:'activity',available:true,current:126,previous:91,delta_pct:38.5,unit:'sessions'}},{{id:'delivery_active_days',label:'Delivery-active days',family:'delivery',available:true,current:12,previous:8,delta_pct:50,unit:'days'}},{{id:'output_pace',label:'Output pace',family:'efficiency',available:true,current:31.4,previous:28,delta_pct:12,unit:'output tokens/s'}}],activity_days:Array.from({{length:30}},(_,i)=>({{recorded_session:i<24}})),usage:{{agents:[{{label:'Codex',count:68,share:54}},{{label:'Claude',count:39,share:31}},{{label:'Cursor',count:19,share:15}}],models:[{{label:'gpt-5.3',runtime:'Codex',count:74,share:49}},{{label:'sonnet-4.5',runtime:'Claude',count:48,share:32}},{{label:'gpt-5.2',runtime:'Codex',count:29,share:19}}]}},coverage:{{git:{{available:true}},cost:{{available:true,eligible:22,total:30}},output:{{available:true,eligible:22,total:30}},timing:{{available:true,eligible:14,total:18}}}},privacy:{{content_included:false,project_identity_included:false}}}};
-		const canvas=new Canvas(),result=drawBuilderRecap(canvas,payload,{{name:' Ada\\n Builder ',includeUsage:true}}),texts=canvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]),arcs=canvas.ctx.ops.filter(op=>op[0]==='arc'),bars=canvas.ctx.ops.filter(op=>op[0]==='rect'&&(op[5]===12||op[5]===6)),rhythmBars=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[2]>=72&&op[2]<1008&&op[3]+op[5]===694),heroFields=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[1]&&op[1].kind==='linear'&&op[2]===0&&op[3]===0&&op[4]===1080&&op[5]>=700),lowerFields=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[1]&&op[1].kind==='linear'&&op[2]===0&&op[3]>=700&&op[4]===1080&&op[5]>=450),nameOp=canvas.ctx.ops.find(op=>op[0]==='text'&&op[1]==='ADA BUILDER'),heroOp=canvas.ctx.ops.find(op=>op[0]==='text'&&op[3]===486),efficiencyLabelOp=canvas.ctx.ops.find(op=>op[0]==='text'&&op[1]==='OUTPUT EFFICIENCY'&&op[3]===result.layout.stats[0].labelY),metricLabelOps=canvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===result.layout.stats[0].labelY),ghostPeriodOps=canvas.ctx.ops.filter(op=>op[0]==='text'&&String(op[4]).includes('330px'));
-		const negativePayload=JSON.parse(JSON.stringify(payload));negativePayload.spotlights.find(stat=>stat.id==='lines_pushed').delta_pct=-25;const negativeCanvas=new Canvas();drawBuilderRecap(negativeCanvas,negativePayload,{{name:'',includeUsage:true}});
-		const unavailablePayload=JSON.parse(JSON.stringify(payload));Object.assign(unavailablePayload.spotlights.find(stat=>stat.id==='lines_pushed'),{{available:false,current:null,previous:null,delta_pct:null}});unavailablePayload.coverage.git.available=false;const unavailableCanvas=new Canvas();drawBuilderRecap(unavailableCanvas,unavailablePayload,{{name:'',includeUsage:true}});
-	const flatPayload=JSON.parse(JSON.stringify(payload));flatPayload.spotlights.find(stat=>stat.id==='lines_pushed').delta_pct=0;const flatCanvas=new Canvas();drawBuilderRecap(flatCanvas,flatPayload,{{name:'',includeUsage:true}});const flatTexts=flatCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]);
-	const privateCanvas=new Canvas();drawBuilderRecap(privateCanvas,payload,{{name:'',includeUsage:false}});const privateTexts=privateCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]);
-	const noUsagePayload=JSON.parse(JSON.stringify(payload));noUsagePayload.usage={{agents:[],models:[]}};const noUsageCanvas=new Canvas();drawBuilderRecap(noUsageCanvas,noUsagePayload,{{name:'',includeUsage:true}});const noUsageTexts=noUsageCanvas.ctx.ops.filter(op=>op[0]==='text').map(op=>op[1]);
-	const gitOnlyPayload=JSON.parse(JSON.stringify(payload));gitOnlyPayload.activity_days=gitOnlyPayload.activity_days.map(day=>({{...day,recorded_session:false}}));const gitOnlyActivity=hasActivity(gitOnlyPayload);
-	class Control{{constructor(){{this.disabled=false;this.checked=false;this.value='';this.textContent='';this.children=[];}}appendChild(child){{this.children.push(child);}}}}
-	const controlElements={{'builder-name':new Control(),'include-usage':new Control()}},$=id=>controlElements[id],document={{querySelectorAll:()=>[],createElement:()=>new Control()}},builderRecapState={{range:30,name:'',includeUsage:true,payload:noUsagePayload}};function builderOptions(){{return {{name:builderRecapState.name,includeUsage:builderRecapState.includeUsage}};}}eval(extract('renderControls'));renderControls(noUsagePayload);
-		const heroRowLabels=canvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===314).map(op=>[op[1],op[2]]),heroRowValues=canvas.ctx.ops.filter(op=>op[0]==='text'&&op[3]===486).map(op=>[op[1],op[2],op[4]]),columnRules=canvas.ctx.ops.filter(op=>op[0]==='rect'&&op[3]===282&&op[5]===3).map(op=>[op[2],op[4]]);
-		console.log(JSON.stringify({{size:[canvas.width,canvas.height],texts,arcs,bars,rhythmBars,heroFields,lowerFields,heroRowLabels,heroRowValues,columnRules,aria:canvas.attrs['aria-label'],negativeAria:negativeCanvas.attrs['aria-label'],unavailableAria:unavailableCanvas.attrs['aria-label'],flatAria:flatCanvas.attrs['aria-label'],flatTexts,nameOp,heroOp,efficiencyLabelOp,metricLabelOps,ghostPeriodOps,summary:result.summary,privateTexts,privateAria:privateCanvas.attrs['aria-label'],noUsageTexts,noUsageAria:noUsageCanvas.attrs['aria-label'],gitOnlyActivity,noUsageControl:{{disabled:controlElements['include-usage'].disabled,checked:controlElements['include-usage'].checked}}}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["size"], [1080, 1350])
-        for text in (
-            "TOKEN METER", "PERFORMANCE CARD", "LAST 30 DAYS", "30D",
-            "ADA BUILDER", "LINES PUSHED",
-            "184,392", "OUTPUT EFFICIENCY", "2.68 K/$", "24/30",
-            "ACTIVE DAYS", "14 DAY STREAK", "FASTEST MODEL", "42.8 TOK/S",
-            "GPT-5.3", "AI SESSIONS", "126",
-            "MOST-USED AGENT", "GO-TO MODEL", "CODEX", "54%", "49%",
-            "BUILD YOURS →", "github.com/splunk/token-meter",
-        ):
-            self.assertIn(text, rendered["texts"])
-        self.assertEqual(rendered["nameOp"][1:4], ["ADA BUILDER", 72, 250])
-        self.assertIn("44px", rendered["nameOp"][4])
-        self.assertEqual(rendered["heroOp"][1], "184,392")
-        # Lines and commits form one two-column hero: labels share a line, values
-        # share a baseline, and each column carries its own accent rule.
-        self.assertEqual(
-            [(op[0], op[1]) for op in rendered["heroRowLabels"]],
-            [("LINES PUSHED", 72), ("COMMITS", 1008)],
-        )
-        self.assertEqual(
-            [(op[0], op[1]) for op in rendered["heroRowValues"]],
-            [("184,392", 72), ("1,284", 1008)],
-        )
-        self.assertEqual(rendered["columnRules"], [[72, 108], [900, 108]])
-        # Commits must stay visually subordinate to the lines hero.
-        hero_size = int(re.search(r"(\d+)px", rendered["heroRowValues"][0][2]).group(1))
-        commit_size = int(re.search(r"(\d+)px", rendered["heroRowValues"][1][2]).group(1))
-        self.assertLess(commit_size, hero_size)
-        self.assertIn("Commits pushed 1,284.", rendered["aria"])
-        self.assertIsNotNone(rendered["efficiencyLabelOp"])
-        # No covered-spend evidence: the spend cell is omitted and four equal
-        # columns span the content measure instead of leaving a gap.
-        self.assertEqual(
-            [(op[1], op[2]) for op in rendered["metricLabelOps"]],
-            [("ACTIVE DAYS", 72), ("OUTPUT EFFICIENCY", 314),
-             ("FASTEST MODEL", 556), ("AI SESSIONS", 798)],
-        )
-        self.assertNotIn("EQUIV. SPEND", rendered["texts"])
-        self.assertEqual(rendered["ghostPeriodOps"], [])
-        self.assertGreaterEqual(len(rendered["bars"]), 6)
-        self.assertEqual(len(rendered["rhythmBars"]), 30)
-        for index, bar in enumerate(rendered["rhythmBars"][:24]):
-            self.assertEqual(bar[1]["kind"], "linear")
-            self.assertEqual(
-                [stop[1] for stop in bar[1]["stops"]],
-                ["#8ee9f2", "#00bceb", "rgba(64,84,214,.72)"],
-            )
-            self.assertEqual(bar[5], 28 + ((index * 19) % 66))
-        for bar in rendered["rhythmBars"][24:]:
-            self.assertEqual((bar[1], bar[5]), ("rgba(159,180,189,.3)", 8))
-        self.assertTrue(rendered["heroFields"])
-        self.assertTrue(rendered["lowerFields"])
-        self.assertEqual(
-            [stop[1] for stop in rendered["heroFields"][0][1]["stops"]],
-            ["#0d2c3d", "#081a27", "#040d14"],
-        )
-        self.assertEqual(
-            [stop[1] for stop in rendered["lowerFields"][0][1]["stops"]],
-            ["#f8f5ee", "#f1eee4", "#e4e0d3"],
-        )
-        self.assertFalse(rendered["arcs"])
-        for raw_count in ("68", "39", "19", "74", "48", "29"):
-            self.assertNotIn(raw_count, rendered["texts"])
-        visible = " ".join(rendered["texts"])
-        for rejected in (
-            "BUILDER FIELD SHEET", "DAY SIGNAL", "30-DAY RHYTHM", "AGENT MIX",
-            "MODEL MIX", "LOCAL / PARTIAL",
-            "PRIVATE LOCAL AGGREGATES", "AI BUILDER RECAP", "prompt://must-not-draw",
-            "VS PRIOR", "↑", "↓", "+54%", "−25%", "NO CHANGE",
-            "LONGEST SESSION", "6H 42M",
-        ):
-            self.assertNotIn(rejected, visible)
-        self.assertIn(
-            "Name Ada Builder. Current lines pushed 184,392 lines.",
-            rendered["aria"],
-        )
-        self.assertIn(
-            "Current lines pushed 184,392 lines.",
-            rendered["negativeAria"],
-        )
-        self.assertIn(
-            "Current lines pushed unavailable.",
-            rendered["unavailableAria"],
-        )
-        self.assertIn(
-            "Current lines pushed 184,392 lines.", rendered["flatAria"],
-        )
-        for output in (
-            rendered["aria"], rendered["negativeAria"],
-            rendered["unavailableAria"], rendered["flatAria"],
-            rendered["summary"], " ".join(rendered["flatTexts"]),
-        ):
-            for rejected in (
-                "Partial evidence", "Complete evidence", "increased", "decreased",
-                "unchanged", "versus prior", "comparison", "VS PRIOR", "↑", "↓",
-            ):
-                self.assertNotIn(rejected, output)
-        self.assertTrue(rendered["gitOnlyActivity"])
-        self.assertIn("runtime-scoped model usage", rendered["aria"])
-        self.assertNotIn("prompt://must-not-draw", rendered["aria"])
-        private_visible = " ".join(rendered["privateTexts"])
-        self.assertIn("LINES PUSHED", private_visible)
-        self.assertIn("184,392", rendered["privateTexts"])
-        self.assertIn("OUTPUT EFFICIENCY", private_visible)
-        for excluded in ("MOST-USED AGENT", "GO-TO MODEL", "CODEX", "CLAUDE",
-                         "CURSOR", "GPT-5.3", "SONNET-4.5", "GPT-5.2"):
-            self.assertNotIn(excluded, private_visible)
-        for excluded in ("Codex", "Claude", "Cursor", "gpt-5.3", "sonnet-4.5", "gpt-5.2"):
-            self.assertNotIn(excluded, rendered["privateAria"])
-        self.assertIn("Usage charts excluded", rendered["privateAria"])
-        no_usage_visible = " ".join(rendered["noUsageTexts"])
-        self.assertNotIn("MOST-USED AGENT", no_usage_visible)
-        self.assertNotIn("GO-TO MODEL", no_usage_visible)
-        self.assertIn("Usage charts unavailable", rendered["noUsageAria"])
-        self.assertEqual(rendered["noUsageControl"], {
-            "disabled": True, "checked": False,
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for preview verification")
-    def test_standalone_success_enables_download_without_export_ready_copy(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-class Element{{constructor(){{this.disabled=true;this.hidden=true;this.textContent='';this.dataset={{}};}}}}
-const elements={{download:new Element(),retry:new Element(),poster:new Element(),status:new Element()}},$=id=>elements[id];
-elements.poster.getContext=()=>({{}});elements.poster.setAttribute=()=>{{}};
-const builderRecapState={{payload:{{activity_days:[{{recorded_session:true}}]}},loading:false,error:'',rendered:false}};
-const logo={{complete:false,naturalWidth:0}};let shouldFail=false;function hasActivity(){{return true;}}function drawBuilderRecap(){{if(shouldFail)throw Error('private failure');}}function drawPlaceholder(){{}}function builderOptions(){{return {{logo}};}}function setStatus(message,kind=''){{elements.status.textContent=message;elements.status.dataset.kind=kind;}}
-for(const name of ['showLogoFailure','renderPreview'])eval(extract(name));
-const waitingReady=renderPreview(),waiting={{ready:waitingReady,download:elements.download.disabled,status:elements.status.textContent}};
-logo.complete=true;logo.naturalWidth=1024;
-const ready=renderPreview(),success={{ready,download:elements.download.disabled,status:elements.status.textContent,kind:elements.status.dataset.kind}};
-shouldFail=true;const failed=renderPreview(),failure={{failed,download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind}};
-console.log(JSON.stringify({{waiting,success,failure}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["waiting"], {
-            "ready": False, "download": True,
-            "status": "Loading local brand asset…",
-        })
-        self.assertEqual(rendered["success"], {
-            "ready": True, "download": False, "status": "", "kind": "",
-        })
-        self.assertEqual(rendered["failure"], {
-            "failed": False, "download": True, "retry": False,
-            "status": "Preview unavailable. Try again.", "kind": "error",
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for logo recovery verification")
-    def test_standalone_logo_error_retries_local_asset_before_enabling_download(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)return '';let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-class Element{{
- constructor(){{this.disabled=true;this.hidden=true;this.textContent='';this.dataset={{}};this.listeners={{}};}}
- addEventListener(type,handler){{this.listeners[type]=handler;}}
- dispatch(type){{if(this.listeners[type])this.listeners[type]({{target:this}});}}
-}}
-class Logo extends Element{{
- constructor(){{super();this.complete=false;this.naturalWidth=0;this._src='/assets/brand/logo-splunk-by-cisco-rgb-w.png';this.sourceWrites=[];this.sourceRemovals=0;}}
- get src(){{return this._src;}}
- set src(value){{this._src=String(value);this.sourceWrites.push(this._src);}}
- getAttribute(name){{return name==='src'?this._src:null;}}
- removeAttribute(name){{if(name==='src'){{this._src='';this.sourceRemovals++;}}}}
-}}
-const elements={{download:new Element(),retry:new Element(),reset:new Element(),poster:new Element(),status:new Element(),'performance-card-logo':new Logo()}},$=id=>elements[id];
-elements.poster.getContext=()=>({{}});elements.poster.setAttribute=()=>{{}};
-const builderRecapState={{range:30,payload:{{activity_days:[{{recorded_session:true}}]}},loading:false,error:'',rendered:false,logoError:false}};
-let recapLoads=0;function loadRecap(){{recapLoads++;}}function resetRecap(){{}}function downloadRecap(){{}}function hasActivity(){{return true;}}function drawBuilderRecap(){{}}function drawPlaceholder(){{}}function builderOptions(){{return {{logo:elements['performance-card-logo']}};}}function setStatus(message,kind=''){{elements.status.textContent=message;elements.status.dataset.kind=kind;}}
-for(const name of ['showLogoFailure','retryLogo','handleLogoLoad','renderPreview']){{const source=extract(name);if(source)eval(source);}}
-for(const line of page.split('\\n').filter(line=>line.includes("$('retry').addEventListener")||line.includes("$('performance-card-logo').addEventListener")))eval(line);
-renderPreview();
-const logo=elements['performance-card-logo'];logo.complete=true;logo.dispatch('error');
-const failure={{download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind}};
-elements.retry.dispatch('click');
-const retrying={{download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind,source:logo.src,sourceWrites:logo.sourceWrites,sourceRemovals:logo.sourceRemovals,recapLoads}};
-logo.complete=true;logo.naturalWidth=1024;logo.dispatch('load');
-const recovered={{rendered:builderRecapState.rendered,download:elements.download.disabled,retry:elements.retry.hidden,status:elements.status.textContent,kind:elements.status.dataset.kind}};
-console.log(JSON.stringify({{failure,retrying,recovered}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["failure"], {
-            "download": True, "retry": False,
-            "status": "Local brand asset unavailable. Try again.",
-            "kind": "error",
-        })
-        self.assertEqual(rendered["retrying"], {
-            "download": True, "retry": True,
-            "status": "Loading local brand asset…", "kind": "",
-            "source": "/assets/brand/logo-splunk-by-cisco-rgb-w.png",
-            "sourceWrites": ["/assets/brand/logo-splunk-by-cisco-rgb-w.png"],
-            "sourceRemovals": 1, "recapLoads": 0,
-        })
-        self.assertEqual(rendered["recovered"], {
-            "rendered": True, "download": False, "retry": True,
-            "status": "", "kind": "",
-        })
-
-    def test_standalone_export_contract_is_png_only(self):
-        page = Path(meter.__file__).with_name("performance.html").read_text()
-        for marker in (
-            "canvas.width=1080", "canvas.height=1350", "canvas.toBlob(blob=>",
-            "'image/png'", "URL.revokeObjectURL", "function downloadRecap(",
-            "function resetRecap(", "new AbortController()",
-        ):
-            self.assertIn(marker, page)
-        self.assertNotIn("LOCAL / PARTIAL", page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for input verification")
-    def test_standalone_name_input_preserves_spaces_while_typing(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const input={{value:'',addEventListener(type,handler){{this.handler=handler;}}}},$=id=>input;
-const builderRecapState={{name:''}};let renders=0;function renderPreview(){{renders++;}}
-eval(extract('sanitizeBuilderName'));
-const handlerSource=page.split('\\n').find(line=>line.startsWith("$('builder-name').addEventListener('input',"));eval(handlerSource);
-for(const character of 'Ada Lovelace'){{input.value+=character;input.handler({{target:input}});}}
-console.log(JSON.stringify({{field:input.value,state:builderRecapState.name,renders}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), {
-            "field": "Ada Lovelace", "state": "Ada Lovelace", "renders": 12,
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for request verification")
-    def test_standalone_request_lifecycle_is_latest_only_and_retryable(self):
-        page_path = Path(meter.__file__).with_name("performance.html")
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);if(page.slice(start-6,start)==='async ')start-=6;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-class Element{{constructor(){{this.disabled=false;this.hidden=true;this.checked=false;this.value='';this.dataset={{}};}}}}
-const elements=Object.fromEntries(['download','retry','builder-name','include-usage'].map(id=>[id,new Element()])), $=id=>elements[id];
-const builderRecapState={{range:30,name:'',includeUsage:true,payload:null,request:0,controller:null,loading:false,error:'',rendered:false}};
-class AbortController{{constructor(){{this.signal={{aborted:false}};}}abort(){{this.signal.aborted=true;}}}}
-let requests=[],status='';function fetch(url,options){{return new Promise(resolve=>requests.push({{url,options,resolve}}));}}function renderControls(){{}}function drawPlaceholder(){{}}function setStatus(message){{status=message;}}function renderPreview(){{builderRecapState.rendered=true;$('download').disabled=false;return true;}}
-eval(extract('sanitizeBuilderName'));eval(extract('defaultPosterStats'));eval(extract('loadRecap'));eval(extract('resetRecap'));
-const payload=range=>({{ok:true,range_days:range,activity_days:[{{recorded_session:true}}],coverage:{{git:{{available:true}}}}}});
-;(async()=>{{
- const first=loadRecap(30);await Promise.resolve();const second=loadRecap(7);await Promise.resolve();const third=loadRecap(90);await Promise.resolve();
- requests[0].resolve({{ok:true,json:async()=>payload(30)}});requests[1].resolve({{ok:true,json:async()=>payload(7)}});requests[2].resolve({{ok:true,json:async()=>payload(90)}});await Promise.all([first,second,third]);
- const latest={{range:builderRecapState.range,payload:builderRecapState.payload.range_days,aborted:requests[1].options.signal.aborted,download:$('download').disabled}};
- const sanitized=sanitizeBuilderName('  Ada\\n\\u0000 Lovelace  ');
- const failedPromise=loadRecap(7);await Promise.resolve();requests[3].resolve({{ok:false,json:async()=>({{}})}});await failedPromise;const failed={{download:$('download').disabled,retry:$('retry').hidden,status}};
- builderRecapState.name='Ada';builderRecapState.includeUsage=false;const resetPromise=resetRecap();await Promise.resolve();requests[4].resolve({{ok:true,json:async()=>payload(30)}});await resetPromise;
- const reset={{range:builderRecapState.range,name:builderRecapState.name,usage:builderRecapState.includeUsage}};
- console.log(JSON.stringify({{latest,sanitized,failed,reset,urls:requests.map(item=>item.url)}}));
-}})().catch(error=>{{console.error(error.stack||error);process.exitCode=1;}});
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=False,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["latest"], {
-            "range": 90, "payload": 90, "aborted": True, "download": False,
-        })
-        self.assertEqual(rendered["sanitized"], "Ada Lovelace")
-        self.assertEqual(rendered["failed"], {
-            "download": True, "retry": False,
-            "status": "Unable to load the builder recap. Try again.",
-        })
-        self.assertEqual(rendered["reset"], {
-            "range": 30, "name": "", "usage": True,
-        })
-        self.assertEqual(rendered["urls"], [
-            "/builder-recap?range=30", "/builder-recap?range=7",
-            "/builder-recap?range=90", "/builder-recap?range=7",
-            "/builder-recap?range=30",
-        ])
-
-
-class LegacyJsonlLoadTests(unittest.TestCase):
-    def test_load_skips_corrupt_bytes_truncated_rows_and_non_objects(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_bytes(
-                b'{"type":"user","value":1}\n'
-                b'\xff\n'
-                b'[]\n'
-                b'"text"\n'
-                b'42\n'
-                b'null\n'
-                b'{"type":"assistant","value":2}\n'
-                b'{"truncated":\n'
-            )
-
-            rows = meter.load(str(path))
-
-        self.assertEqual(rows, [
-            {"type": "user", "value": 1},
-            {"type": "assistant", "value": 2},
-        ])
-
-    def test_load_returns_empty_when_the_trace_cannot_be_opened(self):
-        with mock.patch("builtins.open", side_effect=PermissionError("denied")):
-            self.assertEqual(meter.load("/unreadable/session.jsonl"), [])
-
-
-class SourceDiscoveryCacheTests(unittest.TestCase):
-    def test_codex_metadata_prefix_is_reused_after_large_trace_append(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            rows = [
-                {
-                    "type": "session_meta",
-                    "payload": {"id": "session", "cwd": "/repo"},
-                },
-                {
-                    "type": "turn_context",
-                    "payload": {"model": "gpt-stable"},
-                },
-            ]
-            rows.extend({"type": "event", "payload": {"index": idx}}
-                        for idx in range(121))
-            path.write_text("".join(json.dumps(row) + "\n" for row in rows))
-
-            with mock.patch.object(meter, "_codex_native_adapters", {}):
-                first = meter.codex_meta(str(path))
-                with path.open("a", encoding="utf-8") as handle:
-                    handle.write(json.dumps({"type": "event", "payload": {}}) + "\n")
-                with mock.patch(
-                    "builtins.open",
-                    side_effect=AssertionError(
-                        "append-only growth must reuse the completed metadata prefix"
-                    ),
-                ):
-                    second = meter.codex_meta(str(path))
-
-        self.assertEqual(first, second)
-        self.assertEqual(second["model"], "gpt-stable")
-
-    def test_codex_metadata_is_reused_until_the_trace_changes(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            session_meta = {
-                "type": "session_meta",
-                "payload": {"id": "session", "cwd": "/repo"},
-            }
-            first_turn = {
-                "type": "turn_context",
-                "payload": {"model": "gpt-first"},
-            }
-            path.write_text(
-                json.dumps(session_meta) + "\n" + json.dumps(first_turn) + "\n"
-            )
-            with mock.patch.object(meter, "_codex_native_adapters", {}):
-                first = meter.codex_meta(str(path))
-                with mock.patch(
-                    "builtins.open",
-                    side_effect=AssertionError("unchanged metadata should come from cache"),
-                ):
-                    second = meter.codex_meta(str(path))
-
-                second_turn = {
-                    "type": "turn_context",
-                    "payload": {"model": "gpt-second"},
-                }
-                path.write_text(
-                    json.dumps(session_meta) + "\n" + json.dumps(second_turn) + "\n"
-                )
-                third = meter.codex_meta(str(path))
-
-        self.assertEqual(first["model"], "gpt-first")
-        self.assertEqual(second["model"], "gpt-first")
-        self.assertEqual(third["model"], "gpt-second")
-
-    def test_codex_index_rename_refreshes_cached_session_name_without_trace_change(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            sessions = root / "sessions"
-            trace = sessions / "2026" / "08" / "10" / "session.jsonl"
-            trace.parent.mkdir(parents=True)
-            session_id = "codex-session"
-            trace.write_text(json.dumps({
-                "type": "session_meta",
-                "timestamp": "2026-08-10T10:00:00Z",
-                "payload": {"id": session_id, "cwd": "/repo"},
-            }) + "\n")
-            os.utime(trace, (1_784_548_800, 1_784_548_800))
-            index = root / "session_index.jsonl"
-            index.write_text(json.dumps({
-                "id": session_id, "thread_name": "Review token-meter PR 14",
-            }) + "\n")
-            empty_summary_cache = {}
-            with mock.patch.object(meter, "CODEX_SESSIONS", str(sessions)), \
-                    mock.patch.object(meter, "CODEX_INDEX", str(index)), \
-                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
-                    mock.patch.object(meter, "CURSOR_PROJECTS", str(root / "no-cursor")), \
-                    mock.patch.object(meter, "OPENCODE_DB", str(root / "no-opencode.db")), \
-                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
-                    mock.patch.object(meter, "claude_desktop_index", return_value={}), \
-                    mock.patch.object(meter, "_summary_cache", empty_summary_cache):
-                first_source = meter.all_session_sources()[0]
-                first_signature = meter.source_mtime_signature([first_source])
-                first_state_signature = meter.session_state_signature(first_source)
-                first_summary = meter.session_summary(first_source)
-                with index.open("a", encoding="utf-8") as fh:
-                    fh.write(json.dumps({
-                        "id": session_id, "thread_name": "Review token-meter PR 14 (2)",
-                    }) + "\n")
-                second_source = meter.all_session_sources()[0]
-                second_signature = meter.source_mtime_signature([second_source])
-                second_state_signature = meter.session_state_signature(second_source)
-                second_summary = meter.session_summary(second_source)
-
-        self.assertEqual(first_source["mtime"], second_source["mtime"])
-        self.assertEqual(first_summary["session_name"], "Review token-meter PR 14")
-        self.assertEqual(second_source["title"], "Review token-meter PR 14 (2)")
-        self.assertNotEqual(first_signature, second_signature)
-        self.assertNotEqual(first_state_signature, second_state_signature)
-        self.assertEqual(second_summary["session_name"], "Review token-meter PR 14 (2)")
-
-    def test_shared_path_cache_retains_one_complete_adapter_pattern_set(self):
-        cache = meter._recursive_path_cache
-        cache.clear()
-        try:
-            with mock.patch("glob.glob", return_value=[]):
-                for index in range(37):
-                    cache.paths(f"/nonexistent/runtime-pattern-{index}/*", now=1.0)
-            self.assertEqual(cache.entry_count, 37)
-        finally:
-            cache.clear()
-
-
-class CursorTraceTests(unittest.TestCase):
-    def source(self, path="/tmp/cursor-session.jsonl", session_id="cursor-session"):
-        return {
-            "provider": "cursor", "client": "cursor", "label": "Cursor",
-            "runtime": "Cursor", "id": session_id,
-            "session": Path(path).name, "path": path, "project": "/repo",
-            "mtime": 1, "title": "Cursor run", "model": "composer-2.5",
-        }
-
-    def snapshot(self):
-        base_ms = 1_784_548_800_000
-        return {
-            "available": True,
-            "header": {"name": "Cursor run"},
-            "composer": {
-                "modelConfig": {
-                    "modelName": "composer-2.5",
-                    "selectedModels": [{"modelId": "composer-2.5", "parameters": [
-                        {"id": "fast", "value": "true"},
-                    ]}],
-                },
-                "contextTokensUsed": 80448,
-                "contextTokenLimit": 200000,
-                "promptTokenBreakdown": {"categories": [
-                    {"id": "rules", "label": "Rules", "estimatedTokens": 1234},
-                ]},
-            },
-            "bubbles": [
-                {"type": 1, "bubbleId": "user-1", "createdAt": base_ms,
-                 "text": "inspect the repository", "requestId": "request-1",
-                 "modelInfo": {"modelName": "composer-2.5"},
-                 "contextWindowStatusAtCreation": {"tokensUsed": 78000, "tokenLimit": 200000}},
-                {"type": 2, "bubbleId": "assistant-1", "createdAt": base_ms + 46000,
-                 "thinking": "trace-visible", "thinkingDurationMs": 3200,
-                 "toolFormerData": {
-                     "name": "ripgrep_raw_search", "toolCallId": "tool-1",
-                     "params": {"query": "needle"}, "additionalData": {"lines": "x" * 80},
-                     "status": "error",
-                 },
-                 "text": "finished", "turnDurationMs": 46624},
-            ],
-        }
-
-    def spans(self):
-        base = 1_784_548_800.0
-        return [
-            {"name": "client.ttft", "start_ts": base, "end_ts": base + 4.118,
-             "duration_s": 4.118, "request_id": "request-1", "error": False},
-            {"name": "agent.request.attempt", "start_ts": base, "end_ts": base + 20,
-             "duration_s": 20, "request_id": "attempt-1", "error": True},
-            {"name": "agent.request.attempt", "start_ts": base + 21, "end_ts": base + 46,
-             "duration_s": 25, "request_id": "attempt-2", "error": False},
-            {"name": "ComposerChatService.submitChatMaybeAbortCurrent", "start_ts": base,
-             "end_ts": base + 46.624, "duration_s": 46.624,
-             "request_id": "request-1", "error": False},
-        ]
-
-    def test_cursor_discovery_uses_sqlite_metadata_and_keeps_activity_order_session_specific(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            projects = root / "projects"
-            db_path = root / "state.vscdb"
-            logs = root / "logs"
-            logs.mkdir()
-            conn = sqlite3.connect(db_path)
-            conn.execute("CREATE TABLE composerHeaders (composerId TEXT, workspaceId TEXT, createdAt INTEGER, lastUpdatedAt INTEGER, isArchived INTEGER, isSubagent INTEGER, checkpointAt INTEGER, value TEXT)")
-            conn.execute("CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value TEXT)")
-            rows = [
-                ("older", 1_784_548_800_000, 0, "gpt-5.6-sol"),
-                ("newer", 1_784_548_900_000, 0, "composer-2.5"),
-                ("child", 1_784_549_000_000, 1, "composer-2.5"),
-            ]
-            for sid, updated, subagent, model in rows:
-                header = {"name": sid.title(), "workspaceIdentifier": {"uri": {"fsPath": "/repo"}}}
-                if subagent:
-                    header["subagentInfo"] = {
-                        "parentComposerId": "newer", "subagentTypeName": "explore",
-                    }
-                composer = {"modelConfig": {"modelName": model}}
-                conn.execute("INSERT INTO composerHeaders VALUES (?, ?, ?, ?, 0, ?, 0, ?)",
-                             (sid, "workspace", updated - 1000, updated, subagent, json.dumps(header)))
-                conn.execute("INSERT INTO cursorDiskKV VALUES (?, ?)",
-                             (f"composerData:{sid}", json.dumps(composer)))
-                trace_dir = projects / "Users-test-repo" / "agent-transcripts" / sid
-                trace_dir.mkdir(parents=True)
-                transcript = trace_dir / f"{sid}.jsonl"
-                transcript.write_text(json.dumps({"role": "user"}) + "\n")
-                os.utime(transcript, (updated / 1000, updated / 1000))
-            nested = (projects / "Users-test-repo" / "agent-transcripts" / "newer" /
-                      "subagents" / "nested.jsonl")
-            nested.parent.mkdir(parents=True)
-            nested.write_text(json.dumps({"role": "user"}) + "\n")
-            os.utime(nested, (1_784_548_000, 1_784_548_000))
-            duplicate = projects / "empty-window" / "agent-transcripts" / "newer" / "newer.jsonl"
-            duplicate.parent.mkdir(parents=True)
-            duplicate.write_text(json.dumps({"role": "user", "replica": "newest"}) + "\n")
-            os.utime(duplicate, (1_784_551_000, 1_784_551_000))
-            conn.commit()
-            conn.close()
-            request_log = logs / "cursor.requestTraces.log"
-            request_log.write_text(
-                "2026-07-20T10:00:01Z span_completed name=client.ttft "
-                "composerId=newer durationMs=100 requestId=r1 traceId=t1 error=false\n"
-            )
-            os.utime(request_log, (1_784_550_000, 1_784_550_000))
-            with mock.patch.object(meter, "CURSOR_PROJECTS", str(projects)), \
-                    mock.patch.object(meter, "CURSOR_STATE_DB", str(db_path)), \
-                    mock.patch.object(meter, "CURSOR_REQUEST_LOGS", str(logs)), \
-                    mock.patch.object(meter, "OPENCODE_DB", str(root / "no-opencode.db")), \
-                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
-                    mock.patch.object(meter, "CODEX_SESSIONS", str(root / "no-codex")), \
-                    mock.patch.object(meter, "CODEX_INDEX", str(root / "no-index")), \
-                    mock.patch.object(meter, "KIRO_SESSIONS", str(root / "no-kiro")), \
-                    mock.patch.object(meter, "KIRO_AGENT_STORAGE", str(root / "no-kiro-agent")), \
-                    mock.patch.object(meter, "PI_AGENT_DIR", str(root / "no-pi-agent")), \
-                    mock.patch.object(meter, "HERMES_STATE_DB", str(root / "no-hermes.db")), \
-                    mock.patch.object(meter, "AGY_BRAIN_DIR", str(root / "no-agy-brain")), \
-                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
-                    mock.patch.object(meter, "claude_desktop_index", return_value={}):
-                sources = meter.all_session_sources()
-            self.assertEqual({row["id"] for row in sources}, {"older", "newer", "child", "nested"})
-            self.assertEqual(len(sources), 4)
-            by_id = {row["id"]: row for row in sources}
-            parent_agent = meter.cursor_agent_id("newer")
-            self.assertEqual(by_id["newer"]["agent_kind"], "root")
-            self.assertEqual(by_id["newer"]["agent_id"], parent_agent)
-            self.assertIsNone(by_id["newer"]["agent_parent_id"])
-            self.assertEqual(by_id["child"]["agent_kind"], "spawned")
-            self.assertEqual(by_id["child"]["agent_parent_id"], parent_agent)
-            self.assertEqual(by_id["child"]["agent_role"], "explore")
-            self.assertEqual(by_id["nested"]["agent_kind"], "spawned")
-            self.assertEqual(by_id["nested"]["agent_parent_id"], parent_agent)
-            self.assertTrue(by_id["nested"]["project"].endswith("test/repo"))
-            self.assertNotIn("newer", by_id["newer"]["agent_id"])
-            self.assertEqual(max(sources, key=lambda row: row["mtime"])["id"], "newer")
-            newer = next(row for row in sources if row["id"] == "newer")
-            self.assertEqual(newer["path"], str(duplicate))
-            self.assertEqual(newer["model"], "composer-2.5")
-            self.assertEqual(newer["project"], "/repo")
-            self.assertEqual(newer["signature_mtime"], newer["mtime"])
-            self.assertTrue(newer["request_revision"])
-
-    def test_cursor_forked_subagent_skips_inherited_bubbles_and_joins_parent_group(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            db_path = Path(tmp) / "state.vscdb"
-            conn = sqlite3.connect(db_path)
-            conn.execute("CREATE TABLE composerHeaders (composerId TEXT, workspaceId TEXT, createdAt INTEGER, lastUpdatedAt INTEGER, isArchived INTEGER, isSubagent INTEGER, checkpointAt INTEGER, value TEXT)")
-            conn.execute("CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value TEXT)")
-            base_ms = 1_784_548_800_000
-
-            def bubble(sid, bid, kind, offset, text):
-                conn.execute("INSERT INTO cursorDiskKV VALUES (?, ?)", (
-                    f"bubbleId:{sid}:{bid}", json.dumps({
-                        "type": kind, "bubbleId": bid, "createdAt": base_ms + offset,
-                        "text": text, "modelInfo": {"modelName": "gpt-5.6-sol"},
-                        **({"turnDurationMs": 1000} if kind == 2 else {}),
-                    })))
-
-            shared = [("u1", 1, 0, "parent ask"), ("a1", 2, 1000, "p" * 400)]
-            for sid, header, own in (
-                ("parent", {}, []),
-                ("fork", {"subagentInfo": {
-                    "parentComposerId": "parent", "forkedFromComposerId": "parent",
-                    "conversationLengthAtSpawn": 2, "subagentTypeName": "generalPurpose",
-                }}, [("u2", 1, 5000, "child ask"), ("a2", 2, 6000, "c" * 40)]),
-            ):
-                rows = shared + own
-                for bid, kind, offset, text in rows:
-                    bubble(sid, bid, kind, offset, text)
-                conn.execute("INSERT INTO composerHeaders VALUES (?, 'w', ?, ?, 0, ?, 0, ?)", (
-                    sid, base_ms, base_ms + 7000, 1 if own else 0, json.dumps(header)))
-                conn.execute("INSERT INTO cursorDiskKV VALUES (?, ?)", (
-                    f"composerData:{sid}", json.dumps({
-                        "modelConfig": {"modelName": "gpt-5.6-sol"},
-                        "contextTokensUsed": 1000,
-                        "fullConversationHeadersOnly": [{"bubbleId": row[0]} for row in rows],
-                    })))
-            conn.commit()
-            conn.close()
-            adapter = meter._cursor_adapter_for(
-                projects_root=str(Path(tmp) / "projects"), database_path=str(db_path),
-                request_logs=str(Path(tmp) / "logs"),
-            )
-            fork = adapter.snapshot("fork")
-            self.assertEqual([item["bubbleId"] for item in fork["bubbles"]], ["u2", "a2"])
-            conn = sqlite3.connect(db_path)
-            conn.execute("UPDATE cursorDiskKV SET value=? WHERE key='composerData:parent'", (
-                json.dumps({"fullConversationHeadersOnly": [{"bubbleId": "u1"}, {"bubbleId": "other"}]}),))
-            conn.commit()
-            conn.close()
-            adapter.reset_metadata_cache()
-            partial = adapter.snapshot("fork")
-            self.assertEqual([item["bubbleId"] for item in partial["bubbles"]], ["a1", "u2", "a2"])
-            conn = sqlite3.connect(db_path)
-            conn.execute("UPDATE cursorDiskKV SET value=? WHERE key='composerData:parent'", (
-                json.dumps({"fullConversationHeadersOnly": [{"bubbleId": "u1"}, {"bubbleId": "a1"}]}),))
-            conn.commit()
-            conn.close()
-
-            parent_source = {**self.source("/tmp/parent.jsonl", "parent"),
-                             "agent_id": meter.cursor_agent_id("parent"),
-                             "agent_kind": "root", "agent_parent_id": None, "agent_role": ""}
-            fork_source = {**self.source("/tmp/fork.jsonl", "fork"),
-                           "agent_id": meter.cursor_agent_id("fork"), "agent_kind": "spawned",
-                           "agent_parent_id": meter.cursor_agent_id("parent"),
-                           "agent_role": "generalPurpose"}
-            with mock.patch.object(meter, "cursor_snapshot", side_effect=adapter.snapshot_legacy), \
-                    mock.patch.object(meter, "cursor_request_spans", return_value=[]), \
-                    mock.patch.object(meter, "load", return_value=[]):
-                rows = [adapter.summarize_legacy(parent_source),
-                        adapter.summarize_legacy(fork_source)]
-        fork_record = rows[1]["_agent_records"][0]
-        self.assertEqual(fork_record["output_tokens"], 10)
-        self.assertEqual(fork_record["role"], "generalPurpose")
-        self.assertEqual(fork_record["session_id"], "fork")
-        self.assertEqual(fork_record["activity_state"], "complete")
-        groups = meter._domain_build_agent_groups(rows)
-        self.assertEqual(len(groups), 1)
-        self.assertEqual(groups[0]["root_session_id"], "parent")
-        self.assertEqual(groups[0]["coverage"]["relationships"], "complete")
-        self.assertEqual([agent["kind"] for agent in groups[0]["agents"]], ["root", "spawned"])
-        self.assertEqual(groups[0]["child_totals"]["tokens"], 1010)
-
-    def test_cursor_recompute_exposes_context_tools_reasoning_wait_ttft_and_retries(self):
-        with mock.patch.object(meter, "cursor_snapshot", return_value=self.snapshot()), \
-                mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
-            state = meter.recompute_cursor(self.source())
-        self.assertEqual(state["provider"], "cursor")
-        self.assertEqual(state["primary_model"], "composer-2.5")
-        self.assertEqual(state["context"]["latest"], 80448)
-        self.assertEqual(state["context"]["window"], 200000)
-        self.assertTrue(state["context"]["estimated"])
-        self.assertEqual(state["context"]["breakdown"][0]["estimated_tokens"], 1234)
-        self.assertTrue(state["availability"]["cost"])
-        self.assertTrue(state["availability"]["tokens"])
-        self.assertFalse(state["availability"]["cache"])
-        self.assertTrue(state["availability"]["throughput"])
-        self.assertTrue(state["availability"]["context"])
-        self.assertTrue(state["availability"]["timing"])
-        self.assertTrue(state["availability"]["tool_results"])
-        execution = state["executions"][0]
-        self.assertEqual(execution["tools"][0]["name"], "ripgrep_raw_search")
-        self.assertTrue(execution["tools"][0]["error"])
-        self.assertGreater(execution["tokens"]["retrieval"], 0)
-        self.assertAlmostEqual(execution["wait_duration_ms"], 46624, places=3)
-        self.assertAlmostEqual(execution["ttft_ms"], 4118, places=3)
-        self.assertEqual((execution["attempts"], execution["failed_attempts"], execution["retries"]),
-                         (2, 1, 1))
-        self.assertEqual(execution["reasoning_duration_ms"], 3200)
-        self.assertEqual(execution["reasoning_tokens"], 4)
-        self.assertEqual(execution["tokens"]["input"], 80448)
-        self.assertEqual(execution["tokens"]["output"], 6)
-        self.assertEqual(execution["pricing_variant"], "fast")
-        self.assertAlmostEqual(execution["cost"], 0.241434, places=6)
-        self.assertTrue(state["cost_approx"])
-        self.assertTrue(state["token_estimate"])
-
-    def test_cursor_turn_timing_attributes_each_span_to_the_turn_it_started_in(self):
-        base = 1_784_548_800.0
-        starts = [base, base + 76.5, base + 86.6]
-        spans = [
-            {"name": "agent.request.attempt", "start_ts": base + 0.2,
-             "end_ts": base + 76.6, "duration_s": 76.4, "request_id": "a", "error": False},
-            {"name": "agent.request.attempt", "start_ts": base + 76.7,
-             "end_ts": base + 101.6, "duration_s": 24.9, "request_id": "b", "error": False},
-            {"name": "agent.request.attempt", "start_ts": base + 84.1,
-             "end_ts": base + 90.0, "duration_s": 5.9, "request_id": "c", "error": False},
-        ]
-        timings = [
-            meter.cursor_turn_timing(
-                spans, start, starts[index + 1] if index + 1 < len(starts) else 0,
-                start + 1,
-            )
-            for index, start in enumerate(starts)
-        ]
-        self.assertEqual([round(item["active_s"], 1) for item in timings], [76.4, 24.9, 5.9])
-        self.assertEqual([item["attempts"] for item in timings], [1, 1, 1])
-        self.assertAlmostEqual(timings[1]["wait_s"], 25.1, places=3)
-        self.assertAlmostEqual(timings[2]["end_ts"], base + 90.0, places=3)
-
-        retry = {"name": "agent.request.attempt", "start_ts": base + 80.0,
-                 "end_ts": base + 82.0, "duration_s": 2.0, "request_id": "turn-a",
-                 "error": False}
-        claimed = frozenset(("turn-a", "turn-b"))
-        turn_a = meter.cursor_turn_timing(
-            [spans[0], retry], base, base + 10, base + 1,
-            request_id="turn-a", claimed_request_ids=claimed,
-        )
-        turn_b = meter.cursor_turn_timing(
-            [spans[0], retry], base + 10, 0, base + 11,
-            request_id="turn-b", claimed_request_ids=claimed,
-        )
-        self.assertEqual((turn_a["attempts"], turn_b["attempts"]), (2, 0))
-        self.assertAlmostEqual(turn_a["end_ts"], base + 82.0, places=3)
-
-    def test_cursor_tool_identity_classifies_orchestration_interaction_and_mcp_tools(self):
-        expected = {
-            "task_v2": ("Subagent", "orchestration", "tool"),
-            "update_current_step": ("Update step", "planning", "tool"),
-            "ask_question": ("Ask question", "interaction", "tool"),
-            "switch_mode": ("Switch mode", "interaction", "tool"),
-            "set_active_branch": ("Set branch", "workspace", "tool"),
-            "search_conversations": ("Search chats", "search", "tool"),
-            "get_mcp_tools": ("MCP tool lookup", "tool_search", "tool"),
-            "mcp-cursor-app-control-open_resource": (
-                "open_resource", "cursor-app-control", "mcp",
-            ),
-        }
-        for name, (display, namespace, kind) in expected.items():
-            with self.subTest(name=name):
-                ident = meter.cursor_tool_identity(name)
-                self.assertEqual(ident["name"], name)
-                self.assertEqual(
-                    (ident["display"], ident["namespace"], ident["kind"]),
-                    (display, namespace, kind),
-                )
-        self.assertEqual(meter.cursor_tool_identity("Read")["name"], "read_file_v2")
-        self.assertEqual(meter.cursor_tool_identity("mcp-")["kind"], "tool")
-
-    def test_cursor_transcript_fallback_survives_missing_database(self):
-        transcript = [
-            {"role": "user", "message": {"content": [{"type": "text", "text": "<user_query>hello</user_query>"}]}},
-            {"role": "assistant", "message": {"content": [
-                {"type": "tool_use", "id": "one", "name": "Read", "input": {"path": "README.md"}},
-                {"type": "text", "text": "done"},
-            ]}},
-            {"type": "turn_ended", "status": "success"},
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "fallback.jsonl"
-            path.write_text("".join(json.dumps(row) + "\n" for row in transcript))
-            with mock.patch.object(meter, "cursor_snapshot", return_value={"available": False}), \
-                    mock.patch.object(meter, "cursor_request_spans") as spans:
-                state = meter.recompute_cursor(self.source(str(path), "fallback"))
-        spans.assert_not_called()
-        self.assertEqual(state["turns"], 1)
-        self.assertTrue(state["cursor_enrichment"]["transcript_fallback"])
-        self.assertEqual(state["executions"][0]["tools"][0]["name"], "read_file_v2")
-        self.assertFalse(state["availability"]["tool_results"])
-
-    def test_cursor_pricing_uses_persisted_composer_variant_and_fails_closed_without_it(self):
-        price, approximate = meter.price_for("composer-2.5", "cursor")
-        self.assertEqual(price, meter.ZERO_PRICE)
-        self.assertTrue(approximate)
-        fast, approximate = meter.price_for("composer-2.5", "cursor", "fast")
-        standard, _ = meter.price_for("composer-2.5", "cursor", "standard")
-        self.assertEqual((fast["input"], fast["output"]), (3.0, 15.0))
-        self.assertEqual((standard["input"], standard["output"]), (0.5, 2.5))
-        self.assertTrue(approximate)
-        self.assertEqual(meter.cursor_price_variant(self.snapshot()["composer"], "composer-2.5"),
-                         "fast")
-
-    def test_cursor_subagent_prices_the_speed_its_parent_spawn_call_recorded(self):
-        def child():
-            data = self.snapshot()
-            data["header"]["subagentInfo"] = {"parentComposerId": "parent", "toolCallId": "spawn-1"}
-            data["composer"]["modelConfig"]["selectedModels"] = [{"modelId": "composer-2.5"}]
-            for bubble in data["bubbles"]:
-                bubble.pop("modelInfo", None)
-            return data
-
-        def parent(spawn_model, tool_call_id="spawn-1"):
-            return {"available": True, "header": {}, "composer": {}, "bubbles": [
-                {"type": 2, "bubbleId": "spawn", "toolFormerData": {
-                    "name": "task_v2", "toolCallId": tool_call_id,
-                    "params": json.dumps({"model": spawn_model, "prompt": "delegate"}),
-                }},
-            ]}
-
-        cases = (
-            ("composer-2.5-fast", "spawn-1", 3.0),
-            ("composer-2.5-standard", "spawn-1", 0.5),
-            ("composer-2.5", "spawn-1", None),
-            ("grok-4.6-fast", "spawn-1", None),
-            ("composer-2.5-fast", "other-call", None),
-        )
-        for spawn_model, tool_call_id, input_rate in cases:
-            with self.subTest(spawn_model=spawn_model, tool_call_id=tool_call_id):
-                snapshots = {"cursor-session": child(), "parent": parent(spawn_model, tool_call_id)}
-                with mock.patch.object(meter, "cursor_snapshot", side_effect=snapshots.__getitem__), \
-                        mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
-                    state = meter.recompute_cursor(self.source())
-                execution = state["executions"][0]
-                if input_rate is None:
-                    self.assertFalse(state["availability"]["cost"])
-                    self.assertEqual(execution["cost"], 0)
-                    continue
-                self.assertTrue(state["availability"]["cost"])
-                self.assertAlmostEqual(execution["cost_breakdown"]["input"], 80448 * input_rate / 1e6)
-
-    def test_cursor_pricing_uses_published_third_party_and_grok_rates(self):
-        after_sol_update = 1_788_000_000
-        cases = {
-            ("claude-opus-5-5", ""): (4.0, 5.0, 0.2, 20.0),
-            ("claude-opus-5-5-medium", ""): (4.0, 5.0, 0.2, 20.0),
-            ("gpt-5.6-sol", ""): (4.0, 5.0, 0.4, 20.0),
-            ("gpt-5.6-sol-xhigh", ""): (4.0, 5.0, 0.4, 20.0),
-            ("grok-4.7", "standard"): (2.0, 0.0, 0.5, 6.0),
-            ("grok-4.7", "fast"): (4.0, 0.0, 1.0, 12.0),
-            ("grok-4.7", "500k-standard"): (4.0, 0.0, 1.0, 12.0),
-            ("grok-4.7", "500k-fast"): (6.0, 0.0, 1.5, 18.0),
-        }
-        for (model, variant), rates in cases.items():
-            with self.subTest(model=model, variant=variant):
-                price, _ = meter.price_for(model, "cursor", variant, at=after_sol_update)
-                self.assertEqual(
-                    (price["input"], price["cache_write"], price["cache_read"], price["output"]),
-                    rates,
-                )
-        before, _ = meter.price_for("gpt-5.6-sol", "cursor", "", at=1_786_000_000)
-        self.assertEqual((before["input"], before["output"]), (5.0, 30.0))
-        for model, variant in (("claude-opus-5-5", "fast"), ("gpt-5.6-sol", "max"),
-                               ("gpt-5.6-sol", "max-fast"), ("composer-2.5", "max"),
-                               ("composer-2.5", "max-fast"), ("claude-opus-5-5-turbo", ""),
-                               ("claude-opus-5-5-turbo", "max")):
-            with self.subTest(unpriced=model, variant=variant):
-                price, _ = meter.price_for(model, "cursor", variant)
-                self.assertEqual(price, meter.ZERO_PRICE)
-
-    def test_cursor_max_mode_bills_the_api_rate_plus_twenty_percent(self):
-        cases = {
-            ("claude-opus-5-5", "max"): (4.8, 6.0, 0.24, 24.0),
-            ("claude-opus-5-5-medium", "max"): (4.8, 6.0, 0.24, 24.0),
-            ("claude-opus-5-5", "max-fast"): (9.6, 12.0, 0.48, 48.0),
-        }
-        for (model, variant), rates in cases.items():
-            with self.subTest(model=model, variant=variant):
-                price, _ = meter.price_for(model, "cursor", variant)
-                self.assertEqual(
-                    tuple(round(price[key], 6) for key in ("input", "cache_write", "cache_read", "output")),
-                    rates,
-                )
-        cost = meter.cost_of({"input_tokens": 1_000_000, "output_tokens": 100_000},
-                             "claude-opus-5-5", "cursor", "max")
-        self.assertAlmostEqual(sum(cost.values()), 4.8 + 2.4)
-
-    def test_cursor_model_name_drops_effort_suffix_only_for_selected_model(self):
-        def composer(name, model_id):
-            return {"modelConfig": {"modelName": name, "selectedModels": [{"modelId": model_id}]}}
-        self.assertEqual(meter.cursor_model(composer("gpt-5.6-sol-xhigh", "gpt-5.6-sol")),
-                         "gpt-5.6-sol")
-        self.assertEqual(meter.cursor_model(composer("claude-opus-5-5-medium", "claude-opus-5-5")),
-                         "claude-opus-5-5")
-        self.assertEqual(meter.cursor_model(composer("gpt-5.6-sol-turbo", "gpt-5.6-sol")),
-                         "gpt-5.6-sol-turbo")
-        self.assertEqual(meter.cursor_model(composer("grok-4.6-high", "composer-2.5")),
-                         "grok-4.6-high")
-
-    def test_cursor_price_variant_reads_fast_max_and_context_parameters(self):
-        def composer(model, params, max_mode=False):
-            return {"modelConfig": {"modelName": model, "maxMode": max_mode, "selectedModels": [{
-                "modelId": model,
-                "parameters": [{"id": key, "value": value} for key, value in params.items()],
-            }]}}
-        self.assertEqual(meter.cursor_price_variant(
-            composer("claude-opus-5-5", {"fast": "false", "effort": "medium"}), "claude-opus-5-5"), "")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("claude-opus-5-5", {"fast": "true"}), "claude-opus-5-5"), "fast")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("gpt-5.6-sol", {}, max_mode=True), "gpt-5.6-sol"), "max")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("composer-2.5", {"fast": "true"}, max_mode=True), "composer-2.5"), "max-fast")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("claude-opus-5-5", {"fast": "false", "context": "300k"}, max_mode=True),
-            "claude-opus-5-5"), "max")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("claude-opus-5-5", {"fast": "true", "context": "1m"}, max_mode=True),
-            "claude-opus-5-5-high"), "max-fast")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("grok-4.7", {"fast": "true", "context": "500k"}), "grok-4.7"), "500k-fast")
-        self.assertEqual(meter.cursor_price_variant(
-            composer("grok-4.7", {"fast": "false"}), "grok-4.7"), "standard")
-
-    def test_cursor_pricing_rejects_composer_lookalikes_and_accepts_qualified_alias(self):
-        composer = self.snapshot()["composer"]
-        composer["modelConfig"]["selectedModels"].insert(0, {
-            "modelId": "some-other-model",
-            "parameters": [{"id": "fast", "value": "false"}],
-        })
-        qualified, approximate = meter.price_for(
-            "cursor.composer-2.5", "cursor", "fast"
-        )
-        self.assertTrue(approximate)
-        self.assertEqual((qualified["input"], qualified["output"]), (3.0, 15.0))
-        self.assertEqual(
-            meter.cursor_price_variant(composer, "cursor.composer-2.5"), "fast"
-        )
-
-        for model in ("composer-2.5ish", "composer-2.5-future"):
-            with self.subTest(model=model):
-                price, unavailable = meter.price_for(model, "cursor", "fast")
-                self.assertTrue(unavailable)
-                self.assertEqual(price, meter.ZERO_PRICE)
-                self.assertEqual(meter.cursor_price_variant(self.snapshot()["composer"], model), "")
-
-    def test_cursor_agent_check_reports_local_estimate_and_caveat(self):
-        with mock.patch.object(meter, "cursor_snapshot", return_value=self.snapshot()), \
-                mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
-            state = meter.recompute_cursor(self.source())
-        with mock.patch.object(meter, "resolve_agent_source", return_value=(self.source(), "matched")), \
-                mock.patch.object(meter, "recompute", return_value=state):
-            result = meter.agent_check(focus="cost", caller={"runtime": "cursor", "project": "/repo"})
-        self.assertTrue(result["ok"])
-        self.assertAlmostEqual(result["evidence"][0]["value"], 0.2414, places=4)
-        self.assertTrue(result["availability"]["cost"])
-        self.assertIn("local", result["caveat"].lower())
-        self.assertIn("cost", result["approximate_fields"])
-
-    def test_cursor_summary_and_model_rollup_include_local_estimates(self):
-        with mock.patch.object(meter, "cursor_snapshot", return_value=self.snapshot()), \
-                mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
-            state = meter.recompute_cursor(self.source())
-        with mock.patch.object(meter, "recompute_cursor", return_value=state):
-            row = meter.cursor_summary(self.source())
-        aggregate = meter.aggregate_model_stats([row])
-        model = aggregate["models"][0]
-        self.assertEqual(row["turns"], 1)
-        self.assertEqual(row["models"], ["composer-2.5"])
-        # Live-session selection uses the end of the last execution, not the database file time.
-        self.assertEqual(row["last_activity_ts"], float(state["timing"]["end_ts"]))
-        self.assertTrue(row["availability"]["cost"])
-        self.assertTrue(row["cost_approx"])
-        self.assertEqual(row["input_tokens"], 80448)
-        self.assertEqual(row["output_tokens"], 6)
-        self.assertEqual(row["usage_basis"], "local_estimate")
-        self.assertEqual(row["provenance"]["estimated_sessions"], 1)
-        self.assertEqual(model["model"], "composer-2.5")
-        self.assertEqual(model["runtime"], "Cursor")
-        self.assertEqual(model["usage_basis"], "local_estimate")
-        self.assertFalse(model["availability"]["cache"])
-        self.assertEqual(model["coverage"]["cache"]["covered_sessions"], 0)
-        self.assertEqual(model["executions"], 1)
-        self.assertEqual(model["median_peak_input_tokens"], 80448)
-        self.assertEqual(model["median_tool_calls"], 1)
-        self.assertAlmostEqual(model["median_wait_s"], 46.624, places=3)
-        self.assertAlmostEqual(model["avg_ttft_ms"], 4118, places=3)
-        self.assertTrue(model["availability"]["tokens"])
-        self.assertEqual(model["input_tokens"], 80448)
-        self.assertEqual(model["output_tokens"], 6)
-        self.assertEqual(model["reasoning_tokens"], 4)
-        self.assertEqual(model["reasoning_output_tokens"], 6)
-        self.assertEqual(model["reasoning_executions"], 1)
-        self.assertTrue(model["availability"]["reasoning_tokens"])
-        self.assertEqual((model["attempts"], model["retries"], model["failed_attempts"]),
-                         (2, 1, 1))
-        self.assertTrue(model["availability"]["attempts"])
-
-    def test_cursor_summary_keeps_priced_model_coverage_in_mixed_session(self):
-        session_availability = meter.metric_availability(
-            "cursor", cost=False, tokens=True, input_tokens=True,
-            output_tokens=True,
-        )
-
-        def execution(model, output_tokens, cost, cost_available, ts):
-            return {
-                "model": model, "ts": ts, "cost": cost,
-                "tokens": {"input": 100, "output": output_tokens},
-                "context_tokens": 100, "reasoning_tokens": 0,
-                "availability": meter.metric_availability(
-                    "cursor", cost=cost_available, tokens=True,
-                    input_tokens=True, output_tokens=True,
-                ),
-                "tools": [], "tool_count": 0, "model_calls": 1,
-            }
-
-        state = {
-            "availability": session_availability,
-            "executions": [
-                execution("composer-2.5", 20, 0.1, True, 1_784_548_801),
-                execution("unknown-model", 30, 0.0, False, 1_784_548_802),
-            ],
-            "total_cost": 0.1, "total_tokens": 250,
-            "tokens": {"input": 200, "output": 50},
-            "cost_approx": True, "token_estimate": True,
-            "timing": {}, "wait_time": {}, "context": {},
-        }
-        with mock.patch.object(meter, "recompute_cursor", return_value=state):
-            row = meter.cursor_summary(self.source())
-
-        self.assertFalse(row["availability"]["cost"])
-        stats = {item["model"]: item for item in row["model_stats"]}
-        self.assertTrue(stats["composer-2.5"]["availability"]["cost"])
-        self.assertEqual(stats["composer-2.5"]["cost_covered_executions"], 1)
-        self.assertEqual(stats["composer-2.5"]["cost_covered_output_tokens"], 20)
-        self.assertFalse(stats["unknown-model"]["availability"]["cost"])
-        daily = {item["model"]: item for item in row["_model_daily"]}
-        self.assertTrue(daily["composer-2.5"]["availability"]["cost"])
-        self.assertFalse(daily["unknown-model"]["availability"]["cost"])
-
-        aggregate = {
-            item["model"]: item for item in meter.aggregate_model_stats([row])["models"]
-        }
-        self.assertTrue(aggregate["composer-2.5"]["availability"]["cost"])
-        self.assertEqual(
-            aggregate["composer-2.5"]["cost_covered_output_tokens"], 20,
-        )
-        self.assertFalse(aggregate["unknown-model"]["availability"]["cost"])
-
-    def test_cursor_efficiency_coverage_requires_output_evidence(self):
-        session_availability = meter.metric_availability(
-            "cursor", cost=True, tokens=True, input_tokens=True,
-            output_tokens=False,
-        )
-
-        def execution(output_tokens, output_available, cost, ts):
-            return {
-                "model": "composer-2.5", "ts": ts, "cost": cost,
-                "tokens": {"input": 100, "output": output_tokens},
-                "context_tokens": 100, "reasoning_tokens": output_tokens // 2,
-                "availability": meter.metric_availability(
-                    "cursor", cost=True, tokens=True, input_tokens=True,
-                    output_tokens=output_available,
-                ),
-                "tools": [], "tool_count": 0, "model_calls": 1,
-            }
-
-        state = {
-            "availability": session_availability,
-            "executions": [
-                execution(20, True, 0.1, 1_784_548_801),
-                execution(0, False, 0.05, 1_784_548_802),
-            ],
-            "total_cost": 0.15, "total_tokens": 220,
-            "tokens": {"input": 200, "output": 20},
-            "cost_approx": True, "token_estimate": True,
-            "timing": {}, "wait_time": {}, "context": {},
-        }
-        with mock.patch.object(meter, "recompute_cursor", return_value=state):
-            row = meter.cursor_summary(self.source())
-
-        stats = row["model_stats"][0]
-        self.assertEqual(stats["executions"], 2)
-        self.assertEqual(stats["token_covered_executions"], 1)
-        self.assertEqual(stats["io_covered_executions"], 1)
-        self.assertEqual(stats["io_covered_input_tokens"], 100)
-        self.assertEqual(stats["io_covered_output_tokens"], 20)
-        self.assertEqual(stats["cost_covered_executions"], 1)
-        self.assertEqual(stats["cost_covered_output_tokens"], 20)
-        self.assertAlmostEqual(stats["cost_covered_cost"], 0.1)
-        self.assertEqual(stats["reasoning_executions"], 1)
-        self.assertEqual(stats["reasoning_unavailable_executions"], 1)
-
-        aggregate = meter.aggregate_model_stats([row])["models"][0]
-        self.assertFalse(aggregate["coverage"]["cost"]["complete"])
-        self.assertFalse(aggregate["coverage"]["reasoning_tokens"]["complete"])
-        self.assertEqual(aggregate["io_covered_executions"], 1)
-        self.assertEqual(aggregate["io_covered_input_tokens"], 100)
-        self.assertEqual(aggregate["io_covered_output_tokens"], 20)
-        self.assertEqual(aggregate["daily"][0]["io_covered_input_tokens"], 100)
-        self.assertAlmostEqual(aggregate["cost_covered_cost"], 0.1)
-
-    def test_usage_provenance_distinguishes_reported_estimated_and_mixed(self):
-        reported = {"id": "reported", "provider": "codex", "cost": 1, "tokens": 10}
-        estimated = {
-            "id": "estimated", "provider": "cursor", "cost": 2, "tokens": 20,
-            "token_estimate": True,
-            "availability": meter.metric_availability("cursor", cost=True, tokens=True),
-        }
-        self.assertEqual(meter.usage_provenance([reported])["usage_basis"], "reported")
-        local = meter.usage_provenance([estimated])
-        self.assertEqual(local["usage_basis"], "local_estimate")
-        self.assertEqual(local["estimated_cost"], 2)
-        mixed = meter.usage_provenance([reported, estimated])
-        self.assertEqual(mixed["usage_basis"], "mixed")
-        self.assertEqual((mixed["reported_sessions"], mixed["estimated_sessions"]), (1, 1))
-
-    def test_cursor_sparse_context_is_interpolated_between_persisted_checkpoints(self):
-        groups = [
-            {"context": {}},
-            {"context": {"tokensUsed": 60000, "tokenLimit": 200000}},
-            {"context": {}},
-        ]
-        rows = meter.cursor_context_estimates(groups, 90000, 200000)
-        self.assertEqual([row["tokens"] for row in rows], [30000, 60000, 90000])
-        self.assertTrue(rows[0]["interpolated"])
-        self.assertFalse(rows[1]["interpolated"])
-
-    def test_mixed_runtime_coverage_is_explicitly_partial(self):
-        covered = {"availability": meter.metric_availability("codex")}
-        cursor = {"availability": meter.metric_availability("cursor")}
-        self.assertEqual(meter.metric_coverage([covered, cursor], "cost"), {
-            "covered_sessions": 1, "total_sessions": 2, "complete": False,
-        })
-
-
-class ExecutionTimingTests(unittest.TestCase):
-    def test_merges_overlapping_execution_windows(self):
-        seconds = meter._merge_execution_intervals([(0, 10), (5, 15), (20, 25)])
-        self.assertEqual(seconds, 20)
-
-    def test_uses_claude_reported_turn_durations(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-06-30T00:00:00.000Z", "message": {"content": "first"}},
-            {"type": "system", "subtype": "turn_duration", "timestamp": "2026-06-30T00:00:10.000Z", "durationMs": 10000},
-            {"type": "user", "timestamp": "2026-06-30T00:01:00.000Z", "message": {"content": "second"}},
-            {"type": "system", "subtype": "turn_duration", "timestamp": "2026-06-30T00:01:20.000Z", "durationMs": 20000},
-        ]
-        timing = meter.execution_timing("claude", objs)
-        self.assertEqual(timing["duration_s"], 30)
-        self.assertEqual(timing["reported_executions"], 2)
-        self.assertEqual(timing["basis"], "reported")
-
-    def test_claude_observed_fallback_excludes_between_prompt_idle_gap(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-06-30T00:00:00.000Z", "message": {"content": "first"}},
-            {"type": "assistant", "timestamp": "2026-06-30T00:00:10.000Z", "message": {"content": "done"}},
-            {"type": "user", "timestamp": "2026-06-30T01:00:00.000Z", "message": {"content": "second"}},
-            {"type": "assistant", "timestamp": "2026-06-30T01:00:20.000Z", "message": {"content": "done"}},
-        ]
-        timing = meter.execution_timing("claude", objs)
-        self.assertEqual(timing["duration_s"], 30)
-        self.assertEqual(timing["observed_executions"], 2)
-        self.assertEqual(timing["basis"], "observed")
-
-    def test_combines_codex_reported_and_open_execution_time(self):
-        objs = [
-            {"timestamp": "2026-06-30T00:00:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-06-30T00:00:30.000Z", "payload": {"type": "task_complete", "duration_ms": 20000}},
-            {"timestamp": "2026-06-30T00:01:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-06-30T00:01:15.000Z", "payload": {"type": "agent_message"}},
-        ]
-        timing = meter.execution_timing("codex", objs)
-        self.assertEqual(timing["duration_s"], 35)
-        self.assertEqual(timing["reported_executions"], 1)
-        self.assertEqual(timing["observed_executions"], 1)
-        self.assertEqual(timing["basis"], "reported + observed")
-
-    def test_codex_context_accepts_structured_approval_policy(self):
-        self.assertEqual(meter.codex_approval_policy_label("on_request"), "on request")
-        self.assertEqual(
-            meter.codex_approval_policy_label({
-                "granular": {
-                    "sandbox_approval": False,
-                    "request_permissions": True,
-                },
-            }),
-            "granular",
-        )
-
-
-class WaitTimeTests(unittest.TestCase):
-    def test_claude_wait_is_prompt_to_completion_and_dedupes_split_messages(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
-             "message": {"content": "do the work"}},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:02.000Z", "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "text", "text": "working"}],
-                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
-            }},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:03.000Z", "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "tool_use", "id": "tool-1", "name": "Read"}],
-                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
-            }},
-            {"type": "user", "timestamp": "2026-07-13T00:00:04.000Z", "message": {
-                "content": [{"type": "tool_result", "tool_use_id": "tool-1", "content": "done"}],
-            }},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:09.000Z", "message": {
-                "id": "msg-2", "model": "claude-opus-4-8",
-                "content": [{"type": "text", "text": "finished"}],
-                "usage": {"input_tokens": 25, "output_tokens": 20}, "stop_reason": "end_turn",
-            }},
-            {"type": "system", "subtype": "turn_duration",
-             "timestamp": "2026-07-13T00:00:10.000Z", "durationMs": 10000},
-        ]
-        samples = meter.claude_wait_samples(objs)
-        self.assertEqual(len(samples), 1)
-        self.assertEqual(samples[0]["duration_s"], 10)
-        self.assertEqual(samples[0]["tool_calls"], 1)
-        self.assertEqual(samples[0]["output_tokens"], 50)
-        self.assertEqual(samples[0]["timing_basis"], "reported")
-
-    def test_codex_wait_uses_reported_duration_and_includes_tool_time(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-13T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-13T00:00:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-13T00:00:02.000Z", "payload": {
-                "type": "function_call", "name": "exec_command", "call_id": "call-1",
-            }},
-            {"timestamp": "2026-07-13T00:00:08.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100, "output_tokens": 40, "total_tokens": 140,
-                }},
-            }},
-            {"timestamp": "2026-07-13T00:00:10.000Z", "payload": {
-                "type": "task_complete", "duration_ms": 10000,
-            }},
-        ]
-        sample = meter.codex_wait_samples(objs)[0]
-        self.assertEqual(sample["duration_s"], 10)
-        self.assertEqual(sample["tool_calls"], 1)
-        self.assertEqual(sample["output_tokens"], 40)
-        self.assertEqual(sample["model"], "gpt-5.6")
-
-    def test_claude_observed_wait_excludes_time_waiting_for_user_input(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
-             "message": {"content": "start"}},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:10.000Z", "message": {
-                "id": "msg-1", "model": "claude-opus-4-8", "stop_reason": "tool_use",
-                "usage": {"input_tokens": 20, "output_tokens": 10},
-                "content": [{"type": "tool_use", "id": "question-1", "name": "AskUserQuestion"}],
-            }},
-            {"type": "user", "timestamp": "2026-07-13T00:01:40.000Z", "message": {
-                "content": [{"type": "tool_result", "tool_use_id": "question-1", "content": "answer"}],
-            }},
-            {"type": "assistant", "timestamp": "2026-07-13T00:01:50.000Z", "message": {
-                "id": "msg-2", "model": "claude-opus-4-8", "stop_reason": "end_turn",
-                "usage": {"input_tokens": 25, "output_tokens": 20},
-                "content": [{"type": "text", "text": "finished"}],
-            }},
-        ]
-        sample = meter.claude_wait_samples(objs)[0]
-        self.assertEqual(sample["wall_duration_s"], 110)
-        self.assertEqual(sample["user_pause_s"], 90)
-        self.assertEqual(sample["duration_s"], 20)
-        self.assertEqual(meter.wait_time_summary([sample])["user_pause_s"], 90)
-
-    def test_wait_summary_reports_average_p95_and_longest(self):
-        summary = meter.wait_time_summary([
-            {"duration_s": 2, "timing_basis": "reported"},
-            {"duration_s": 6, "timing_basis": "observed"},
-            {"duration_s": 10, "timing_basis": "reported"},
-        ])
-        self.assertEqual(summary["total_s"], 18)
-        self.assertEqual(summary["avg_s"], 6)
-        self.assertEqual(summary["median_s"], 6)
-        self.assertEqual(summary["p95_s"], 10)
-        self.assertEqual(summary["max_s"], 10)
-
-
-class ModelPerformanceTests(unittest.TestCase):
-    def setUp(self):
-        # Matched-pace comparisons are cached per model pair and persisted, so
-        # each test starts from a clean in-memory and on-disk cache and never
-        # writes into the developer's home directory.
-        self._pace_temp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._pace_temp.cleanup)
-        self._pace_cache_path = Path(self._pace_temp.name) / "matched-pace-cache.json"
-        patcher = mock.patch.object(
-            meter, "TOKEN_METER_MATCHED_PACE_CACHE", str(self._pace_cache_path),
-        )
-        patcher.start()
-        self.addCleanup(patcher.stop)
-        self.addCleanup(meter._matched_pace_pair_cache.clear)
-        self.addCleanup(
-            setattr, meter, "_matched_pace_pair_cache_loaded", False,
-        )
-        self.addCleanup(meter._matched_pace_build_state.update, building=False)
-        self.addCleanup(setattr, meter, "_matched_pace_persist", False)
-        meter._matched_pace_pair_cache.clear()
-        meter._matched_pace_pair_cache_loaded = False
-        meter._matched_pace_build_state["building"] = False
-        meter._matched_pace_persist = True
-        meter._matched_pace_cache.update(signature=None, data=None)
-        self.addCleanup(meter._matched_pace_cache.update, signature=None, data=None)
-
-    def test_parse_iso_reuses_bounded_timestamp_conversions(self):
-        meter.parse_iso.cache_clear()
-        timestamp = "2026-08-14T04:30:00.123Z"
-
-        first = meter.parse_iso(timestamp)
-        before = meter.parse_iso.cache_info()
-        second = meter.parse_iso(timestamp)
-        after = meter.parse_iso.cache_info()
-
-        self.assertEqual(first, second)
-        self.assertEqual(after.hits, before.hits + 1)
-        self.assertLessEqual(after.maxsize, 65536)
-
-    def test_codex_performance_without_model_identity_stays_unknown(self):
-        objs = [
-            {"timestamp": "2026-07-01T00:00:00.000Z",
-             "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-01T00:00:01.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100, "output_tokens": 10,
-                    "total_tokens": 110,
-                }},
-            }},
-            {"timestamp": "2026-07-01T00:00:02.000Z", "payload": {
-                "type": "task_complete", "duration_ms": 2000,
-            }},
-        ]
-
-        samples = meter.codex_performance_samples(objs)
-
-        self.assertEqual(samples[0]["model"], "unknown-model")
-
-    def test_claude_tool_free_turn_uses_reported_turn_duration(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-07-01T00:00:00.000Z",
-             "message": {"content": "hello"}},
-            {"type": "assistant", "timestamp": "2026-07-01T00:00:01.900Z", "message": {
-                "id": "msg-1", "model": "claude-sonnet-5", "content": [{"type": "text", "text": "done"}],
-                "usage": {"input_tokens": 20, "output_tokens": 10}, "stop_reason": "end_turn",
-            }},
-            {"type": "system", "subtype": "turn_duration", "timestamp": "2026-07-01T00:00:02.000Z",
-             "durationMs": 2000},
-        ]
-        samples = meter.claude_performance_samples(objs)
-        summary = meter.performance_summary(samples, 10)
-        self.assertEqual(len(samples), 1)
-        self.assertEqual(samples[0]["tool_calls"], 0)
-        self.assertEqual(samples[0]["peak_input_tokens"], 20)
-        self.assertEqual(samples[0]["model_calls"], 1)
-        self.assertEqual(summary["basis"], "tool_free")
-        self.assertEqual(summary["output_tps"], 5)
-
-    def test_claude_desktop_uses_observed_turn_timing_without_duration_records(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
-             "message": {"content": "inspect the project"}},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:02.000Z", "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "text", "text": "checking"}],
-                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
-            }},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:04.000Z", "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "tool_use", "id": "tool-1", "name": "Read"}],
-                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
-            }},
-            {"type": "user", "timestamp": "2026-07-13T00:00:05.000Z", "message": {
-                "content": [{"type": "tool_result", "tool_use_id": "tool-1", "content": "done"}],
-            }},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:10.000Z", "message": {
-                "id": "msg-2", "model": "claude-opus-4-8",
-                "content": [{"type": "text", "text": "finished"}],
-                "usage": {"input_tokens": 25, "output_tokens": 20}, "stop_reason": "end_turn",
-            }},
-        ]
-        samples = meter.claude_performance_samples(objs)
-        self.assertEqual(len(samples), 1)
-        self.assertEqual(samples[0]["timing_basis"], "observed")
-        self.assertEqual(samples[0]["duration_s"], 10)
-        self.assertEqual(samples[0]["output_tokens"], 50)
-        self.assertEqual(samples[0]["tool_calls"], 1)
-        self.assertEqual(meter.performance_summary(samples, 50)["output_tps"], 5)
-
-    def test_claude_observed_throughput_excludes_user_input_pause(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
-             "message": {"content": "start"}},
-            {"type": "assistant", "timestamp": "2026-07-13T00:00:10.000Z", "message": {
-                "id": "msg-1", "model": "claude-opus-4-8", "stop_reason": "tool_use",
-                "usage": {"input_tokens": 20, "output_tokens": 10},
-                "content": [{"type": "tool_use", "id": "question-1", "name": "AskUserQuestion"}],
-            }},
-            {"type": "user", "timestamp": "2026-07-13T00:01:40.000Z", "message": {
-                "content": [{"type": "tool_result", "tool_use_id": "question-1", "content": "answer"}],
-            }},
-            {"type": "assistant", "timestamp": "2026-07-13T00:01:50.000Z", "message": {
-                "id": "msg-2", "model": "claude-opus-4-8", "stop_reason": "end_turn",
-                "usage": {"input_tokens": 25, "output_tokens": 20},
-                "content": [{"type": "text", "text": "finished"}],
-            }},
-        ]
-        sample = meter.claude_performance_samples(objs)[0]
-        self.assertEqual(sample["wall_duration_s"], 110)
-        self.assertEqual(sample["user_pause_s"], 90)
-        self.assertEqual(sample["duration_s"], 20)
-
-    def test_codex_tool_free_speed_excludes_time_to_first_token(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-01T00:00:09.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 200, "cached_input_tokens": 50,
-                    "output_tokens": 100, "total_tokens": 300,
-                }},
-            }},
-            {"timestamp": "2026-07-01T00:00:10.000Z", "payload": {
-                "type": "task_complete", "duration_ms": 10000, "time_to_first_token_ms": 2000,
-            }},
-        ]
-        samples = meter.codex_performance_samples(objs, "gpt-5.6")
-        summary = meter.performance_summary(samples, 100)
-        self.assertEqual(samples[0]["generation_s"], 8)
-        self.assertEqual(samples[0]["peak_input_tokens"], 200)
-        self.assertEqual(samples[0]["cache_read_tokens"], 50)
-        self.assertEqual(samples[0]["uncached_input_tokens"], 150)
-        self.assertEqual(samples[0]["model_calls"], 1)
-        self.assertEqual(summary["output_tps"], 12.5)
-        self.assertEqual(summary["avg_ttft_ms"], 2000)
-
-    def test_codex_live_speed_uses_completed_steps_before_task_complete(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 200, "cached_input_tokens": 50,
-                    "output_tokens": 40, "total_tokens": 240,
-                }},
-            }},
-            {"timestamp": "2026-07-01T00:00:05.000Z", "payload": {
-                "type": "function_call", "name": "exec_command", "call_id": "call-1",
-            }},
-            {"timestamp": "2026-07-01T00:00:10.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 250, "cached_input_tokens": 100,
-                    "output_tokens": 60, "total_tokens": 310,
-                }},
-            }},
-        ]
-
-        live = meter.codex_live_performance_summary(objs)
-
-        self.assertFalse(meter.performance_summary(
-            meter.codex_performance_samples(objs, "gpt-5.6"), 100,
-        )["available"])
-        self.assertTrue(live["available"])
-        self.assertEqual(live["basis"], "live_end_to_end")
-        self.assertEqual(live["completed_steps"], 2)
-        self.assertEqual(live["measured_output_tokens"], 100)
-        self.assertEqual(live["measured_seconds"], 10)
-        self.assertEqual(live["output_tps"], 10)
-
-    def test_codex_live_speed_disappears_when_task_completes(self):
-        objs = [
-            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 200, "output_tokens": 40, "total_tokens": 240,
-                }},
-            }},
-            {"timestamp": "2026-07-01T00:00:05.000Z", "payload": {
-                "type": "task_complete", "duration_ms": 5000,
-            }},
-        ]
-
-        live = meter.codex_live_performance_summary(objs)
-
-        self.assertFalse(live["available"])
-        self.assertEqual(live["completed_steps"], 0)
-        self.assertEqual(live["output_tps"], 0)
-
-    def test_tool_bearing_task_falls_back_to_end_to_end_throughput(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-01T00:00:02.000Z", "payload": {
-                "type": "function_call", "name": "exec_command", "call_id": "call-1",
-            }},
-            {"timestamp": "2026-07-01T00:00:09.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100, "output_tokens": 100, "total_tokens": 200,
-                }},
-            }},
-            {"timestamp": "2026-07-01T00:00:10.000Z", "payload": {
-                "type": "task_complete", "duration_ms": 10000, "time_to_first_token_ms": 1000,
-            }},
-        ]
-        summary = meter.performance_summary(meter.codex_performance_samples(objs), 100)
-        self.assertEqual(summary["basis"], "end_to_end")
-        self.assertEqual(summary["tool_free_samples"], 0)
-        self.assertEqual(summary["output_tps"], 10)
-
-    def test_cross_log_model_aggregation_is_weighted_and_keeps_daily_io(self):
-        sessions = [{
-            "provider": "codex",
-            "model_stats": [{"model": "gpt-5.6", "cost": 1.0, "tokens": 330,
-                             "input_tokens": 300, "output_tokens": 30, "executions": 2}],
-            "_model_daily": [{"model": "gpt-5.6", "day": "2026-07-01", "cost": 1.0,
-                              "input_tokens": 300, "output_tokens": 30, "executions": 2}],
-            "_performance_samples": [
-                {"model": "gpt-5.6", "day": "2026-07-01", "ts": 10,
-                 "output_tokens": 10, "duration_s": 2, "generation_s": 1, "tool_calls": 0},
-                {"model": "gpt-5.6", "day": "2026-07-01", "ts": 20,
-                 "output_tokens": 20, "duration_s": 5, "generation_s": 3, "tool_calls": 0},
-            ],
-            "_wait_samples": [
-                {"model": "gpt-5.6", "day": "2026-07-01", "duration_s": 8},
-                {"model": "gpt-5.6", "day": "2026-07-01", "duration_s": 12},
-            ],
-        }]
-        result = meter.aggregate_model_stats(sessions)
-        row = result["models"][0]
-        self.assertEqual(row["output_tps"], 7.5)
-        self.assertEqual(row["timing_coverage"], 1)
-        self.assertEqual(row["daily"][0]["input_tokens"], 300)
-        self.assertEqual(row["daily"][0]["throughput_samples"], 2)
-        self.assertEqual(row["avg_wait_s"], 10)
-        self.assertEqual(row["median_wait_s"], 10)
-        self.assertEqual(row["p95_wait_s"], 12)
-        self.assertEqual(row["daily"][0]["wait_durations_s"], [8, 12])
-        self.assertEqual(row["daily"][0]["max_wait_s"], 12)
-
-    def test_model_efficiency_counters_preserve_reasoning_cache_and_missing_evidence(self):
-        stats = {}
-        meter.add_model_summary(stats, "gpt-5.6", {
-            "input_tokens": 100,
-            "cache_read_input_tokens": 60,
-            "cache_creation_input_tokens": 20,
-            "output_tokens": 40,
-            "reasoning_output_tokens": 12,
-            "reasoning_available": True,
-        }, 0.5)
-        meter.add_model_summary(stats, "gpt-5.6", {
-            "input_tokens": 50,
-            "output_tokens": 10,
-        }, 0.1)
-
-        self.assertEqual(stats["gpt-5.6"], {
-            "cost": 0.6,
-            "tokens": 280,
-            "input_tokens": 230,
-            "output_tokens": 50,
-            "cache_read_tokens": 60,
-            "cache_write_tokens": 20,
-            "reasoning_tokens": 12,
-            "reasoning_output_tokens": 40,
-            "reasoning_executions": 1,
-            "reasoning_unavailable_executions": 1,
-            "thinking_executions": 0,
-            "thinking_covered_executions": 0,
-            "token_covered_executions": 2,
-            "io_covered_executions": 2,
-            "io_covered_input_tokens": 230,
-            "io_covered_output_tokens": 50,
-            "executions": 2,
-            "input_evidence": True,
-            "output_evidence": True,
-        })
-
-    def test_reasoning_requires_numeric_evidence(self):
-        from token_meter.runtimes.codex import codex_usage as native_codex_usage
-
-        for value in (
-            None, False, True, "12", -1, 12.5, float("inf"), float("nan"),
-            10 ** 400,
-        ):
-            codex = native_codex_usage({
-                "output_tokens": 20, "reasoning_output_tokens": value,
-            })
-            opencode = meter._opencode_usage({
-                "tokens": {"output": 20, "reasoning": value},
-            })
-            self.assertFalse(codex["reasoning_available"])
-            self.assertEqual(codex["reasoning_output_tokens"], 0)
-            self.assertFalse(opencode["reasoning_available"])
-            self.assertEqual(opencode["reasoning_tokens"], 0)
-            self.assertEqual(meter._opencode_context_tokens(opencode), 20)
-        self.assertTrue(native_codex_usage({
-            "output_tokens": 20, "reasoning_output_tokens": 0,
-        })["reasoning_available"])
-        self.assertTrue(meter._opencode_usage({
-            "tokens": {"output": 20, "reasoning": 0},
-        })["reasoning_available"])
-        self.assertEqual(native_codex_usage({
-            "output_tokens": 20, "reasoning_output_tokens": 12.0,
-        })["reasoning_output_tokens"], 12)
-        for normalizer in (native_codex_usage, meter.codex_usage):
-            oversized = normalizer({
-                "input_tokens": 10,
-                "output_tokens": 20,
-                "reasoning_output_tokens": 21,
-            })
-            self.assertFalse(oversized["reasoning_available"])
-            self.assertEqual(oversized["reasoning_output_tokens"], 0)
-
-        stats = {}
-        meter.add_model_summary(stats, "gpt-5.6", {
-            "input_tokens": 10,
-            "output_tokens": 20,
-            "reasoning_output_tokens": 21,
-            "reasoning_available": True,
-        }, 0.1)
-        self.assertEqual(stats["gpt-5.6"]["reasoning_tokens"], 0)
-        self.assertEqual(stats["gpt-5.6"]["reasoning_executions"], 0)
-        self.assertEqual(stats["gpt-5.6"]["reasoning_unavailable_executions"], 1)
-
-    def test_model_aggregation_exposes_efficiency_counts_and_coverage(self):
-        sessions = [{
-            "id": "session-a", "provider": "codex", "runtime": "Codex",
-            "availability": meter.metric_availability("codex"),
-            "model_stats": [{
-                "model": "gpt-5.6", "cost": 2.0, "tokens": 360,
-                "input_tokens": 300, "output_tokens": 60, "executions": 3,
-                "cache_read_tokens": 120, "cache_write_tokens": 10,
-                "reasoning_tokens": 15, "reasoning_output_tokens": 50,
-                "reasoning_executions": 2,
-                "reasoning_unavailable_executions": 1,
-            }],
-            "_model_daily": [{
-                "model": "gpt-5.6", "day": "2026-08-27", "cost": 2.0,
-                "input_tokens": 300, "output_tokens": 60, "executions": 3,
-                "cache_read_tokens": 120, "cache_write_tokens": 10,
-                "reasoning_tokens": 15, "reasoning_output_tokens": 50,
-                "reasoning_executions": 2,
-                "reasoning_unavailable_executions": 1,
-            }],
-            "_performance_samples": [{
-                "model": "gpt-5.6", "day": "2026-08-27", "ts": 10,
-                "input_tokens": 300, "output_tokens": 60,
-                "duration_s": 3, "generation_s": 3,
-                "tool_calls": 2, "model_calls": 2,
-                "attempts": 3, "retries": 2, "failed_attempts": 1,
-            }],
-            "_wait_samples": [],
-        }]
-
-        row = meter.aggregate_model_stats(sessions)["models"][0]
-
-        self.assertEqual(row["cache_read_tokens"], 120)
-        self.assertEqual(row["cache_write_tokens"], 10)
-        self.assertEqual(row["cost_covered_output_tokens"], 60)
-        self.assertEqual(row["cost_covered_executions"], 3)
-        self.assertEqual(row["cache_covered_input_tokens"], 300)
-        self.assertEqual(row["token_covered_executions"], 3)
-        self.assertEqual(row["reasoning_tokens"], 15)
-        self.assertEqual(row["reasoning_output_tokens"], 50)
-        self.assertEqual(row["reasoning_executions"], 2)
-        self.assertEqual(row["reasoning_unavailable_executions"], 1)
-        self.assertEqual(row["attempts"], 3)
-        self.assertEqual(row["retries"], 2)
-        self.assertEqual(row["failed_attempts"], 1)
-        self.assertEqual(row["attempt_samples"], 1)
-        self.assertEqual(row["coverage"]["reasoning_tokens"], {
-            "covered_executions": 2,
-            "total_executions": 3,
-            "complete": False,
-        })
-        self.assertFalse(row["coverage"]["attempts"]["complete"])
-        self.assertEqual(row["daily"][0]["reasoning_tokens"], 15)
-        self.assertEqual(row["daily"][0]["attempts"], 3)
-
-    def test_efficiency_denominators_exclude_uncovered_cost_and_cache_rows(self):
-        covered = {
-            "id": "covered", "provider": "codex", "runtime": "Codex",
-            "availability": meter.metric_availability(
-                "codex", cost=True, tokens=True, cache=True,
-            ),
-            "model_stats": [{
-                "model": "gpt-5.6", "cost": 2.0, "tokens": 360,
-                "input_tokens": 300, "output_tokens": 60, "executions": 1,
-                "cache_read_tokens": 120,
-            }],
-            "_model_daily": [{
-                "model": "gpt-5.6", "day": "2026-08-27", "cost": 2.0,
-                "input_tokens": 300, "output_tokens": 60, "executions": 1,
-                "cache_read_tokens": 120,
-            }],
-        }
-        uncovered = {
-            "id": "uncovered", "provider": "codex", "runtime": "Codex",
-            "availability": meter.metric_availability(
-                "codex", cost=False, tokens=True, cache=False,
-            ),
-            "model_stats": [{
-                "model": "gpt-5.6", "cost": 0.0, "tokens": 1100,
-                "input_tokens": 1000, "output_tokens": 100,
-                "executions": 1,
-            }],
-            "_model_daily": [{
-                "model": "gpt-5.6", "day": "2026-08-27", "cost": 0.0,
-                "input_tokens": 1000, "output_tokens": 100,
-                "executions": 1,
-            }],
-        }
-
-        row = meter.aggregate_model_stats([covered, uncovered])["models"][0]
-
-        self.assertEqual(row["output_tokens"], 160)
-        self.assertEqual(row["cost_covered_output_tokens"], 60)
-        self.assertEqual(row["cache_covered_input_tokens"], 300)
-        self.assertFalse(row["coverage"]["cost"]["complete"])
-        self.assertFalse(row["coverage"]["cache"]["complete"])
-
-    def test_input_only_model_evidence_keeps_output_unavailable(self):
-        availability = meter.metric_availability(
-            "opencode", cost=True, tokens=True, input_tokens=True,
-            output_tokens=False, cache=True,
-        )
-        stats = {
-            "model": "model-a", "cost": 1.0, "input_tokens": 10,
-            "output_tokens": 0, "executions": 1,
-            "token_covered_executions": 0, "cost_covered_executions": 0,
-            "cost_covered_output_tokens": 0,
-            "cache_covered_input_tokens": 10,
-            "availability": availability,
-        }
-        row = meter.aggregate_model_stats([{
-            "id": "input-only", "provider": "opencode", "runtime": "OpenCode",
-            "availability": meter.metric_availability(
-                "opencode", cost=True, tokens=True, input_tokens=True,
-                output_tokens=True, cache=True,
-            ),
-            "model_stats": [stats],
-            "_model_daily": [{**stats, "day": "2026-08-27"}],
-            "_wait_samples": [{
-                "model": "model-a", "day": "2026-08-27",
-                "duration_s": 1, "output_tokens": 0,
-            }],
-        }])["models"][0]
-
-        self.assertTrue(row["availability"]["tokens"])
-        self.assertTrue(row["availability"]["input_tokens"])
-        self.assertFalse(row["availability"]["output_tokens"])
-        self.assertFalse(row["daily"][0]["availability"]["output_tokens"])
-
-    def test_mixed_speed_coverage_counts_all_completed_output(self):
-        summary = meter.performance_summary([
-            {"output_tokens": 10, "duration_s": 2, "generation_s": 1, "tool_calls": 0, "ts": 1},
-            {"output_tokens": 90, "duration_s": 9, "generation_s": 8, "tool_calls": 1, "ts": 2},
-        ], 100)
-        self.assertEqual(summary["basis"], "end_to_end")
-        self.assertAlmostEqual(summary["output_tps"], 100 / 11)
-        self.assertEqual(summary["sample_count"], 2)
-        self.assertEqual(summary["timing_coverage"], 1)
-
-    def test_model_aggregation_omits_rows_without_io(self):
-        availability = meter.metric_availability(
-            "claude", cost=False, tokens=True, input_tokens=True,
-            output_tokens=True, cache=False,
-        )
-        result = meter.aggregate_model_stats([{
-            "provider": "claude", "availability": availability,
-            "model_stats": [{"model": "<synthetic>", "input_tokens": 0,
-                             "output_tokens": 0, "executions": 2, "cost": 0,
-                             "token_covered_executions": 2,
-                             "availability": availability}],
-        }])
-        self.assertEqual(result["models"], [])
-        self.assertEqual(result["total_models"], 0)
-
-    def test_model_aggregation_keeps_explicitly_covered_zero_io(self):
-        availability = meter.metric_availability(
-            "opencode", cost=True, tokens=True, input_tokens=True,
-            output_tokens=True, cache=True,
-        )
-        stats = {
-            "model": "model-a", "cost": 1.0,
-            "input_tokens": 0, "output_tokens": 0, "executions": 1,
-            "token_covered_executions": 1, "cost_covered_executions": 1,
-            "cost_covered_output_tokens": 0,
-            "cache_covered_input_tokens": 0,
-            "availability": availability,
-        }
-
-        result = meter.aggregate_model_stats([{
-            "id": "covered-zero", "provider": "opencode", "runtime": "OpenCode",
-            "availability": availability, "model_stats": [stats],
-            "_model_daily": [{**stats, "day": "2026-08-27"}],
-        }])
-
-        self.assertEqual(result["total_models"], 1)
-        row = result["models"][0]
-        self.assertEqual(row["input_tokens"], 0)
-        self.assertEqual(row["output_tokens"], 0)
-        self.assertEqual(row["cost_covered_output_tokens"], 0)
-        self.assertTrue(row["availability"]["input_tokens"])
-        self.assertTrue(row["availability"]["output_tokens"])
-        self.assertTrue(row["daily"][0]["availability"]["output_tokens"])
-
-    def test_model_aggregation_splits_same_model_by_runtime(self):
-        def session(runtime, output):
-            return {
-                "provider": "claude", "runtime": runtime,
-                "model_stats": [{"model": "claude-opus", "cost": 1, "tokens": 100,
-                                 "input_tokens": 90, "output_tokens": output, "executions": 1}],
-                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
-            }
-        result = meter.aggregate_model_stats([
-            session("Claude Code", 10), session("Claude-3P", 20),
-        ])
-        self.assertEqual(len(result["models"]), 2)
-        self.assertEqual(
-            {(row["model"], row["runtime"], row["id"]) for row in result["models"]},
-            {
-                ("claude-opus", "Claude Code", "claude-opus::Claude Code::unavailable"),
-                ("claude-opus", "Claude-3P", "claude-opus::Claude-3P::unavailable"),
-            },
-        )
-
-    def test_model_aggregation_gives_unreported_effort_an_explicit_identity(self):
-        result = meter.aggregate_model_stats([{
-            "provider": "codex", "runtime": "Codex",
-            "model_stats": [{
-                "model": "gpt-5.6", "cost": 1, "tokens": 100,
-                "input_tokens": 80, "output_tokens": 20, "executions": 1,
-            }],
-            "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
-        }])
-        self.assertEqual(result["models"][0]["id"], "gpt-5.6::Codex::unavailable")
-
-    def test_model_aggregation_keeps_trace_reported_session_effort_per_runtime(self):
-        def session(effort):
-            return {
-                "provider": "codex", "runtime": "Codex",
-                "reasoning_effort": effort,
-                "model_stats": [{
-                    "model": "gpt-5.6", "cost": 1, "tokens": 100,
-                    "input_tokens": 80, "output_tokens": 20, "executions": 1,
-                }],
-                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
-            }
-
-        rows = meter.aggregate_model_stats([
-            session("high"), session("xhigh"), session("private client note 42"),
-            session(""),
-        ])["models"]
-
-        self.assertEqual(
-            {(row.get("reasoning_effort"), tuple(row.get("reasoning_efforts") or ()))
-             for row in rows},
-            {("high", ("high",)), ("xhigh", ("xhigh",)), (None, ())},
-        )
-
-    def test_model_aggregation_scopes_effort_to_single_model_sessions_and_days(self):
-        def stats(model):
-            return {
-                "model": model, "cost": 1, "tokens": 100,
-                "input_tokens": 80, "output_tokens": 20, "executions": 1,
-            }
-
-        result = meter.aggregate_model_stats([
-            {
-                "provider": "codex", "runtime": "Codex", "reasoning_effort": "high",
-                "model_stats": [stats("gpt-5.6")],
-                "_model_daily": [{**stats("gpt-5.6"), "day": "2026-08-30"}],
-            },
-            {
-                "provider": "codex", "runtime": "Codex", "reasoning_effort": "xhigh",
-                "model_stats": [stats("gpt-5.6")],
-                "_model_daily": [{**stats("gpt-5.6"), "day": "2026-08-31"}],
-            },
-            {
-                "provider": "codex", "runtime": "Codex", "reasoning_effort": "ultra",
-                "primary_model": "gpt-a",
-                "model_stats": [stats("gpt-a"), stats("gpt-b")],
-                "_model_daily": [
-                    {**stats("gpt-a"), "day": "2026-08-31"},
-                    {**stats("gpt-b"), "day": "2026-08-31"},
-                ],
-            },
-        ])
-        by_model_effort = {
-            (row["model"], row.get("reasoning_effort")): row
-            for row in result["models"]
-        }
-
-        self.assertEqual(
-            by_model_effort[("gpt-5.6", "high")]["daily"][0]["reasoning_efforts"],
-            ["high"],
-        )
-        self.assertEqual(
-            by_model_effort[("gpt-5.6", "xhigh")]["daily"][0]["reasoning_efforts"],
-            ["xhigh"],
-        )
-        self.assertEqual(by_model_effort[("gpt-a", "ultra")]["reasoning_efforts"], ["ultra"])
-        self.assertEqual(by_model_effort[("gpt-b", None)]["reasoning_efforts"], [])
-
-    def test_project_model_stats_scopes_exactly_and_omits_session_identity(self):
-        def session(session_id, project, output):
-            return {
-                "id": session_id, "path": f"/private/logs/{session_id}.jsonl",
-                "title": f"Private title {session_id}",
-                "provider": "codex", "runtime": "Codex", "project": project,
-                "availability": meter.metric_availability("codex"),
-                "model_stats": [{
-                    "model": "gpt-5.6", "cost": 1, "tokens": 100 + output,
-                    "input_tokens": 100, "output_tokens": output, "executions": 1,
-                }],
-                "_model_daily": [{
-                    "model": "gpt-5.6", "day": "2026-07-30", "cost": 1,
-                    "input_tokens": 100, "output_tokens": output, "executions": 1,
-                }],
-                "_performance_samples": [], "_wait_samples": [],
-            }
-
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["internal_rows"] = (
-                session("secret-a", "/repo/a", 10),
-                session("secret-b", "/repo/b", 40),
-            )
-            meter._xsess["project_model_stats"] = {}
-            with mock.patch.object(meter, "cross_session",
-                                   return_value={"generated_at": 123}):
-                payload, status = meter.project_model_stats("/repo/a")
-                missing, missing_status = meter.project_model_stats("")
-                unknown, unknown_status = meter.project_model_stats("/repo/unknown")
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(status, 200)
-        self.assertTrue(payload["ok"])
-        self.assertEqual(payload["generated_at"], 123)
-        self.assertEqual(payload["model_stats"]["models"][0]["output_tokens"], 10)
-        self.assertNotIn("projects", payload["model_stats"])
-        encoded = json.dumps(payload)
-        self.assertNotIn("/repo/a", encoded)
-        self.assertNotIn("/private/logs", encoded)
-        self.assertNotIn("secret-a", encoded)
-        self.assertNotIn("Private title", encoded)
-        self.assertEqual(missing_status, 400)
-        self.assertFalse(missing["ok"])
-        self.assertEqual(unknown_status, 404)
-        self.assertFalse(unknown["ok"])
-        self.assertIn(
-            'elif req_path == "/model-stats":',
-            Path(meter.IMPLEMENTATION_FILE).read_text(),
-        )
-
-    def test_project_model_stats_groups_non_folder_labels_as_other_local_sessions(self):
-        def session(session_id, project):
-            return {
-                "id": session_id, "project": project, "provider": "codex",
-                "runtime": "Codex", "model_stats": [{
-                    "model": "gpt-5.6", "cost": 1, "tokens": 100,
-                    "input_tokens": 80, "output_tokens": 20, "executions": 1,
-                }],
-                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
-            }
-
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess.update({
-                "internal_rows": (session("cli", "CLI"), session("none", "No project")),
-                "project_model_stats": {},
-            })
-            with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}):
-                payload, status = meter.project_model_stats("__other_local_sessions__")
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(status, 200)
-        self.assertEqual(payload["model_stats"]["total_models"], 1)
-
-    def test_model_project_options_are_sorted_and_bounded(self):
-        sessions = [
-            {"project": f"/repo/{index:04d}", "provider": "codex",
-             "model_stats": [], "_model_daily": [], "_performance_samples": [],
-             "_wait_samples": []}
-            for index in range(meter.MODEL_PROJECT_OPTION_LIMIT + 1)
-        ]
-        result = meter.aggregate_model_stats(reversed(sessions))
-        self.assertEqual(len(result["projects"]), meter.MODEL_PROJECT_OPTION_LIMIT)
-        self.assertEqual(result["projects"][0], "/repo/0000")
-        self.assertTrue(result["projects_truncated"])
-
-    def test_cursor_samples_are_excluded_from_matched_pace(self):
-        samples = [{
-            "model": "gpt-5.6", "day": "2026-07-20", "ts": index + 1,
-            "input_tokens": 100, "peak_input_tokens": 100, "output_tokens": 20,
-            "duration_s": 2, "generation_s": 2, "tool_calls": 0, "model_calls": 1,
-        } for index in range(25)]
-        cursor = {
-            "id": "cursor", "provider": "cursor", "runtime": "Cursor",
-            "token_estimate": True,
-            "availability": meter.metric_availability(
-                "cursor", cost=True, tokens=True, input_tokens=True,
-                output_tokens=True, throughput=True, timing=True,
-            ),
-            "model_stats": [{"model": "gpt-5.6", "cost": 1, "tokens": 120,
-                              "input_tokens": 100, "output_tokens": 20, "executions": 1}],
-            "_model_daily": [], "_performance_samples": samples, "_wait_samples": [],
-        }
-        codex = {
-            **cursor, "id": "codex", "provider": "codex", "runtime": "Codex",
-            "token_estimate": False, "availability": meter.metric_availability("codex"),
-        }
-        result = meter.aggregate_model_stats([cursor, codex])
-        self.assertEqual({row["id"] for row in result["models"]},
-                         {"gpt-5.6::Cursor::unavailable", "gpt-5.6::Codex::unavailable"})
-        self.assertFalse(any(
-            any("::Cursor" in value for value in (pair["a_id"], pair["b_id"]))
-            for pairs in result["matched_pace"]["windows"].values() for pair in pairs
-        ))
-
-    def test_runtime_label_distinguishes_claude_desktop_roots(self):
-        standard = {
-            "provider": "claude", "client": "claude_desktop",
-            "metadata_path": str(Path(meter.CLAUDE_DESKTOP_DATA_ROOTS[0]) / "sessions" / "one.json"),
-        }
-        third_party = {
-            "provider": "claude", "client": "claude_desktop",
-            "metadata_path": str(Path(meter.CLAUDE_DESKTOP_DATA_ROOTS[1]) / "sessions" / "two.json"),
-        }
-        self.assertEqual(meter.source_runtime_label(standard), "Claude Desktop")
-        self.assertEqual(meter.source_runtime_label(third_party), "Claude-3P")
-        self.assertEqual(meter.source_runtime_label({"provider": "claude", "client": "claude_code"}),
-                         "Claude Code")
-        self.assertEqual(meter.source_runtime_label({"provider": "codex"}), "Codex")
-        self.assertEqual(meter.source_runtime_label({"provider": "cursor"}), "Cursor")
-
-    def test_matched_pace_has_exact_today_and_yesterday_windows(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(day, start):
-            return [{
-                "duration_s": 10, "ts": start + index, "day": day,
-                "input_tokens": 10000, "peak_input_tokens": 10000,
-                "cache_read_tokens": 0, "output_tokens": 1000,
-                "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        groups = {
-            runtime: (
-                samples("2026-08-11", offset)
-                + samples("2026-08-10", offset + 100)
-                + samples("2026-07-01", offset + 200)
-            )
-            for runtime, offset in (("alpha", 0), ("beta", 1000))
-        }
-
-        windows = meter.matched_pace_windows(groups, now_ts=now)["windows"]
-
-        self.assertEqual(
-            list(windows),
-            ["today", "yesterday", "7", "30", "90", "month", "last_month", "all"],
-        )
-        self.assertEqual(windows["month"][0]["a_samples"], 40)
-        for name in ("today", "yesterday"):
-            self.assertEqual(len(windows[name]), 1)
-            self.assertEqual(windows[name][0]["a_samples"], 20)
-            self.assertEqual(windows[name][0]["b_samples"], 20)
-        self.assertEqual(windows["7"][0]["a_samples"], 40)
-        self.assertEqual(windows["7"][0]["b_samples"], 40)
-        self.assertEqual(windows["all"][0]["a_samples"], 60)
-        self.assertEqual(windows["all"][0]["b_samples"], 60)
-        self.assertEqual(windows["last_month"][0]["a_samples"], 20)
-        self.assertEqual(windows["last_month"][0]["b_samples"], 20)
-        self.assertEqual(windows["month"][0]["a_samples"], 40)
-        self.assertEqual(windows["month"][0]["b_samples"], 40)
-
-    def test_matched_pace_reuses_unchanged_inputs_and_invalidates_changed_samples(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(duration, offset):
-            return [{
-                "duration_s": duration, "ts": now + offset + index,
-                "day": "2026-08-11", "input_tokens": 10000,
-                "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        groups = {"alpha": samples(10, 0), "beta": samples(20, 100)}
-        original = meter.matched_pace_comparison
-        with mock.patch.object(
-            meter, "matched_pace_comparison", wraps=original,
-        ) as comparison:
-            first = meter.matched_pace_windows(groups, now_ts=now)
-            first_call_count = comparison.call_count
-            second = meter.matched_pace_windows(groups, now_ts=now)
-            unchanged_call_count = comparison.call_count
-            changed_groups = {**groups, "beta": samples(30, 100)}
-            changed = meter.matched_pace_windows(changed_groups, now_ts=now)
-
-        self.assertGreater(first_call_count, 0)
-        self.assertEqual(unchanged_call_count, first_call_count)
-        self.assertEqual(second, first)
-        # Published snapshots are never mutated, so the cached windows are shared.
-        self.assertIs(second, first)
-        self.assertGreater(comparison.call_count, unchanged_call_count)
-        self.assertEqual(first["windows"]["today"][0]["pace_ratio"], 2)
-        self.assertEqual(changed["windows"]["today"][0]["pace_ratio"], 3)
-
-    def test_matched_pace_rebuilds_only_pairs_touching_a_changed_model(self):
-        """A new turn for one model must not recompute every model pair."""
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(duration, offset):
-            return [{
-                "duration_s": duration, "ts": now + offset + index,
-                "day": "2026-08-11", "input_tokens": 10000,
-                "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        names = ("alpha", "beta", "gamma", "delta")
-        groups = {name: samples(10 + index, index * 100)
-                  for index, name in enumerate(names)}
-        original = meter.matched_pace_comparison
-        with mock.patch.object(
-            meter, "matched_pace_comparison", wraps=original,
-        ) as comparison:
-            meter.matched_pace_windows(groups, now_ts=now)
-            first_call_count = comparison.call_count
-            changed_groups = {**groups, "gamma": samples(99, 500)}
-            meter.matched_pace_windows(changed_groups, now_ts=now)
-            after_change = comparison.call_count
-
-        # Four models form six pairs across every window. Only the three pairs
-        # that include the changed model may be recomputed.
-        windows = len(meter.MATCHED_PACE_WINDOW_KEYS)
-        self.assertEqual(first_call_count, 6 * windows)
-        self.assertEqual(after_change - first_call_count, 3 * windows)
-
-    def test_matched_pace_cached_pairs_match_a_cold_computation(self):
-        """Per-pair caching must not change any reported comparison."""
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(duration, offset):
-            return [{
-                "duration_s": duration, "ts": now + offset + index,
-                "day": "2026-08-11", "input_tokens": 10000,
-                "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        groups = {name: samples(10 + index, index * 100)
-                  for index, name in enumerate(("alpha", "beta", "gamma"))}
-        with_cached_pairs = meter.matched_pace_windows(groups, now_ts=now)
-        meter._matched_pace_pair_cache.clear()
-        meter._matched_pace_cache["signature"] = None
-        meter._matched_pace_cache["data"] = None
-        cold = meter.matched_pace_windows(groups, now_ts=now)
-
-        self.assertEqual(cold, with_cached_pairs)
-
-    def test_matched_pace_reuses_a_persisted_pair_cache_after_restart(self):
-        """A restart must reuse stored pairs instead of rebuilding every pair."""
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(duration, offset):
-            return [{
-                "duration_s": duration, "ts": now + offset + index,
-                "day": "2026-08-11", "input_tokens": 10000,
-                "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        groups = {name: samples(10 + index, index * 100)
-                  for index, name in enumerate(("alpha", "beta", "gamma"))}
-        original = meter.matched_pace_comparison
-        with mock.patch.object(
-            meter, "matched_pace_comparison", wraps=original,
-        ) as comparison:
-            first = meter.matched_pace_windows(groups, now_ts=now)
-            first_calls = comparison.call_count
-            # Simulate a process restart: drop in-memory state, keep the file.
-            meter._matched_pace_pair_cache.clear()
-            meter._matched_pace_pair_cache_loaded = False
-            meter._matched_pace_cache["signature"] = None
-            meter._matched_pace_cache["data"] = None
-            restarted = meter.matched_pace_windows(groups, now_ts=now)
-            restarted_calls = comparison.call_count - first_calls
-
-        self.assertGreater(first_calls, 0)
-        self.assertTrue(self._pace_cache_path.exists())
-        self.assertEqual(
-            restarted_calls, 0,
-            "a persisted pair cache must avoid recomputing unchanged pairs",
-        )
-        self.assertEqual(restarted, first)
-
-    def test_matched_pace_recovers_from_an_unusable_cache_file(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(duration, offset):
-            return [{
-                "duration_s": duration, "ts": now + offset + index,
-                "day": "2026-08-11", "input_tokens": 10000,
-                "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        groups = {"alpha": samples(10, 0), "beta": samples(20, 100)}
-        for payload in (
-            "{ not json",
-            json.dumps({"schema": 999, "pairs": "unexpected"}),
-            json.dumps({
-                "schema": meter.MATCHED_PACE_CACHE_SCHEMA,
-                "pairs": [{"a_id": 5}, "junk"],
-            }),
-        ):
-            with self.subTest(payload=payload[:24]):
-                self._pace_cache_path.write_text(payload)
-                meter._matched_pace_pair_cache.clear()
-                meter._matched_pace_pair_cache_loaded = False
-                meter._matched_pace_cache["signature"] = None
-                meter._matched_pace_cache["data"] = None
-                result = meter.matched_pace_windows(groups, now_ts=now)
-                self.assertEqual(len(result["windows"]["today"]), 1)
-
-    def test_matched_pace_rebuild_releases_the_cache_lock(self):
-        """A slow rebuild must not block unrelated cross-session requests."""
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-
-        def samples(duration, offset):
-            return [{
-                "duration_s": duration, "ts": now + offset + index,
-                "day": "2026-08-11", "input_tokens": 10000,
-                "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-            } for index in range(20)]
-
-        groups = {"alpha": samples(10, 0), "beta": samples(20, 100)}
-        entered = threading.Event()
-        release = threading.Event()
-        real_build = meter._build_matched_pace_windows
-        acquired = False
-
-        def blocking_build(*args, **kwargs):
-            entered.set()
-            release.wait(timeout=10)
-            return real_build(*args, **kwargs)
-
-        with mock.patch.object(
-            meter, "_build_matched_pace_windows", side_effect=blocking_build,
-        ):
-            worker = threading.Thread(
-                target=meter.matched_pace_windows,
-                args=(groups,), kwargs={"now_ts": now}, daemon=True,
-            )
-            worker.start()
-            try:
-                self.assertTrue(entered.wait(timeout=5))
-                acquired = meter._matched_pace_cache_lock.acquire(timeout=5)
-                if acquired:
-                    meter._matched_pace_cache_lock.release()
-            finally:
-                release.set()
-                worker.join(timeout=10)
-
-        self.assertTrue(
-            acquired,
-            "matched_pace_windows must not hold the cache lock while rebuilding",
-        )
-
-    @staticmethod
-    def _pace_groups(now, names=("alpha", "beta", "gamma"), day_offsets=(0,)):
-        """Build 20 timed turns per model on each day offset from ``now``."""
-        def samples(duration, offset):
-            rows = []
-            for day_offset in day_offsets:
-                ts = now - day_offset * 86400
-                day = datetime.date.fromtimestamp(ts).isoformat()
-                rows.extend({
-                    "duration_s": duration + day_offset, "ts": ts + offset + index,
-                    "day": day, "input_tokens": 10000,
-                    "peak_input_tokens": 10000, "cache_read_tokens": 0,
-                    "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
-                } for index in range(20))
-            return rows
-
-        return {name: samples(10 + index, index * 100)
-                for index, name in enumerate(names)}
-
-    @staticmethod
-    def _drop_pace_memory(loaded=False):
-        """Drop in-memory matched-pace state; ``loaded=False`` simulates restart."""
-        meter._matched_pace_pair_cache.clear()
-        meter._matched_pace_pair_cache_loaded = loaded
-        meter._matched_pace_cache["signature"] = None
-        meter._matched_pace_cache["data"] = None
-
-    def _cold_pace(self, groups, now):
-        self._drop_pace_memory(loaded=True)
-        return meter.matched_pace_windows(groups, now_ts=now)
-
-    def test_matched_pace_pair_cache_does_not_reuse_previous_day_windows(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        tomorrow = now + 86400
-        groups = self._pace_groups(now, day_offsets=(0, 1))
-        meter.matched_pace_windows(groups, now_ts=now)
-        rolled = meter.matched_pace_windows(groups, now_ts=tomorrow)
-        cold = self._cold_pace(groups, tomorrow)
-
-        self.assertEqual(rolled, cold)
-        # The previous "today" samples are now "yesterday"; nothing is today.
-        self.assertFalse(any(row["available"] for row in rolled["windows"]["today"]))
-        self.assertTrue(all(row["available"] for row in rolled["windows"]["yesterday"]))
-
-    def test_matched_pace_persisted_pairs_do_not_survive_a_day_rollover(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        tomorrow = now + 86400
-        groups = self._pace_groups(now, day_offsets=(0, 1))
-        meter.matched_pace_windows(groups, now_ts=now)
-        self.assertTrue(self._pace_cache_path.exists())
-        self._drop_pace_memory()
-        reloaded = meter.matched_pace_windows(groups, now_ts=tomorrow)
-        cold = self._cold_pace(groups, tomorrow)
-
-        self.assertEqual(reloaded, cold)
-
-    def test_matched_pace_rejects_incomplete_or_non_finite_persisted_entries(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now)
-        expected = meter.matched_pace_windows(groups, now_ts=now)
-        stored = json.loads(self._pace_cache_path.read_text())
-
-        def corrupt_missing(entry):
-            entry["windows"].pop("today")
-            entry["windows"].pop("yesterday")
-
-        def corrupt_nan(entry):
-            entry["windows"]["today"]["coverage"] = float("nan")
-
-        def corrupt_infinite(entry):
-            entry["windows"]["all"]["pace_ratio"] = float("inf")
-
-        def corrupt_type(entry):
-            entry["windows"]["7"]["matched_pairs"] = "12"
-
-        for corrupt in (corrupt_missing, corrupt_nan, corrupt_infinite, corrupt_type):
-            with self.subTest(corruption=corrupt.__name__):
-                payload = json.loads(json.dumps(stored))
-                for entry in payload["pairs"]:
-                    corrupt(entry)
-                self._pace_cache_path.write_text(json.dumps(payload))
-                self._drop_pace_memory()
-                result = meter.matched_pace_windows(groups, now_ts=now)
-                self.assertEqual(result, expected)
-                self.assertEqual(meter._matched_pace_pair_cache_loaded, True)
-                self.assertEqual(len(meter._matched_pace_pair_cache), 3)
-
-    def test_matched_pace_ignores_an_undecodable_cache_file(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now)
-        expected = self._cold_pace(groups, now)
-        self._pace_cache_path.write_bytes(b'{"schema": \xff\xfe\x80 }')
-        self._drop_pace_memory()
-
-        self.assertEqual(meter.matched_pace_windows(groups, now_ts=now), expected)
-
-    def test_project_scoped_matched_pace_leaves_the_global_pair_cache_intact(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        global_groups = self._pace_groups(now, names=("alpha", "beta", "gamma", "delta"))
-        project_groups = {
-            name: rows[:15] for name, rows in global_groups.items()
-            if name in ("alpha", "beta")
-        }
-        first = meter.matched_pace_windows(global_groups, now_ts=now)
-        persisted = self._pace_cache_path.read_bytes()
-        project = meter.matched_pace_windows(
-            project_groups, now_ts=now, persistent=False,
-        )
-        self.assertEqual(self._pace_cache_path.read_bytes(), persisted)
-        self.assertEqual(project, self._cold_pace(project_groups, now))
-        # Restore the global in-memory state the cold check discarded.
-        self._drop_pace_memory()
-        meter.matched_pace_windows(global_groups, now_ts=now)
-        meter.matched_pace_windows(project_groups, now_ts=now, persistent=False)
-        meter._matched_pace_cache["signature"] = None
-
-        original = meter.matched_pace_comparison
-        with mock.patch.object(
-            meter, "matched_pace_comparison", wraps=original,
-        ) as comparison:
-            again = meter.matched_pace_windows(global_groups, now_ts=now)
-        self.assertEqual(comparison.call_count, 0)
-        self.assertEqual(again, first)
-        self.assertEqual(self._pace_cache_path.read_bytes(), persisted)
-
-    def test_project_model_stats_uses_the_non_persistent_pace_scope(self):
-        row = {
-            "id": "s", "project": "/repo/a", "provider": "codex",
-            "runtime": "Codex", "model_stats": [{
-                "model": "gpt-5.6", "cost": 1, "tokens": 100,
-                "input_tokens": 80, "output_tokens": 20, "executions": 1,
-            }],
-            "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
-        }
-        saved_cache = dict(meter._xsess)
-        original = meter.matched_pace_windows
-        try:
-            meter._xsess.update({"internal_rows": (row,), "project_model_stats": {}})
-            with mock.patch.object(meter, "cross_session",
-                                   return_value={"generated_at": 1}), \
-                    mock.patch.object(meter, "matched_pace_windows",
-                                      wraps=original) as pace:
-                _, status = meter.project_model_stats("/repo/a")
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(status, 200)
-        self.assertEqual(pace.call_count, 1)
-        self.assertIs(pace.call_args.kwargs.get("persistent"), False)
-
-    def test_matched_pace_skips_the_write_when_no_pair_changed(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now)
-        meter.matched_pace_windows(groups, now_ts=now)
-        self.assertTrue(self._pace_cache_path.exists())
-        # Force a rebuild that finds every pair already cached: a restart that
-        # reloads the file, then a changed whole-result signature.
-        self._drop_pace_memory()
-        with mock.patch.object(meter, "atomic_write_text") as write:
-            meter.matched_pace_windows(groups, now_ts=now)
-            meter._matched_pace_cache["signature"] = None
-            meter.matched_pace_windows(groups, now_ts=now)
-        write.assert_not_called()
-
-        changed = {**groups, "gamma": groups["gamma"][:-1]}
-        with mock.patch.object(meter, "atomic_write_text") as write:
-            meter.matched_pace_windows(changed, now_ts=now)
-        self.assertEqual(write.call_count, 1)
-
-    def test_matched_pace_pair_cache_is_bounded_on_load_and_in_memory(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now, names=("alpha", "beta", "gamma", "delta"))
-        with mock.patch.object(meter, "MATCHED_PACE_CACHE_MAX_PAIRS", 2):
-            first = meter.matched_pace_windows(groups, now_ts=now)
-            self.assertEqual(len(meter._matched_pace_pair_cache), 2)
-            self.assertEqual(len(json.loads(
-                self._pace_cache_path.read_text())["pairs"]), 2)
-            self.assertEqual(first, self._cold_pace(groups, now))
-        meter._matched_pace_cache["signature"] = None
-        meter.matched_pace_windows(groups, now_ts=now)
-        stored = json.loads(self._pace_cache_path.read_text())
-        self.assertEqual(len(stored["pairs"]), 6)
-        with mock.patch.object(meter, "MATCHED_PACE_CACHE_MAX_PAIRS", 3):
-            self._drop_pace_memory()
-            with mock.patch.object(meter, "_build_matched_pace_windows",
-                                   return_value=({}, False)):
-                meter.matched_pace_windows(groups, now_ts=now)
-            self.assertEqual(len(meter._matched_pace_pair_cache), 3)
-
-    def test_matched_pace_skips_entries_with_huge_integers_without_raising(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now)
-        expected = meter.matched_pace_windows(groups, now_ts=now)
-        stored = json.loads(self._pace_cache_path.read_text())
-        huge = "9" * 400
-        # json.loads decodes a bare 400-digit literal as a Python int, for
-        # which math.isfinite raises OverflowError.
-        for field in ("pace_ratio", "matched_pairs"):
-            with self.subTest(field=field):
-                payload = json.loads(json.dumps(stored))
-                payload["pairs"][0]["windows"]["all"][field] = "HUGE"
-                text = json.dumps(payload).replace('"HUGE"', huge)
-                self._pace_cache_path.write_text(text)
-                self._drop_pace_memory()
-                original = meter.matched_pace_comparison
-                with mock.patch.object(
-                    meter, "matched_pace_comparison", wraps=original,
-                ) as comparison:
-                    result = meter.matched_pace_windows(groups, now_ts=now)
-                self.assertEqual(result, expected)
-                self.assertEqual(result, self._cold_pace(groups, now))
-                # Only the corrupted pair is recomputed; the others are kept.
-                self.assertEqual(
-                    comparison.call_count, len(meter.MATCHED_PACE_WINDOW_KEYS),
-                )
-
-    def test_matched_pace_persisted_entries_cannot_inject_output_fields(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now)
-        expected = meter.matched_pace_windows(groups, now_ts=now)
-        stored = json.loads(self._pace_cache_path.read_text())
-
-        def inject_key(window):
-            window["note"] = "/Users/x/secret"
-
-        def inject_reason(window):
-            window["reason"] = "/Users/x/secret"
-
-        def long_reason(window):
-            window["reason"] = "only 1 comparable turns; needs 20" + "x" * 300
-
-        def negative_ratio(window):
-            window["pace_ratio"] = -1.5
-
-        def negative_count(window):
-            window["a_samples"] = -3
-
-        def absurd_ratio(window):
-            window["ci_high"] = 1e300
-
-        def missing_key(window):
-            window.pop("reason")
-
-        for corrupt in (inject_key, inject_reason, long_reason, negative_ratio,
-                        negative_count, absurd_ratio, missing_key):
-            with self.subTest(corruption=corrupt.__name__):
-                payload = json.loads(json.dumps(stored))
-                for entry in payload["pairs"]:
-                    corrupt(entry["windows"]["7"])
-                self._pace_cache_path.write_text(json.dumps(payload))
-                self._drop_pace_memory()
-                result = meter.matched_pace_windows(groups, now_ts=now)
-                self.assertEqual(result, expected)
-                self.assertNotIn("/Users/x/secret", json.dumps(result))
-                self.assertNotIn("note", json.dumps(result))
-
-    def test_matched_pace_over_cap_rebuilds_do_not_rewrite_the_cache(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now, names=("alpha", "beta", "gamma", "delta"))
-        with mock.patch.object(meter, "MATCHED_PACE_CACHE_MAX_PAIRS", 2):
-            first = meter.matched_pace_windows(groups, now_ts=now)
-            kept = set(meter._matched_pace_pair_cache)
-            with mock.patch.object(meter, "atomic_write_text") as write:
-                for _ in range(3):
-                    meter._matched_pace_cache["signature"] = None
-                    again = meter.matched_pace_windows(groups, now_ts=now)
-                    self.assertEqual(again, first)
-            write.assert_not_called()
-            self.assertEqual(set(meter._matched_pace_pair_cache), kept)
-            self.assertEqual(first, self._cold_pace(groups, now))
-
-    def test_matched_pace_concurrent_callers_trigger_one_build(self):
-        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
-        groups = self._pace_groups(now)
-        callers = 4
-        waiting = set()
-        waiting_lock = threading.Lock()
-        all_waiting = threading.Event()
-
-        class CountingCondition(type(meter._matched_pace_build_condition)):
-            def wait(self, timeout=None):
-                with waiting_lock:
-                    waiting.add(threading.get_ident())
-                    if len(waiting) >= callers - 1:
-                        all_waiting.set()
-                return super().wait(timeout)
-
-        real_build = meter._build_matched_pace_windows
-        builds = []
-
-        def gated_build(*args, **kwargs):
-            builds.append(threading.get_ident())
-            all_waiting.wait(timeout=10)
-            return real_build(*args, **kwargs)
-
-        results = [None] * callers
-
-        def call(index):
-            results[index] = meter.matched_pace_windows(groups, now_ts=now)
-
-        with mock.patch.object(meter, "_matched_pace_build_condition",
-                               CountingCondition(threading.Lock())), \
-                mock.patch.object(meter, "_build_matched_pace_windows",
-                                  side_effect=gated_build):
-            threads = [threading.Thread(target=call, args=(index,), daemon=True)
-                       for index in range(callers)]
-            for thread in threads:
-                thread.start()
-            for thread in threads:
-                thread.join(timeout=15)
-
-        self.assertTrue(all_waiting.is_set())
-        self.assertEqual(len(builds), 1)
-        self.assertTrue(all(result is not None for result in results))
-        self.assertTrue(all(result == results[0] for result in results))
-
-    def test_matched_pace_reports_ratio_confidence_and_coverage(self):
-        def sample(duration, ts):
-            return {
-                "duration_s": duration, "ts": ts, "day": "2026-07-13",
-                "input_tokens": 100000, "peak_input_tokens": 50000,
-                "cache_read_tokens": 70000, "output_tokens": 2000,
-                "tool_calls": 4, "model_calls": 3,
-            }
-        left = [sample(10, index * 60) for index in range(24)]
-        right = [sample(20, index * 60 + 1) for index in range(24)]
-        comparison = meter.matched_pace_comparison("left", left, "right", right)
-        self.assertTrue(comparison["available"])
-        self.assertEqual(comparison["matched_pairs"], 24)
-        self.assertEqual(comparison["coverage"], 1)
-        self.assertEqual(comparison["pace_ratio"], 2)
-        self.assertEqual(comparison["ci_low"], 2)
-        self.assertEqual(comparison["ci_high"], 2)
-
-    def test_matched_pace_withholds_sparse_or_different_tool_shapes(self):
-        base = {
-            "duration_s": 10, "ts": 1, "day": "2026-07-13",
-            "input_tokens": 10000, "peak_input_tokens": 10000,
-            "output_tokens": 1000, "model_calls": 1, "cache_read_tokens": 0,
-        }
-        sparse = meter.matched_pace_comparison(
-            "a", [{**base, "tool_calls": 0}] * 19,
-            "b", [{**base, "tool_calls": 0}] * 19,
-        )
-        different = meter.matched_pace_comparison(
-            "a", [{**base, "tool_calls": 0}] * 20,
-            "b", [{**base, "tool_calls": 1}] * 20,
-        )
-        self.assertFalse(sparse["available"])
-        self.assertIn("20 timed turns", sparse["reason"])
-        self.assertFalse(different["available"])
-        self.assertEqual(different["matched_pairs"], 0)
-        self.assertIn("comparable turns", different["reason"])
-
-    def test_matched_pace_completes_under_large_sample_volume(self):
-        def sample(idx, duration):
-            return {
-                "duration_s": duration, "ts": 1000000 + idx * 60,
-                "day": "2026-08-01",
-                "input_tokens": 100000, "peak_input_tokens": 100000,
-                "cache_read_tokens": 70000, "output_tokens": 2000,
-                "tool_calls": 4, "model_calls": 3,
-            }
-        left = [sample(i, 10) for i in range(2000)]
-        right = [sample(i, 20) for i in range(2000)]
-        session_rows = [
-            {
-                "id": f"ses_{i}", "provider": "opencode",
-                "runtime": "OpenCode", "project": f"project-{i % 10}",
-                "availability": {"cost": True, "tokens": True, "cache": True},
-                "model_stats": [
-                    {"model": f"model-{i % 3}", "cost": 1.0, "tokens": 5000,
-                     "input_tokens": 3000, "output_tokens": 2000,
-                     "executions": 10, "availability": {"cost": True, "tokens": True}},
-                ],
-                "_model_daily": [],
-                "_performance_samples": left if i == 0 else [],
-                "_wait_samples": [],
-                "_tool_evidence": meter.summarize_tool_evidence([]),
-            }
-            for i in range(50)
-        ]
-        session_rows.append({
-            "id": "ses_big", "provider": "opencode",
-            "runtime": "OpenCode", "project": "big-project",
-            "availability": {"cost": True, "tokens": True, "cache": True},
-            "model_stats": [
-                {"model": "model-0", "cost": 50.0, "tokens": 250000,
-                 "input_tokens": 150000, "output_tokens": 100000,
-                 "executions": 500, "availability": {"cost": True, "tokens": True}},
-            ],
-            "_model_daily": [],
-            "_performance_samples": right,
-            "_wait_samples": [],
-            "_tool_evidence": meter.summarize_tool_evidence([]),
-        })
-        start = time.time()
-        result = meter.aggregate_model_stats(session_rows)
-        elapsed = time.time() - start
-        self.assertLess(elapsed, 5.0,
-                        f"aggregate_model_stats took {elapsed:.1f}s with 4000 samples; "
-                        "matched_pace_comparison may be unbounded")
-        self.assertGreaterEqual(len(result.get("models", [])), 1)
-
-
-class RemovedLanguageSignalTests(unittest.TestCase):
-    def test_language_signal_endpoints_return_not_found(self):
-        for path in ("/settings/language-signals", "/settings/frustration"):
-            with self.subTest(path=path):
-                handler = object.__new__(meter.H)
-                handler.path = path
-                errors, responses = [], []
-                handler.send_error = lambda status: errors.append(status)
-                handler._send = lambda *args, **kwargs: responses.append((args, kwargs))
-                handler.headers = {"Host": "127.0.0.1:8722"}
-                handler.do_POST()
-                self.assertEqual(errors, [404])
-                self.assertEqual(responses, [])
-
-    def test_language_signal_code_is_gone_from_backend_and_parsers(self):
-        for name in (
-            "language_signal_settings", "set_language_signal_terms", "frustration_settings",
-            "set_frustration_terms", "analyze_language_signals", "analyze_language_signal_turns",
-            "attach_language_signals", "aggregate_language_signals", "aggregate_frustration",
-            "DEFAULT_FRUSTRATION_TERMS", "DEFAULT_POSITIVE_TERMS",
-        ):
-            self.assertFalse(hasattr(meter, name), name)
-        root = Path(meter.IMPLEMENTATION_FILE).parent
-        for path in sorted((root / "runtimes").glob("*.py")) + [root / "domain" / "aggregates.py"]:
-            source = path.read_text()
-            for marker in ("language_signal", "frustration", "signal_turns"):
-                self.assertNotIn(marker, source, f"{path.name}: {marker}")
-        self.assertNotIn('"language_signals"', Path(meter.IMPLEMENTATION_FILE).read_text())
-
-    def test_cross_session_payload_has_no_language_signal_fields(self):
-        def row(source):
-            return {
-                **source, "turns": 1, "cost": 1.0, "tokens": 100,
-                "input_tokens": 90, "output_tokens": 10,
-                "models": ["claude-test"], "token_estimate": False,
-                "availability": meter.metric_availability(
-                    "claude", cost=True, tokens=True,
-                    input_tokens=True, output_tokens=True,
-                ),
-                "_model_cost": {"claude-test": 1.0},
-                "_model_tok": {"claude-test": 100},
-                "_day_cost": {"2026-08-18": 1.0}, "model_stats": [],
-                "_model_daily": [], "_performance_samples": [],
-                "_wait_samples": [], "_tool_evidence": {},
-            }
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["data"], meter._xsess["at"] = None, 0
-            with mock.patch.object(meter, "session_summary", side_effect=row), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                result = meter.cross_session(sources=[{
-                    "id": "only", "path": "/tmp/only", "provider": "claude",
-                    "runtime": "Claude", "label": "Claude Desktop", "project": "/repo", "mtime": 1,
-                }])
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertNotIn("language_signals", result)
-        self.assertNotIn("frustration", result)
-        self.assertNotIn("language_signals", json.dumps(result))
-
-    def test_every_settings_write_drops_obsolete_language_signal_terms(self):
-        obsolete = {
-            "language_signal_terms": {"positive": ["great"], "friction": ["damn"]},
-            "frustration_terms": ["damn"],
-        }
-        writers = {
-            "updates": lambda path: meter.set_update_settings({"enabled": False, "auto_install": False}, path),
-            "budgets": lambda path: meter.set_budget_settings({"monthly_usd": 50}, path),
-            "session_budget": lambda path: meter.set_session_budget_override("session-a", 5, path=path),
-            "default_session_budget": lambda path: meter.set_default_session_budget_value(12, path=path),
-            "model_pricing": lambda path: meter.set_model_price(
-                "claude", "claude-sonnet-5",
-                {"input": 4, "output": 20, "cache_write": 5, "cache_read": 0.4},
-                effective_from=100, path=path,
-            ),
-            "work_insights": lambda path: meter.set_work_insights_settings({"pause_on_battery": False}, path),
-        }
-        for name, write in writers.items():
-            with self.subTest(writer=name), tempfile.TemporaryDirectory() as tmp:
-                path = Path(tmp) / "settings.json"
-                path.write_text(json.dumps({**obsolete, "unrelated": {"keep": True}}))
-                with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                    result = write(str(path))
-                saved = json.loads(path.read_text())
-                self.assertTrue(result.get("ok"), result)
-                self.assertNotIn("language_signal_terms", saved)
-                self.assertNotIn("frustration_terms", saved)
-                self.assertEqual(saved["unrelated"], {"keep": True})
-
-    def test_reading_settings_never_rewrites_obsolete_terms(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            original = json.dumps({"frustration_terms": ["damn"]})
-            path.write_text(original)
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                meter.update_settings(str(path))
-                meter.budget_settings(str(path))
-                meter.model_pricing_settings()
-            self.assertEqual(path.read_text(), original)
-
-
-class PricingTests(unittest.TestCase):
-    def test_builtin_pricing_exposes_reviewed_primary_sources(self):
-        pricing = meter.model_pricing_settings()
-        self.assertEqual(pricing["reviewed_on"], "2026-09-30")
-        self.assertEqual(
-            [source["provider"] for source in pricing["sources"]],
-            ["anthropic", "openai", "cursor", "google"],
-        )
-        self.assertEqual(
-            [source["url"] for source in pricing["sources"]],
-            [
-                "https://platform.claude.com/docs/en/about-claude/pricing",
-                "https://developers.openai.com/api/docs/models/compare",
-                "https://cursor.com/docs/models-and-pricing",
-                "https://ai.google.dev/gemini-api/docs/pricing",
-            ],
-        )
-
-    def test_current_anthropic_builtin_prices_match_primary_source(self):
-        self.assertEqual(meter.CLAUDE_PRICE["claude-fable-5"], {
-            "input": 10.0, "output": 50.0,
-            "cache_write": 12.5, "cache_read": 1.0,
-        })
-        self.assertEqual(meter.CLAUDE_PRICE["claude-opus-4-8"], {
-            "input": 5.0, "output": 25.0,
-            "cache_write": 6.25, "cache_read": 0.5,
-        })
-
-    def test_opus_5_uses_published_api_rates(self):
-        price, approximate = meter.price_for("claude-opus-5", "claude")
-        self.assertEqual(price, {
-            "input": 5.0, "output": 25.0, "cache_write": 6.25, "cache_read": 0.5,
-        })
-        self.assertFalse(approximate)
-        row = next(
-            item for item in meter.model_pricing_settings()["models"]
-            if item["provider"] == "claude" and item["model"] == "claude-opus-5"
-        )
-        self.assertTrue(row["builtin"])
-        self.assertFalse(row["overridden"])
-        self.assertEqual(row["source"], "built-in")
-
-    def test_sonnet_5_uses_current_standard_api_rates(self):
-        price, approximate = meter.price_for("claude-sonnet-5", "claude")
-        self.assertEqual(price, {"input": 2.0, "output": 10.0, "cache_write": 2.5, "cache_read": 0.2})
-        self.assertFalse(approximate)
-
-    def test_sonnet_5_5_uses_published_rates_in_settings_and_estimates(self):
-        expected = {
-            "input": 2.0, "output": 10.0,
-            "cache_write": 2.5, "cache_read": 0.2,
-        }
-        with tempfile.TemporaryDirectory() as tmp:
-            rows = [
-                item for item in meter.model_pricing_settings(
-                    path=str(Path(tmp) / "settings.json"),
-                )["models"]
-                if item["provider"] == "claude"
-                and item["model"] == "claude-sonnet-5-5"
-            ]
-        self.assertEqual(len(rows), 1)
-        row = rows[0]
-        self.assertEqual(row["prices"], expected)
-        self.assertTrue(row["builtin"])
-        self.assertEqual(row["source"], "built-in")
-        price, unavailable = meter.price_for("claude-sonnet-5-5", "claude")
-        self.assertEqual(price, expected)
-        self.assertFalse(unavailable)
-
-    def test_unknown_models_do_not_inherit_runtime_default_prices(self):
-        for provider, model, default_price in (
-            ("claude", "claude-future-unknown", meter.CLAUDE_PRICE[meter.DEFAULT_CLAUDE_MODEL]),
-            ("codex", "gpt-future-unknown", meter.OPENAI_PRICE[meter.DEFAULT_OPENAI_MODEL]),
-            ("opencode", "future-model", {
-                "input": 2.0, "output": 10.0,
-                "cache_write": 2.5, "cache_read": 0.2,
-            }),
-        ):
-            with self.subTest(provider=provider, model=model):
-                price, unavailable = meter.price_for(model, provider)
-                self.assertEqual(price, meter.ZERO_PRICE)
-                self.assertNotEqual(price, default_price)
-                self.assertTrue(unavailable)
-
-    def test_codex_path_discovery_does_not_invent_a_default_model(self):
-        path = os.path.expanduser("~/.codex/sessions/model-less.jsonl")
-        with (
-            mock.patch.object(meter, "all_session_sources", return_value=[]),
-            mock.patch.object(meter, "codex_meta", return_value={}),
-            mock.patch.object(meter, "safe_mtime", return_value=0),
-        ):
-            source = meter.source_from_path(path)
-
-        self.assertEqual(source["model"], "unknown-model")
-
-    def test_gpt_5_6_uses_current_sol_api_rates(self):
-        price, approximate = meter.price_for("gpt-5.6", "codex")
-        expected = {
-            "input": 4.0, "output": 20.0, "cache_write": 5.0, "cache_read": 0.4,
-        }
-        self.assertEqual(price, expected)
-        self.assertFalse(approximate)
-        explicit, explicit_approximate = meter.price_for("gpt-5.6-sol", "codex")
-        self.assertEqual(explicit, price)
-        self.assertFalse(explicit_approximate)
-        for model in ("gpt-5.6", "gpt-5.6-sol"):
-            with self.subTest(model=model):
-                row = next(
-                    item for item in meter.model_pricing_settings()["models"]
-                    if item["provider"] == "codex" and item["model"] == model
-                )
-                self.assertEqual(row["prices"], expected)
-                self.assertEqual(row["source"], "built-in")
-
-    def test_gpt_5_6_current_tier_prices_match_official_model_catalog(self):
-        expected = {
-            "gpt-5.6-terra": {
-                "input": 2.0, "output": 12.0, "cache_write": 2.5, "cache_read": 0.2,
-            },
-            "gpt-5.6-luna": {
-                "input": 0.2, "output": 1.2, "cache_write": 0.25, "cache_read": 0.02,
-            },
-        }
-        for model, prices in expected.items():
-            with self.subTest(model=model):
-                actual, approximate = meter.price_for(model, "codex")
-                self.assertEqual(actual, prices)
-                self.assertFalse(approximate)
-
-    def test_gpt_6_astra_uses_official_api_rates_and_appears_in_settings(self):
-        expected = {
-            "input": 10.0, "output": 50.0,
-            "cache_write": 12.5, "cache_read": 1.0,
-        }
-        actual, unavailable = meter.price_for("gpt-6-astra", "codex")
-
-        self.assertEqual(actual, expected)
-        self.assertFalse(unavailable)
-        row = next(
-            item for item in meter.model_pricing_settings()["models"]
-            if item["provider"] == "codex" and item["model"] == "gpt-6-astra"
-        )
-        self.assertTrue(row["builtin"])
-        self.assertFalse(row["overridden"])
-        self.assertEqual(row["source"], "built-in")
-        self.assertEqual(row["prices"], expected)
-
-    def test_gpt_5_6_price_cutover_preserves_older_session_estimates(self):
-        previous = {
-            "input": 5.0, "output": 30.0, "cache_write": 6.25, "cache_read": 0.5,
-        }
-        for model, current_input in (("gpt-5.6-terra", 2.0), ("gpt-5.6-luna", 0.2)):
-            with self.subTest(model=model):
-                old, old_approximate = meter.price_for(
-                    model, "codex", at=meter.GPT_56_PRICE_UPDATE_AT - 1,
-                )
-                current, current_approximate = meter.price_for(
-                    model, "codex", at=meter.GPT_56_PRICE_UPDATE_AT,
-                )
-                self.assertEqual(old, previous)
-                self.assertFalse(old_approximate)
-                self.assertEqual(current["input"], current_input)
-                self.assertFalse(current_approximate)
-
-    def test_gpt_5_6_long_context_multiplier_starts_at_price_cutover(self):
-        usage = {
-            "input_tokens": meter.GPT_56_LONG_CONTEXT_TOKENS + 1,
-            "cache_creation_input_tokens": 0,
-            "cache_read_input_tokens": 0,
-            "output_tokens": 100_000,
-        }
-        old = meter.cost_of(
-            usage, "gpt-5.6-sol", "cursor", at=meter.GPT_56_PRICE_UPDATE_AT - 1,
-        )
-        current = meter.cost_of(
-            usage, "gpt-5.6-sol", "cursor", at=meter.GPT_56_PRICE_UPDATE_AT,
-        )
-        self.assertAlmostEqual(old["input"], usage["input_tokens"] * 5.0 / 1e6)
-        self.assertAlmostEqual(old["output"], 3.0)
-        self.assertAlmostEqual(current["input"], usage["input_tokens"] * 5.0 * 2.0 / 1e6)
-        self.assertAlmostEqual(current["output"], 4.5)
-
-    def test_codex_credit_pricing_has_no_long_context_surcharge(self):
-        from token_meter.models.catalog import GPT_56_SOL_PRICE_UPDATE_AT as at
-        usage = {
-            "input_tokens": meter.GPT_56_LONG_CONTEXT_TOKENS - 99_999,
-            "cache_creation_input_tokens": 0,
-            "cache_read_input_tokens": 100_000,
-            "output_tokens": 100_000,
-        }
-        for model in ("gpt-5.6-sol", "gpt-6.1-sol"):
-            with self.subTest(model=model):
-                price, _ = meter.price_for(model, "codex", at=at)
-                codex = meter.cost_of(usage, model, "codex", at=at)
-                self.assertAlmostEqual(codex["input"], usage["input_tokens"] * price["input"] / 1e6)
-                self.assertAlmostEqual(codex["cache_read"], 100_000 * price["cache_read"] / 1e6)
-                self.assertAlmostEqual(codex["output"], 100_000 * price["output"] / 1e6)
-        cursor_price, _ = meter.price_for("gpt-5.6-sol", "cursor", at=at)
-        cursor = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=at)
-        self.assertAlmostEqual(
-            cursor["input"], usage["input_tokens"] * cursor_price["input"] * 2.0 / 1e6,
-        )
-        self.assertAlmostEqual(cursor["output"], 100_000 * cursor_price["output"] * 1.5 / 1e6)
-
-    def test_cursor_long_context_surcharge_boundary_and_cache_savings(self):
-        from token_meter.models.catalog import GPT_56_SOL_PRICE_UPDATE_AT as at
-        price, _ = meter.price_for("gpt-5.6-sol", "cursor", at=at)
-        # Cache writes and cache reads count toward the context threshold.
-        for context, multiplier in ((272_000, 1.0), (272_001, 2.0)):
-            with self.subTest(context=context):
-                usage = {
-                    "input_tokens": context - 2_000,
-                    "cache_creation_input_tokens": 1_000,
-                    "cache_read_input_tokens": 1_000,
-                    "output_tokens": 0,
-                }
-                cost = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=at)
-                self.assertAlmostEqual(
-                    cost["input"], (context - 2_000) * price["input"] * multiplier / 1e6,
-                )
-                self.assertAlmostEqual(
-                    cost["cache_write"], 1_000 * price["cache_write"] * multiplier / 1e6,
-                )
-                savings = meter.cache_savings({}, "cursor", "gpt-5.6-sol", [{
-                    "model": "gpt-5.6-sol", "ts": at,
-                    "tokens": {"fresh_input": context - 2_000,
-                               "cache_read": 1_000, "cache_write": 1_000},
-                }])
-                self.assertAlmostEqual(
-                    savings,
-                    1_000 * (price["input"] - price["cache_read"]) * multiplier / 1e6,
-                )
-
-    def test_custom_model_price_persists_and_drives_cost_calculation(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                result = meter.set_model_price(
-                    "openai", "gpt-custom-1",
-                    {"input": 1.25, "output": 6.5, "cache_write": 0, "cache_read": 0.2},
-                )
-                price, approximate = meter.price_for("gpt-custom-1", "codex")
-                cost = meter.cost_of({
-                    "input_tokens": 1_000_000,
-                    "output_tokens": 1_000_000,
-                    "cache_creation_input_tokens": 1_000_000,
-                    "cache_read_input_tokens": 1_000_000,
-                }, "gpt-custom-1", "codex")
-                saved = json.loads(path.read_text())
-        self.assertTrue(result["ok"])
-        self.assertEqual(price, {
-            "input": 1.25, "output": 6.5, "cache_write": 0.0, "cache_read": 0.2,
-        })
-        self.assertFalse(approximate)
-        self.assertEqual(cost, {
-            "input": 1.25, "output": 6.5, "cache_write": 0.0, "cache_read": 0.2,
-        })
-        self.assertIn("gpt-custom-1", saved["model_pricing"]["codex"])
-        self.assertIsInstance(saved["model_pricing"]["codex"]["gpt-custom-1"], list)
-        self.assertIsNotNone(
-            saved["model_pricing"]["codex"]["gpt-custom-1"][0]["effective_from"]
-        )
-
-    def test_model_price_batch_persists_multiple_rows_with_one_atomic_write(self):
-        changes = [
-            {
-                "provider": "claude", "model": "claude-opus-5",
-                "prices": {"input": 6, "output": 30, "cache_write": 7.5, "cache_read": 0.6},
-            },
-            {
-                "provider": "codex", "model": "gpt-5.4",
-                "prices": {"input": 3, "output": 18, "cache_write": 0, "cache_read": 0.3},
-            },
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            original_write = meter.atomic_write_text
-            with mock.patch.object(
-                    meter, "atomic_write_text", side_effect=original_write) as write:
-                result = meter.set_model_prices(
-                    changes, path=str(path), effective_from=100,
-                )
-            saved = json.loads(path.read_text())
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["effective_scope"], "selected_time")
-        self.assertEqual(len(result["changes"]), 2)
-        self.assertEqual(write.call_count, 1)
-        self.assertEqual(
-            saved["model_pricing"]["claude"]["claude-opus-5"][0]["effective_from"],
-            100.0,
-        )
-        self.assertEqual(
-            saved["model_pricing"]["codex"]["gpt-5.4"][0]["effective_from"],
-            100.0,
-        )
-
-    def test_invalid_model_price_batch_is_rejected_without_any_write(self):
-        changes = [
-            {
-                "provider": "codex", "model": "gpt-valid",
-                "prices": {"input": 1, "output": 4, "cache_write": 0, "cache_read": 0.1},
-            },
-            {
-                "provider": "codex", "model": "gpt-invalid",
-                "prices": {"input": -1, "output": 4, "cache_write": 0, "cache_read": 0.1},
-            },
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text('{"keep": "unchanged"}\n')
-            before = path.read_text()
-            with mock.patch.object(meter, "atomic_write_text") as write:
-                result = meter.set_model_prices(changes, path=str(path))
-            after = path.read_text()
-        self.assertFalse(result["ok"])
-        self.assertEqual(before, after)
-        write.assert_not_called()
-
-    def test_model_price_batch_rejects_duplicate_provider_model_entries(self):
-        price = {"input": 1, "output": 4, "cache_write": 0, "cache_read": 0.1}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            result = meter.set_model_prices([
-                {"provider": "openai", "model": "gpt-duplicate", "prices": price},
-                {"provider": "codex", "model": "gpt-duplicate", "prices": price},
-            ], path=str(path))
-        self.assertFalse(result["ok"])
-        self.assertIn("duplicate", result["error"].lower())
-        self.assertFalse(path.exists())
-
-    def test_builtin_override_can_be_restored_without_losing_other_settings(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"frustration_terms": ["damn"], "unrelated": {"keep": True}}))
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                changed = meter.set_model_price(
-                    "claude", "claude-sonnet-5",
-                    {"input": 4, "output": 20, "cache_write": 5, "cache_read": 0.4},
-                    effective_from=100,
-                )
-                price, approximate = meter.price_for(
-                    "claude-sonnet-5", "claude", at=150,
-                )
-                pricing = meter.model_pricing_settings()
-                restored = meter.set_model_price(
-                    "claude", "claude-sonnet-5", remove=True,
-                    effective_from=200,
-                )
-                default_price, default_approximate = meter.price_for(
-                    "claude-sonnet-5", "claude", at=200,
-                )
-                historical_price, _ = meter.price_for(
-                    "claude-sonnet-5", "claude", at=150,
-                )
-                saved = json.loads(path.read_text())
-        row = next(
-            item for item in pricing["models"]
-            if item["provider"] == "claude" and item["model"] == "claude-sonnet-5"
-        )
-        self.assertTrue(changed["ok"])
-        self.assertEqual(price["input"], 4.0)
-        self.assertFalse(approximate)
-        self.assertEqual(row["source"], "override")
-        self.assertTrue(restored["ok"])
-        self.assertEqual(default_price, meter.CLAUDE_PRICE["claude-sonnet-5"])
-        self.assertFalse(default_approximate)
-        self.assertEqual(historical_price["input"], 4.0)
-        self.assertEqual(saved["unrelated"], {"keep": True})
-        self.assertNotIn("frustration_terms", saved)
-        periods = saved["model_pricing"]["claude"]["claude-sonnet-5"]
-        self.assertEqual(periods[0]["effective_from"], 100.0)
-        self.assertEqual(periods[1], {"effective_from": 200.0, "use_builtin": True})
-
-    def test_legacy_override_remains_all_history_and_migrates_on_next_edit(self):
-        legacy = {"input": 7, "output": 21, "cache_write": 8, "cache_read": 0.7}
-        updated = {"input": 4, "output": 12, "cache_write": 5, "cache_read": 0.4}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({
-                "model_pricing": {"codex": {"gpt-5.6-terra": legacy}},
-                "language_signal_terms": {"positive": ["great"], "friction": ["damn"]},
-                "unrelated": {"keep": True},
-            }))
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                before_migration, _ = meter.price_for("gpt-5.6-terra", "codex", at=1)
-                result = meter.set_model_price(
-                    "codex", "gpt-5.6-terra", updated, effective_from=500,
-                )
-                before_cutoff, _ = meter.price_for("gpt-5.6-terra", "codex", at=499)
-                at_cutoff, _ = meter.price_for("gpt-5.6-terra", "codex", at=500)
-                saved = json.loads(path.read_text())
-        self.assertTrue(result["ok"])
-        self.assertEqual(before_migration, {key: float(value) for key, value in legacy.items()})
-        self.assertEqual(before_cutoff, before_migration)
-        self.assertEqual(at_cutoff, {key: float(value) for key, value in updated.items()})
-        self.assertEqual(saved["unrelated"], {"keep": True})
-        self.assertNotIn("language_signal_terms", saved)
-        periods = saved["model_pricing"]["codex"]["gpt-5.6-terra"]
-        self.assertIsNone(periods[0]["effective_from"])
-        self.assertEqual(periods[1]["effective_from"], 500.0)
-
-    def test_custom_model_can_be_retired_without_losing_historical_price(self):
-        prices = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                added = meter.set_model_price(
-                    "codex", "gpt-retired", prices, effective_from=100,
-                )
-                retired = meter.set_model_price(
-                    "codex", "gpt-retired", remove=True, effective_from=200,
-                )
-                old, old_approximate = meter.price_for("gpt-retired", "codex", at=150)
-                current, current_approximate = meter.price_for("gpt-retired", "codex", at=200)
-                pricing = meter.model_pricing_settings()
-                saved = json.loads(path.read_text())
-        row = next(item for item in pricing["models"] if item["model"] == "gpt-retired")
-        self.assertTrue(added["ok"])
-        self.assertTrue(retired["ok"])
-        self.assertEqual(old, {key: float(value) for key, value in prices.items()})
-        self.assertFalse(old_approximate)
-        self.assertTrue(current_approximate)
-        self.assertNotEqual(current, old)
-        self.assertFalse(row["active"])
-        self.assertEqual(row["source"], "retired")
-        self.assertEqual(row["effective_from"], 200.0)
-        self.assertEqual(row["prices"], old)
-        self.assertEqual(pricing["retired_custom_models"], 1)
-        self.assertEqual(
-            saved["model_pricing"]["codex"]["gpt-retired"][-1],
-            {"effective_from": 200.0, "inactive": True},
-        )
-
-    def test_apply_to_all_history_is_explicit_and_replaces_timeline(self):
-        first = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
-        global_price = {"input": 2, "output": 6, "cache_write": 0, "cache_read": 0.2}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                meter.set_model_price("codex", "gpt-global", first, effective_from=100)
-                result = meter.set_model_price(
-                    "codex", "gpt-global", global_price, apply_to_all_history=True,
-                )
-                historical, approximate = meter.price_for("gpt-global", "codex", at=1)
-                saved = json.loads(path.read_text())
-        self.assertTrue(result["ok"])
-        self.assertTrue(result["apply_to_all_history"])
-        self.assertIsNone(result["effective_from"])
-        self.assertFalse(approximate)
-        self.assertEqual(historical, {key: float(value) for key, value in global_price.items()})
-        self.assertEqual(len(saved["model_pricing"]["codex"]["gpt-global"]), 1)
-        self.assertIsNone(saved["model_pricing"]["codex"]["gpt-global"][0]["effective_from"])
-
-    def test_identical_current_price_does_not_add_redundant_period(self):
-        prices = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            first = meter.set_model_price(
-                "codex", "gpt-idempotent", prices, path=str(path), effective_from=100,
-            )
-            repeated = meter.set_model_price(
-                "codex", "gpt-idempotent", prices, path=str(path), effective_from=200,
-            )
-            saved = json.loads(path.read_text())
-        self.assertTrue(first["changed"])
-        self.assertFalse(repeated["changed"])
-        self.assertEqual(len(saved["model_pricing"]["codex"]["gpt-idempotent"]), 1)
-
-    def test_session_cost_can_span_manual_price_periods(self):
-        usage = {
-            "input_tokens": 1_000_000,
-            "output_tokens": 0,
-            "cache_creation_input_tokens": 0,
-            "cache_read_input_tokens": 0,
-        }
-        override = {"input": 4, "output": 20, "cache_write": 5, "cache_read": 0.4}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                meter.set_model_price(
-                    "claude", "claude-sonnet-5", override, effective_from=100,
-                )
-                before = meter.cost_of(usage, "claude-sonnet-5", "claude", at=99)
-                after = meter.cost_of(usage, "claude-sonnet-5", "claude", at=100)
-        self.assertEqual(before["input"], 2.0)
-        self.assertEqual(after["input"], 4.0)
-        self.assertEqual(before["input"] + after["input"], 6.0)
-
-    def test_oversized_manual_history_is_ignored_without_repricing_builtin(self):
-        prices = {"input": 9, "output": 9, "cache_write": 9, "cache_read": 9}
-        periods = [
-            {"effective_from": index, "prices": prices}
-            for index in range(meter.MAX_MODEL_PRICE_PERIODS + 1)
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({
-                "model_pricing": {"claude": {"claude-sonnet-5": periods}},
-            }))
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
-                price, approximate = meter.price_for(
-                    "claude-sonnet-5", "claude", at=meter.MAX_MODEL_PRICE_PERIODS + 2,
-                )
-                row = next(
-                    item for item in meter.model_pricing_settings()["models"]
-                    if item["provider"] == "claude" and item["model"] == "claude-sonnet-5"
-                )
-        self.assertEqual(price, meter.CLAUDE_PRICE["claude-sonnet-5"])
-        self.assertFalse(approximate)
-        self.assertEqual(row["periods"], 0)
-
-    def test_model_pricing_http_action_forwards_bounded_scope_fields(self):
-        source = Path(meter.IMPLEMENTATION_FILE).read_text()
-        self.assertIn('if isinstance(payload.get("changes"), list)', source)
-        self.assertIn('set_model_prices(', source)
-        self.assertIn(
-            'apply_to_all_history=payload.get("apply_to_all_history") is True',
-            source,
-        )
-        self.assertIn('effective_from=payload.get("effective_from")', source)
-
-    def test_future_or_conflicting_effective_scope_is_rejected(self):
-        prices = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            future = meter.set_model_price(
-                "codex", "gpt-future", prices, path=str(path),
-                effective_from=meter.time.time() + 600,
-            )
-            conflicting = meter.set_model_price(
-                "codex", "gpt-conflict", prices, path=str(path),
-                effective_from=100, apply_to_all_history=True,
-            )
-        self.assertFalse(future["ok"])
-        self.assertIn("future", future["error"])
-        self.assertFalse(conflicting["ok"])
-        self.assertIn("either", conflicting["error"])
-        self.assertFalse(path.exists())
-
-    def test_invalid_custom_model_prices_are_rejected(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            bad_model = meter.set_model_price(
-                "codex", "model with spaces",
-                {"input": 1, "output": 2, "cache_write": 0, "cache_read": 0},
-                path=str(path),
-            )
-            bad_price = meter.set_model_price(
-                "codex", "gpt-custom",
-                {"input": -1, "output": 2, "cache_write": 0, "cache_read": 0},
-                path=str(path),
-            )
-        self.assertFalse(bad_model["ok"])
-        self.assertFalse(bad_price["ok"])
-        self.assertFalse(path.exists())
-
-    def test_longest_model_prefix_wins(self):
-        price, approximate = meter.price_for("gpt-5.4-mini-2026-07-01", "codex")
-        self.assertEqual(price, meter.OPENAI_PRICE["gpt-5.4-mini"])
-        self.assertFalse(approximate)
-
-
-class SessionSummaryStatsTests(unittest.TestCase):
-    def source(self, provider, model=None):
-        return {
-            "id": "session", "path": "/tmp/session.jsonl", "provider": provider,
-            "client": provider, "label": provider.title(), "project": "/repo",
-            "mtime": 1, "title": "Summary stats", "model": model,
-        }
-
-    def test_claude_summary_exposes_input_output_and_model_stats(self):
-        objs = [{
-            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {
-                "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
-                "usage": {"input_tokens": 100, "cache_creation_input_tokens": 20,
-                          "cache_read_input_tokens": 30, "output_tokens": 10},
-                "stop_reason": "end_turn",
-            },
-        }]
-        row = meter.claude_summary(self.source("claude"), objs)
-        self.assertEqual(row["input_tokens"], 150)
-        self.assertEqual(row["output_tokens"], 10)
-        self.assertEqual(row["model_stats"][0]["model"], "claude-sonnet-4-6")
-        self.assertEqual(row["model_stats"][0]["executions"], 1)
-        self.assertEqual(row["model_stats"][0]["reasoning_executions"], 0)
-        self.assertEqual(row["model_stats"][0]["reasoning_unavailable_executions"], 1)
-        self.assertEqual(row["primary_model"], "claude-sonnet-4-6")
-        self.assertEqual(row["context"]["latest"], 150)
-        self.assertIsNone(row["context"]["window"])
-        self.assertEqual(row["_context_samples"], [150])
-        self.assertTrue(row["terminal"])
-        self.assertEqual(row["usage_basis"], "reported")
-
-    def test_claude_summary_keeps_thinking_visible_without_inventing_reasoning_tokens(self):
-        objs = [
-            {
-                "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-                "message": {
-                    "id": "msg-1", "model": "claude-opus-4-8",
-                    "content": [{"type": "thinking", "thinking": "hidden"}],
-                    "usage": {"input_tokens": 100, "output_tokens": 40},
-                    "stop_reason": "end_turn",
-                },
-            },
-            {
-                "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
-                "message": {
-                    "id": "msg-1", "model": "claude-opus-4-8",
-                    "content": [{"type": "text", "text": "answer"}],
-                    "usage": {"input_tokens": 100, "output_tokens": 40},
-                    "stop_reason": "end_turn",
-                },
-            },
-        ]
-
-        row = meter.claude_summary(self.source("claude"), objs)
-        stats = row["model_stats"][0]
-        self.assertEqual(stats["executions"], 1)
-        self.assertEqual(stats["reasoning_tokens"], 0)
-        self.assertEqual(stats["reasoning_output_tokens"], 0)
-        self.assertEqual(stats["reasoning_executions"], 0)
-        self.assertEqual(stats["reasoning_unavailable_executions"], 1)
-        self.assertEqual(stats["thinking_executions"], 1)
-        self.assertEqual(stats["thinking_covered_executions"], 0)
-        aggregate = meter.aggregate_model_stats([row])["models"][0]
-        self.assertEqual(aggregate["reasoning_tokens"], 0)
-        self.assertEqual(aggregate["reasoning_output_tokens"], 0)
-        self.assertFalse(aggregate["availability"]["reasoning_tokens"])
-        self.assertFalse(aggregate["coverage"]["reasoning_tokens"]["complete"])
-        self.assertEqual(aggregate["thinking_executions"], 1)
-        self.assertEqual(aggregate["thinking_covered_executions"], 0)
-        self.assertEqual(aggregate["daily"][0]["reasoning_tokens"], 0)
-        self.assertEqual(aggregate["daily"][0]["thinking_executions"], 1)
-        self.assertEqual(aggregate["daily"][0]["thinking_covered_executions"], 0)
-
-    def test_claude_summary_accepts_separate_thinking_token_stat(self):
-        row = meter.claude_summary(self.source("claude"), [{
-            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "thinking", "thinking": "hidden"}],
-                "usage": {
-                    "input_tokens": 100,
-                    "output_tokens": 40,
-                    "thinking_tokens": 30,
-                },
-                "stop_reason": "end_turn",
-            },
-        }])
-
-        stats = row["model_stats"][0]
-        self.assertEqual(stats["reasoning_tokens"], 30)
-        self.assertEqual(stats["reasoning_output_tokens"], 40)
-        self.assertEqual(stats["reasoning_executions"], 1)
-        self.assertEqual(stats["thinking_executions"], 1)
-        self.assertEqual(stats["thinking_covered_executions"], 1)
-
-    def test_claude_split_messages_preserve_separate_thinking_token_stat(self):
-        thinking = {
-            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "thinking", "thinking": "hidden"}],
-                "usage": {
-                    "input_tokens": 100,
-                    "output_tokens": 40,
-                    "thinking_tokens": 30,
-                },
-                "stop_reason": None,
-            },
-        }
-        answer = {
-            "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
-            "message": {
-                "id": "msg-1", "model": "claude-opus-4-8",
-                "content": [{"type": "text", "text": "answer"}],
-                "usage": {"input_tokens": 100, "output_tokens": 40},
-                "stop_reason": "end_turn",
-            },
-        }
-
-        for records in ([thinking, answer], [answer, thinking]):
-            with self.subTest(exact_stat_first=records[0] is thinking):
-                row = meter.claude_summary(self.source("claude"), records)
-                stats = row["model_stats"][0]
-                self.assertEqual(stats["reasoning_tokens"], 30)
-                self.assertEqual(stats["reasoning_output_tokens"], 40)
-                self.assertEqual(stats["thinking_covered_executions"], 1)
-
-                with tempfile.TemporaryDirectory() as tmp:
-                    path = Path(tmp) / "claude-thinking.jsonl"
-                    path.write_text("".join(
-                        json.dumps(record) + "\n" for record in records
-                    ))
-                    selected = meter.recompute_claude({
-                        **self.source("claude"),
-                        "path": str(path),
-                        "session": path.name,
-                    })
-                self.assertEqual(selected["semantic"]["reasoning"], 30)
-                self.assertEqual(selected["semantic"]["output"], 10)
-
-    def test_claude_selected_session_never_substitutes_output_for_thinking_tokens(self):
-        def recompute(thinking_tokens=None, block_type="thinking"):
-            usage = {"input_tokens": 100, "output_tokens": 40}
-            if thinking_tokens is not None:
-                usage["thinking_tokens"] = thinking_tokens
-            records = [
-                {
-                    "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-                    "message": {
-                        "id": "msg-1", "model": "claude-opus-4-8",
-                        "content": [{"type": block_type, "thinking": "hidden"}],
-                        "usage": usage, "stop_reason": "end_turn",
-                    },
-                },
-                {
-                    "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
-                    "message": {
-                        "id": "msg-1", "model": "claude-opus-4-8",
-                        "content": [{"type": "text", "text": "answer"}],
-                        "usage": usage, "stop_reason": "end_turn",
-                    },
-                },
-            ]
-            with tempfile.TemporaryDirectory() as tmp:
-                path = Path(tmp) / "claude-thinking.jsonl"
-                path.write_text("".join(json.dumps(record) + "\n" for record in records))
-                return meter.recompute_claude({
-                    **self.source("claude"), "path": str(path), "session": path.name,
-                })
-
-        unavailable = recompute()
-        self.assertEqual(unavailable["semantic"]["reasoning"], 0)
-        self.assertEqual(unavailable["semantic"]["output"], 40)
-        self.assertEqual(unavailable["analyses"]["reasoning"]["tokens"], 0)
-        self.assertEqual(unavailable["analyses"]["reasoning"]["think_turns"], 0)
-        self.assertEqual(unavailable["series"][0]["reasoning"], 0)
-        self.assertEqual(unavailable["executions"][0]["reasoning_tokens"], 0)
-        self.assertEqual(unavailable["executions"][0]["tokens"]["reasoning"], 0)
-        self.assertFalse(any(
-            event["kind"] == "reasoning" for event in unavailable["trace"]
-        ))
-        message = next(
-            event for event in unavailable["trace"] if event["kind"] == "message"
-        )
-        self.assertEqual(message["reasoning_tokens"], 0)
-
-        redacted = recompute(block_type="redacted_thinking")
-        self.assertEqual(redacted["semantic"]["reasoning"], 0)
-        self.assertEqual(redacted["executions"][0]["reasoning_tokens"], 0)
-
-        exact = recompute(30)
-        self.assertEqual(exact["semantic"]["reasoning"], 30)
-        self.assertEqual(exact["semantic"]["output"], 10)
-        self.assertEqual(exact["analyses"]["reasoning"]["tokens"], 30)
-        self.assertEqual(exact["analyses"]["reasoning"]["think_turns"], 1)
-        self.assertEqual(exact["series"][0]["reasoning"], 30)
-        self.assertEqual(exact["executions"][0]["reasoning_tokens"], 30)
-        self.assertEqual(exact["executions"][0]["tokens"]["reasoning"], 30)
-
-    def test_claude_summary_keeps_missing_model_pricing_unavailable(self):
-        row = meter.claude_summary(self.source("claude"), [{
-            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {
-                "id": "msg-1", "content": [],
-                "usage": {"input_tokens": 100_000, "output_tokens": 1_000},
-                "stop_reason": "end_turn",
-            },
-        }])
-
-        self.assertEqual(row["primary_model"], "unknown-model")
-        self.assertFalse(row["availability"]["cost"])
-        self.assertEqual(row["cost"], 0.0)
-
-    def test_claude_and_codex_malformed_token_counts_fail_closed(self):
-        for value in ("bad", True, -1, 1.5, float("inf"), 10 ** 400):
-            with self.subTest(runtime="claude", value_type=type(value).__name__):
-                claude = meter.claude_summary(self.source("claude"), [
-                    {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
-                     "message": {"content": "start"}},
-                    {"type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
-                     "message": {
-                         "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
-                         "usage": {"input_tokens": value, "output_tokens": value},
-                         "stop_reason": "end_turn",
-                     }},
-                    {"type": "user", "timestamp": "2026-07-02T00:00:02.000Z",
-                     "message": {"content": "next"}},
-                ])
-                self.assertFalse(claude["availability"]["tokens"])
-                self.assertFalse(claude["availability"]["input_tokens"])
-                self.assertFalse(claude["availability"]["output_tokens"])
-                self.assertFalse(claude["availability"]["cost"])
-                self.assertEqual(claude["model_stats"][0]["token_covered_executions"], 0)
-                self.assertEqual(claude["model_stats"][0]["io_covered_executions"], 0)
-                self.assertEqual(claude["model_stats"][0]["cost_covered_executions"], 0)
-
-            with self.subTest(runtime="codex", value_type=type(value).__name__):
-                codex = meter.codex_summary(self.source("codex", "gpt-5.6-sol"), [{
-                    "timestamp": "2026-07-02T00:00:00.000Z",
-                    "type": "event_msg",
-                    "payload": {"type": "token_count", "info": {
-                        "last_token_usage": {
-                            "input_tokens": value, "output_tokens": value,
-                        },
-                    }},
-                }])
-                self.assertFalse(codex["availability"]["tokens"])
-                self.assertFalse(codex["availability"]["input_tokens"])
-                self.assertFalse(codex["availability"]["output_tokens"])
-                self.assertFalse(codex["availability"]["cost"])
-                self.assertEqual(codex["model_stats"][0]["token_covered_executions"], 0)
-                self.assertEqual(codex["model_stats"][0]["io_covered_executions"], 0)
-                self.assertEqual(codex["model_stats"][0]["cost_covered_executions"], 0)
-
-        output_only = meter.codex_summary(
-            self.source("codex", "gpt-5.6-sol"), [{
-                "timestamp": "2026-07-02T00:00:00.000Z",
-                "type": "event_msg",
-                "payload": {"type": "token_count", "info": {
-                    "last_token_usage": {"input_tokens": "bad", "output_tokens": 20},
-                }},
-            }],
-        )
-        self.assertFalse(output_only["availability"]["cache"])
-        self.assertFalse(output_only["model_stats"][0]["availability"]["cache"])
-        aggregate = meter.aggregate_model_stats([output_only])["models"][0]
-        self.assertFalse(aggregate["availability"]["cache"])
-        self.assertFalse(aggregate["coverage"]["cache"]["complete"])
-
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "claude-malformed.jsonl"
-            records = [
-                {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
-                 "message": {"content": "start"}},
-                {"type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
-                 "message": {
-                     "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
-                     "usage": {"input_tokens": "bad", "output_tokens": "bad"},
-                     "stop_reason": "end_turn",
-                 }},
-                {"type": "user", "timestamp": "2026-07-02T00:00:02.000Z",
-                 "message": {"content": "next"}},
-            ]
-            path.write_text("".join(json.dumps(record) + "\n" for record in records))
-            state = meter.recompute_claude({
-                **self.source("claude"), "path": str(path), "session": path.name,
-            })
-        self.assertIsNotNone(state)
-        self.assertFalse(state["availability"]["tokens"])
-        self.assertFalse(state["availability"]["cost"])
-
-    def test_claude_summary_keeps_priced_model_coverage_in_mixed_session(self):
-        def message(message_id, model, timestamp, output_tokens):
-            return {
-                "type": "assistant", "timestamp": timestamp,
-                "message": {
-                    "id": message_id, "model": model, "content": [],
-                    "usage": {
-                        "input_tokens": 100, "output_tokens": output_tokens,
-                    },
-                    "stop_reason": "end_turn",
-                },
-            }
-
-        row = meter.claude_summary(self.source("claude"), [
-            message("msg-known", "claude-sonnet-4-6", "2026-07-02T00:00:01.000Z", 20),
-            message("msg-unknown", "unknown-model", "2026-07-02T00:00:02.000Z", 30),
-        ])
-
-        self.assertFalse(row["availability"]["cost"])
-        stats = {item["model"]: item for item in row["model_stats"]}
-        self.assertTrue(stats["claude-sonnet-4-6"]["availability"]["cost"])
-        self.assertEqual(stats["claude-sonnet-4-6"]["cost_covered_executions"], 1)
-        self.assertEqual(stats["claude-sonnet-4-6"]["cost_covered_output_tokens"], 20)
-        self.assertFalse(stats["unknown-model"]["availability"]["cost"])
-        self.assertEqual(stats["unknown-model"]["cost_covered_executions"], 0)
-        daily = {item["model"]: item for item in row["_model_daily"]}
-        self.assertTrue(daily["claude-sonnet-4-6"]["availability"]["cost"])
-        self.assertFalse(daily["unknown-model"]["availability"]["cost"])
-
-        aggregate = {
-            item["model"]: item for item in meter.aggregate_model_stats([row])["models"]
-        }
-        known = aggregate["claude-sonnet-4-6"]
-        self.assertTrue(known["availability"]["cost"])
-        self.assertEqual(known["cost_covered_executions"], 1)
-        self.assertEqual(known["cost_covered_output_tokens"], 20)
-        self.assertTrue(known["daily"][0]["availability"]["cost"])
-        self.assertFalse(aggregate["unknown-model"]["availability"]["cost"])
-
-    def test_claude_summary_ignores_zero_usage_synthetic_marker_for_cost_coverage(self):
-        def message(message_id, model, input_tokens, output_tokens):
-            return {
-                "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
-                "message": {
-                    "id": message_id, "model": model, "content": [],
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "cache_read_input_tokens": 0,
-                        "cache_creation_input_tokens": 0,
-                        "output_tokens": output_tokens,
-                    },
-                    "stop_reason": "end_turn",
-                },
-            }
-
-        row = meter.claude_summary(self.source("claude"), [
-            message("msg-known", "claude-sonnet-4-6", 100, 20),
-            message("msg-synthetic", "<synthetic>", 0, 0),
-        ])
-
-        self.assertTrue(row["availability"]["cost"])
-        self.assertFalse(row["cost_approx"])
-        self.assertGreater(row["cost"], 0)
-        self.assertEqual(row["primary_model"], "claude-sonnet-4-6")
-        self.assertEqual(row["models"], ["sonnet-4-6"])
-        self.assertEqual(row["context"]["latest"], 100)
-        self.assertEqual(row["_context_samples"], [100])
-        self.assertEqual(row["turns"], 1)
-        self.assertTrue(row["terminal"])
-        from token_meter.domain.aggregates import aggregate_cross_session_rows
-        self.assertEqual(
-            aggregate_cross_session_rows([row])["total_executions"], 1,
-        )
-
-    def test_claude_summary_synthetic_marker_does_not_extend_timing(self):
-        synthetic = self.synthetic_record()
-        synthetic["timestamp"] = "2026-07-02T00:01:00.000Z"
-        row = meter.claude_summary(self.source("claude"), [{
-            "type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {"content": "test request"},
-        }, self.claude_usage_row("2026-07-02T00:00:01.000Z"), synthetic])
-
-        self.assertEqual(row["duration_s"], 1)
-        self.assertEqual(len(row["_wait_samples"]), 1)
-        self.assertEqual(row["_wait_samples"][0]["duration_s"], 1)
-        self.assertEqual(row["_wait_samples"][0]["model"], "claude-sonnet-4-6")
-
-    def synthetic_record(self, usage=None):
-        if usage is None:
-            usage = {
-                "input_tokens": 0, "cache_creation_input_tokens": 0,
-                "cache_read_input_tokens": 0, "output_tokens": 0,
-            }
-        return {
-            "type": "assistant", "timestamp": "2026-07-02T00:01:00.000Z",
-            "message": {
-                "id": "msg-synthetic", "model": "<synthetic>", "content": [],
-                "usage": usage,
-                "stop_reason": "stop_sequence",
-            },
-        }
-
-    def test_claude_synthetic_marker_requires_valid_complete_zero_usage(self):
-        cases = {
-            "malformed": {
-                "input_tokens": "bad", "cache_creation_input_tokens": 0,
-                "cache_read_input_tokens": 0, "output_tokens": "bad",
-            },
-            "missing-output": {
-                "input_tokens": 0, "cache_creation_input_tokens": 0,
-                "cache_read_input_tokens": 0,
-            },
-        }
-        for name, usage in cases.items():
-            with self.subTest(name=name):
-                objs = [self.claude_usage_row(), self.synthetic_record(usage)]
-
-                summary = meter.claude_summary(self.source("claude"), objs)
-                with tempfile.TemporaryDirectory() as tmp:
-                    path = Path(tmp) / "session.jsonl"
-                    path.write_text("".join(json.dumps(row) + "\n" for row in objs))
-                    state = meter.recompute_claude({
-                        **self.source("claude"), "path": str(path),
-                        "session": path.name,
-                    })
-
-                self.assertEqual(summary["turns"], 2)
-                self.assertEqual(summary["primary_model"], "<synthetic>")
-                self.assertFalse(summary["availability"]["cost"])
-                self.assertFalse(state["availability"]["cost"])
-                if name == "malformed":
-                    self.assertFalse(summary["availability"]["tokens"])
-                    self.assertFalse(state["availability"]["tokens"])
-
-    def test_claude_summary_keeps_other_angle_bracket_models(self):
-        other = self.synthetic_record()
-        other["message"]["model"] = "<local-model>"
-
-        row = meter.claude_summary(
-            self.source("claude"), [self.claude_usage_row(), other],
-        )
-
-        self.assertEqual(row["turns"], 2)
-        self.assertEqual(row["primary_model"], "<local-model>")
-        self.assertIn("<local-model>", row["models"])
-
-    def test_claude_only_synthetic_marker_keeps_usage_unavailable(self):
-        objs = [self.synthetic_record()]
-
-        summary = meter.claude_summary(self.source("claude"), objs)
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_text(json.dumps(objs[0]) + "\n")
-            state = meter.recompute_claude({
-                **self.source("claude"), "path": str(path),
-                "session": path.name,
-            })
-
-        self.assertEqual(summary["turns"], 0)
-        self.assertFalse(summary["availability"]["tokens"])
-        self.assertFalse(summary["availability"]["cost"])
-        self.assertEqual(state["executions"], [])
-        self.assertFalse(state["availability"]["tokens"])
-        self.assertFalse(state["availability"]["cost"])
-
-    def test_claude_summary_prices_pseudo_model_records_that_report_tokens(self):
-        objs = [
-            self.claude_usage_row(),
-            self.synthetic_record({"input_tokens": 40, "output_tokens": 5}),
-        ]
-
-        row = meter.claude_summary(self.source("claude"), objs)
-
-        self.assertFalse(row["availability"]["cost"])
-        self.assertEqual(row["primary_model"], "<synthetic>")
-
-    def test_claude_recompute_keeps_cost_available_with_synthetic_records(self):
-        records = [{
-            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {
-                "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
-                "usage": {"input_tokens": 10, "cache_creation_input_tokens": 5_000,
-                          "cache_read_input_tokens": 5_000, "output_tokens": 10,
-                          "cache_creation": {
-                              "ephemeral_5m_input_tokens": 5_000,
-                              "ephemeral_1h_input_tokens": 0,
-                          }},
-                "stop_reason": "end_turn",
-            },
-        }, self.synthetic_record()]
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_text("".join(json.dumps(row) + "\n" for row in records))
-            source = {
-                **self.source("claude"), "path": str(path),
-                "session": path.name,
-            }
-            state = meter.recompute_claude(source)
-
-        self.assertTrue(state["availability"]["cost"])
-        self.assertFalse(state["cost_approx"])
-        self.assertGreater(state["total_cost"], 0)
-        self.assertEqual(len(state["executions"]), 1)
-
-    def test_unknown_model_keeps_cache_money_unavailable(self):
-        record = {
-            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
-            "message": {
-                "id": "msg-1", "content": [],
-                "usage": {
-                    "input_tokens": 10, "cache_creation_input_tokens": 5_000,
-                    "cache_read_input_tokens": 5_000, "output_tokens": 10,
-                },
-                "stop_reason": "end_turn",
-            },
-        }
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_text(json.dumps(record) + "\n")
-            source = {
-                **self.source("claude"), "path": str(path),
-                "session": path.name,
-            }
-            state = meter.recompute_claude(source)
-
-        self.assertFalse(state["availability"]["cost"])
-        self.assertTrue(state["availability"]["cache"])
-        self.assertEqual(state["cache"]["total"], 10_000)
-        self.assertIsNone(state["cache"]["saved"])
-        self.assertIsNone(state["cache"]["cost"])
-        self.assertIsNone(state["cache_saved"])
-
-    def claude_source_without_title(self):
-        return {
-            "id": "session", "path": "/tmp/session.jsonl", "provider": "claude",
-            "client": "claude", "label": "Claude", "project": "/repo",
-            "mtime": 1, "title": None, "model": None,
-        }
-
-    def claude_usage_row(self, ts="2026-07-02T00:00:00.000Z"):
-        return {
-            "type": "assistant", "timestamp": ts,
-            "message": {
-                "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
-                "usage": {"input_tokens": 10, "output_tokens": 5},
-                "stop_reason": "end_turn",
-            },
-        }
-
-    def test_claude_summary_prefers_custom_title_record_over_prompt_heuristic(self):
-        objs = [
-            {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
-             "message": {"content": "What does this function do?"}},
-            self.claude_usage_row(),
-            {"type": "custom-title", "customTitle": "release-triage",
-             "sessionId": "session"},
-        ]
-        row = meter.claude_summary(self.claude_source_without_title(), objs)
-        self.assertEqual(row["title"], "release-triage")
-        self.assertEqual(row["session_name"], "release-triage")
-
-    def test_claude_summary_counts_loaded_and_used_skills_and_mcp_servers(self):
-        usage = self.claude_usage_row()
-        usage["message"]["content"] = [
-            {"type": "tool_use", "id": "t1", "name": "Skill", "input": {"skill": "brainstorming"}},
-            {"type": "tool_use", "id": "t2", "name": "mcp__context7__query-docs", "input": {}},
-            {"type": "tool_use", "id": "t3", "name": "mcp__webex__webex_rooms", "input": {}},
-        ]
-        objs = [
-            {"type": "attachment", "attachment": {
-                "type": "skill_listing", "isInitial": True, "skillCount": 3,
-                "names": ["brainstorming", "pdf", "docx"],
-                "content": "PRIVATE SKILL LISTING TEXT"}},
-            {"type": "attachment", "attachment": {
-                "type": "deferred_tools_delta", "addedLines": ["PRIVATE LINE"],
-                "addedNames": ["CronCreate", "mcp__context7__query-docs",
-                               "mcp__context7__resolve-library-id", "mcp__outlook__outlook_send"],
-                "removedNames": []}},
-            {"type": "attachment", "attachment": {
-                "type": "mcp_instructions_delta", "addedNames": ["context7"],
-                "addedBlocks": ["PRIVATE INSTRUCTIONS"], "removedNames": []}},
-            usage,
-        ]
-        row = meter.claude_summary(self.claude_source_without_title(), objs)
-        self.assertEqual(row["capabilities"], {
-            "skills": {"loaded": 3, "used": 1},
-            "mcp_servers": {"loaded": 3, "used": 2},
-        })
-        self.assertNotIn("PRIVATE", json.dumps(row["capabilities"]))
-        self.assertNotIn("PRIVATE", json.dumps(
-            {k: v for k, v in row.items() if not k.startswith("_")}, default=str,
-        ))
-
-    def test_claude_session_state_counts_capabilities_from_main_trace(self):
-        usage = self.claude_usage_row()
-        usage["message"]["content"] = [
-            {"type": "tool_use", "id": "t1", "name": "mcp__docs__search", "input": {}},
-        ]
-        records = [
-            {"type": "attachment", "attachment": {
-                "type": "skill_listing", "names": ["pdf", "docx"], "content": "PRIVATE"}},
-            {"type": "attachment", "attachment": {
-                "type": "deferred_tools_delta", "addedNames": ["mcp__jira__get"]}},
-            usage,
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "claude-capabilities.jsonl"
-            path.write_text("".join(json.dumps(record) + "\n" for record in records))
-            state = meter.recompute_claude({
-                **self.source("claude"), "path": str(path), "session": path.name,
-            })
-        self.assertEqual(state["capabilities"], {
-            "skills": {"loaded": 2, "used": 0, "basis": "session"},
-            "mcp_servers": {"loaded": 2, "used": 1, "basis": "session"},
-        })
-        self.assertNotIn("PRIVATE", json.dumps(meter.dashboard_state_payload(state), default=str))
-
-    def test_codex_skill_listing_and_namespaced_mcp_calls_are_counted(self):
-        from token_meter.runtimes.codex import codex_mcp_tool_name, _loaded_skill_names
-        objs = [
-            {"type": "world_state", "payload": {"state": {"host_skills": {
-                "body": "- pdf: PRIVATE (file: /h/.codex/skills/pdf/SKILL.md)\n"
-                        "- docx: PRIVATE (file: /h/.codex/skills/docx/SKILL.md)"}}}},
-            {"type": "response_item", "payload": {"type": "message", "role": "developer", "content": [
-                {"type": "input_text", "text": "<skills_instructions>- xlsx (file: /p/skills/xlsx/SKILL.md)</skills_instructions>"},
-            ]}},
-        ]
-        self.assertEqual(_loaded_skill_names(objs, meter.skill_names_from_value), {"pdf", "docx", "xlsx"})
-        self.assertIsNone(_loaded_skill_names([], meter.skill_names_from_value))
-        self.assertEqual(codex_mcp_tool_name("js", "mcp__cua_repl"), "mcp__cua_repl__js")
-        self.assertEqual(codex_mcp_tool_name("exec", None), "exec")
-        calls = meter.codex_tool_call_evidence([{"timestamp": "2026-07-02T00:00:00Z", "payload": {
-            "type": "function_call", "name": "js", "namespace": "mcp__cua_repl", "call_id": "c1", "arguments": "{}",
-        }}])
-        self.assertEqual((calls[0]["kind"], calls[0]["namespace"]), ("mcp", "cua_repl"))
-
-    def test_configured_capabilities_fill_unrecorded_loads_with_label(self):
-        with mock.patch.object(meter, "configured_capabilities", return_value=({"a", "b", "c"}, set())):
-            result = meter.with_configured_capabilities({
-                "skills": {"loaded": None, "used": 1},
-                "mcp_servers": {"loaded": None, "used": 2},
-            }, "cursor", "/repo")
-        self.assertEqual(result, {
-            "skills": {"loaded": 3, "used": 1, "basis": "configured"},
-            "mcp_servers": {"loaded": 2, "used": 2, "basis": "configured"},
-        })
-        with mock.patch.object(meter, "configured_capabilities", return_value=(None, None)):
-            result = meter.with_configured_capabilities({
-                "skills": {"loaded": 9, "used": 1}, "mcp_servers": {"loaded": None, "used": 0},
-            }, "kiro", "")
-        self.assertEqual(result["skills"], {"loaded": 9, "used": 1, "basis": "session"})
-        self.assertEqual(result["mcp_servers"], {"loaded": None, "used": 0, "basis": "unavailable"})
-
-    def test_cursor_configured_capabilities_read_skill_dirs_and_mcp_json(self):
-        with tempfile.TemporaryDirectory() as home, tempfile.TemporaryDirectory() as project:
-            for root, name in (("skills", "pdf"), ("skills-cursor", "canvas")):
-                path = Path(home) / ".cursor" / root / name
-                path.mkdir(parents=True)
-                (path / "SKILL.md").write_text("x")
-            (Path(home) / ".cursor" / "mcp.json").write_text(json.dumps({"mcpServers": {"docs": {}, "jira": {}}}))
-            (Path(project) / ".cursor").mkdir()
-            (Path(project) / ".cursor" / "mcp.json").write_text(json.dumps({"mcpServers": {"local": {}}}))
-            with mock.patch.dict(os.environ, {"HOME": home}):
-                skills, servers = meter._scan_configured_capabilities("cursor", project)
-        self.assertEqual(skills, {"pdf", "canvas"})
-        self.assertEqual(servers, {"docs", "jira", "local"})
-
-    def test_claude_summary_without_load_records_keeps_loaded_unknown(self):
-        row = meter.claude_summary(self.claude_source_without_title(), [self.claude_usage_row()])
-        self.assertEqual(row["capabilities"], {
-            "skills": {"loaded": None, "used": 0},
-            "mcp_servers": {"loaded": None, "used": 0},
-        })
-
-    def test_session_capabilities_uses_codex_catalog_mcp_namespaces(self):
-        from token_meter.domain.tools import session_capabilities
-        evidence = {
-            "skills": [],
-            "tools": [{"name": "mcp__docs__search", "namespace": "docs", "kind": "mcp"}],
-            "catalog": [
-                {"name": "mcp__docs__search", "namespace": "docs", "kind": "mcp"},
-                {"name": "mcp__jira__get", "namespace": "jira", "kind": "mcp"},
-                {"name": "exec_command", "namespace": "shell", "kind": "tool"},
-            ],
-        }
-        self.assertEqual(session_capabilities(evidence), {
-            "skills": {"loaded": None, "used": 0},
-            "mcp_servers": {"loaded": 2, "used": 1},
-        })
-        self.assertEqual(session_capabilities({"catalog": [
-            {"name": "exec_command", "namespace": "shell", "kind": "tool"},
-        ]})["mcp_servers"], {"loaded": None, "used": 0})
-
-    def test_claude_summary_uses_ai_title_when_no_custom_title(self):
-        objs = [
-            self.claude_usage_row(),
-            {"type": "ai-title", "aiTitle": "Process codex reviews for issue #40",
-             "sessionId": "session"},
-        ]
-        row = meter.claude_summary(self.claude_source_without_title(), objs)
-        self.assertEqual(row["title"], "Process codex reviews for issue #40")
-        self.assertEqual(row["session_name"], "Process codex reviews for issue #40")
-
-    def test_claude_summary_desktop_title_outranks_custom_and_ai_title(self):
-        source = self.claude_source_without_title()
-        source["title"] = "Desktop sidecar title"
-        objs = [
-            self.claude_usage_row(),
-            {"type": "custom-title", "customTitle": "release-triage",
-             "sessionId": "session"},
-            {"type": "ai-title", "aiTitle": "Process codex reviews",
-             "sessionId": "session"},
-        ]
-        row = meter.claude_summary(source, objs)
-        self.assertEqual(row["title"], "Desktop sidecar title")
-        self.assertEqual(row["session_name"], "Desktop sidecar title")
-
-    def test_claude_summary_keeps_last_custom_title_when_multiple_records(self):
-        objs = [
-            self.claude_usage_row(),
-            {"type": "custom-title", "customTitle": "first-name",
-             "sessionId": "session"},
-            {"type": "custom-title", "customTitle": "second-name",
-             "sessionId": "session"},
-        ]
-        row = meter.claude_summary(self.claude_source_without_title(), objs)
-        self.assertEqual(row["title"], "second-name")
-        self.assertEqual(row["session_name"], "second-name")
-
-    def test_claude_summary_falls_back_to_untitled_when_no_declared_title_and_no_human_prompt(self):
-        objs = [
-            self.claude_usage_row(),
-            {"type": "user", "isMeta": True,
-             "timestamp": "2026-07-02T00:00:00.000Z",
-             "message": {"content": "Base directory for this skill: /Users/pat"}},
-        ]
-        row = meter.claude_summary(self.claude_source_without_title(), objs)
-        self.assertEqual(row["title"], "(untitled log)")
-        self.assertEqual(row["session_name"], "")
-
-    def test_claude_summary_prompt_fallback_title_does_not_populate_session_name(self):
-        objs = [
-            self.claude_usage_row(),
-            {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
-             "message": {"content": "What does this function do?"}},
-        ]
-        row = meter.claude_summary(self.claude_source_without_title(), objs)
-        self.assertEqual(row["title"], "What does this function do?")
-        self.assertEqual(row["session_name"], "")
-
-    def test_codex_summary_carries_live_throughput_into_current_sessions(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-01T00:00:00.000Z",
-             "payload": {"type": "task_started"}},
-            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 200, "output_tokens": 40, "total_tokens": 240,
-                }},
-            }},
-        ]
-
-        row = meter.codex_summary(self.source("codex", "gpt-5.6"), objs)
-
-        self.assertFalse(row["throughput"]["available"])
-        self.assertIn("live_throughput", row)
-        self.assertEqual(row["live_throughput"]["output_tps"], 10)
-        self.assertEqual(row["live_throughput"]["completed_steps"], 1)
-
-    def test_codex_summary_records_the_last_reply_not_later_bookkeeping(self):
-        import calendar
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z", "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 200, "output_tokens": 40, "total_tokens": 240}}}},
-            # Resuming the session later writes context lines but no reply.
-            {"type": "turn_context", "timestamp": "2026-07-01T05:00:00.000Z", "payload": {"model": "gpt-5.6"}},
-        ]
-        row = meter.codex_summary(self.source("codex", "gpt-5.6"), objs)
-        self.assertEqual(row["last_activity_ts"], calendar.timegm((2026, 7, 1, 0, 0, 4)))
-        self.assertIsNone(meter.codex_summary(self.source("codex", "gpt-5.6"), objs[:1])["last_activity_ts"])
-
-    def test_codex_summary_keeps_missing_model_pricing_unavailable(self):
-        row = meter.codex_summary(self.source("codex"), [{
-            "timestamp": "2026-07-02T00:00:01.000Z",
-            "payload": {"type": "token_count", "info": {"last_token_usage": {
-                "input_tokens": 100_000, "output_tokens": 1_000,
-                "total_tokens": 101_000,
-            }}},
-        }])
-
-        self.assertEqual(row["primary_model"], "unknown-model")
-        self.assertFalse(row["availability"]["cost"])
-        self.assertEqual(row["cost"], 0.0)
-
-    def test_codex_summary_keeps_priced_model_coverage_in_mixed_session(self):
-        row = meter.codex_summary(self.source("codex", "gpt-5.6"), [
-            {"type": "turn_context", "timestamp": "2026-07-02T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6"}},
-            {"timestamp": "2026-07-02T00:00:01.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100, "output_tokens": 20, "total_tokens": 120,
-                }},
-            }},
-            {"type": "turn_context", "timestamp": "2026-07-02T00:00:02.000Z",
-             "payload": {"model": "unknown-model"}},
-            {"timestamp": "2026-07-02T00:00:03.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100, "output_tokens": 30, "total_tokens": 130,
-                }},
-            }},
-        ])
-
-        self.assertFalse(row["availability"]["cost"])
-        stats = {item["model"]: item for item in row["model_stats"]}
-        self.assertTrue(stats["gpt-5.6"]["availability"]["cost"])
-        self.assertEqual(stats["gpt-5.6"]["cost_covered_executions"], 1)
-        self.assertEqual(stats["gpt-5.6"]["cost_covered_output_tokens"], 20)
-        self.assertFalse(stats["unknown-model"]["availability"]["cost"])
-        self.assertEqual(stats["unknown-model"]["cost_covered_executions"], 0)
-        daily = {item["model"]: item for item in row["_model_daily"]}
-        self.assertTrue(daily["gpt-5.6"]["availability"]["cost"])
-        self.assertFalse(daily["unknown-model"]["availability"]["cost"])
-
-        aggregate = {
-            item["model"]: item for item in meter.aggregate_model_stats([row])["models"]
-        }
-        self.assertTrue(aggregate["gpt-5.6"]["availability"]["cost"])
-        self.assertEqual(aggregate["gpt-5.6"]["cost_covered_executions"], 1)
-        self.assertEqual(aggregate["gpt-5.6"]["cost_covered_output_tokens"], 20)
-        self.assertTrue(aggregate["gpt-5.6"]["daily"][0]["availability"]["cost"])
-        self.assertEqual(
-            aggregate["gpt-5.6"]["daily"][0]["cost_covered_output_tokens"], 20,
-        )
-        self.assertFalse(aggregate["unknown-model"]["availability"]["cost"])
-
-    def test_codex_summary_exposes_input_output_and_model_stats(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-02T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6", "effort": "xhigh"}},
-            {"timestamp": "2026-07-02T00:00:00.500Z", "payload": {
-                "type": "task_started", "model_context_window": 200000,
-            }},
-            {"timestamp": "2026-07-02T00:00:01.000Z", "payload": {
-                "type": "token_count", "info": {"model_context_window": 200000,
-                                                "last_token_usage": {
-                    "input_tokens": 100, "cached_input_tokens": 40,
-                    "output_tokens": 20, "reasoning_output_tokens": 8,
-                    "total_tokens": 120,
-                }},
-            }},
-            {"timestamp": "2026-07-02T00:00:02.000Z", "payload": {
-                "type": "task_complete",
-            }},
-        ]
-        row = meter.codex_summary(self.source("codex", "gpt-5.6"), objs)
-        self.assertEqual(row["input_tokens"], 100)
-        self.assertEqual(row["output_tokens"], 20)
-        self.assertEqual(row["model_stats"][0]["model"], "gpt-5.6")
-        self.assertEqual(row["model_stats"][0]["tokens"], 120)
-        self.assertEqual(row["model_stats"][0]["reasoning_tokens"], 8)
-        self.assertEqual(row["model_stats"][0]["reasoning_output_tokens"], 20)
-        self.assertEqual(row["model_stats"][0]["reasoning_executions"], 1)
-        self.assertEqual(row["model_stats"][0]["reasoning_unavailable_executions"], 0)
-        self.assertEqual(row["primary_model"], "gpt-5.6")
-        self.assertEqual(row["reasoning_effort"], "xhigh")
-        self.assertEqual(row["session_name"], "Summary stats")
-        self.assertEqual(row["context"]["latest"], 100)
-        self.assertEqual(row["context"]["window"], 200000)
-        self.assertEqual(row["context"]["latest_pct"], 0.0005)
-        self.assertEqual(row["_context_samples"], [100])
-        self.assertTrue(row["terminal"])
-        self.assertEqual(row["usage_basis"], "reported")
-
-    def test_codex_summary_prices_each_usage_event_across_a_cutover(self):
-        objs = [
-            {"type": "turn_context", "timestamp": "2026-07-30T00:00:00.000Z",
-             "payload": {"model": "gpt-5.6-terra"}},
-            {"timestamp": "2026-07-30T00:00:01.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100_000, "output_tokens": 100_000,
-                    "total_tokens": 200_000,
-                }},
-            }},
-            {"timestamp": "2026-07-31T00:00:00.000Z", "payload": {
-                "type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100_000, "output_tokens": 100_000,
-                    "total_tokens": 200_000,
-                }},
-            }},
-        ]
-        row = meter.codex_summary(self.source("codex", "gpt-5.6-terra"), objs)
-        self.assertAlmostEqual(row["cost"], 4.9)
-        self.assertEqual(len(row["_day_cost"]), 2)
-        for actual, expected in zip(sorted(row["_day_cost"].values()), (1.4, 3.5)):
-            self.assertAlmostEqual(actual, expected)
-        self.assertAlmostEqual(row["_model_cost"]["gpt-5.6-terra"], 4.9)
-
-
-class CodexLineageAccountingTests(unittest.TestCase):
-    def setUp(self):
-        self.temp = tempfile.TemporaryDirectory()
-        self.root = Path(self.temp.name)
-        self.sessions = self.root / "sessions"
-        self.trace_root = self.sessions / "2026" / "08" / "11"
-        self.trace_root.mkdir(parents=True)
-        self.index = self.root / "session_index.jsonl"
-        self.index.write_text("")
-        self.context = DiscoveryContext(home=str(self.root))
-        self.adapter = CodexRuntimeAdapter(
-            self.sessions,
-            self.index,
-            compatibility=meter._codex_compatibility(),
-            default_model="gpt-5.6",
-        )
-
-    def tearDown(self):
-        self.temp.cleanup()
-
-    def write_trace(self, name, rows, mtime):
-        path = self.trace_root / f"rollout-{name}.jsonl"
-        path.write_text("".join(json.dumps(row) + "\n" for row in rows))
-        os.utime(path, (mtime, mtime))
-        return path
-
-    @staticmethod
-    def meta(physical_id, logical_id="task-1", **extra):
-        return {
-            "timestamp": "2026-08-11T00:00:00.000Z",
-            "type": "session_meta",
-            "payload": {
-                "id": physical_id,
-                "session_id": logical_id,
-                "cwd": "/work/project",
-                **extra,
-            },
-        }
-
-    @staticmethod
-    def turn(timestamp):
-        return {
-            "timestamp": timestamp.replace("Z", ".000Z"),
-            "type": "turn_context",
-            "payload": {"model": "gpt-5.6", "cwd": "/work/project"},
-        }
-
-    @staticmethod
-    def tool(name, call_id, timestamp):
-        return {
-            "timestamp": timestamp.replace("Z", ".000Z"),
-            "type": "response_item",
-            "payload": {
-                "type": "function_call",
-                "name": name,
-                "call_id": call_id,
-                "arguments": {},
-            },
-        }
-
-    @staticmethod
-    def tokens(input_tokens, output_tokens, total_input, total_output, timestamp):
-        return {
-            "timestamp": timestamp.replace("Z", ".000Z"),
-            "type": "event_msg",
-            "payload": {"type": "token_count", "info": {
-                "last_token_usage": {
-                    "input_tokens": input_tokens,
-                    "output_tokens": output_tokens,
-                    "total_tokens": input_tokens + output_tokens,
-                },
-                "total_token_usage": {
-                    "input_tokens": total_input,
-                    "output_tokens": total_output,
-                    "total_tokens": total_input + total_output,
-                },
-            }},
-        }
-
-    def root_and_child_sources(self):
-        self.write_trace("root", [
-            self.meta("root-1"),
-            self.turn("2026-08-11T00:00:01Z"),
-            {"timestamp": "2026-08-11T00:00:01.000Z", "type": "event_msg",
-             "payload": {"type": "task_started"}},
-            self.tool("inherited_tool", "inherited-call", "2026-08-11T00:00:02Z"),
-            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:03Z"),
-            {"timestamp": "2026-08-11T00:00:04.000Z", "type": "event_msg",
-             "payload": {"type": "task_complete", "duration_ms": 3000}},
-        ], 10)
-        self.write_trace("child", [
-            self.meta("child-1", forked_from_id="root-1"),
-            self.meta("root-1"),
-            self.turn("2026-08-11T01:00:01Z"),
-            {"timestamp": "2026-08-11T01:00:01.000Z", "type": "event_msg",
-             "payload": {"type": "task_started"}},
-            self.tool("inherited_tool", "inherited-call", "2026-08-11T01:00:02Z"),
-            self.tokens(100, 10, 100, 10, "2026-08-11T01:00:03Z"),
-            {"timestamp": "2026-08-11T01:00:04.000Z", "type": "event_msg",
-             "payload": {"type": "task_complete", "duration_ms": 3000}},
-            self.turn("2026-08-11T02:00:01Z"),
-            {"timestamp": "2026-08-11T02:00:01.000Z", "type": "event_msg",
-             "payload": {"type": "task_started"}},
-            self.tool("child_tool", "child-call", "2026-08-11T02:00:02Z"),
-            self.tokens(50, 5, 150, 15, "2026-08-11T02:00:03Z"),
-        ], 20)
-        return {
-            source["physical_trace_id"]: source
-            for source in self.adapter.discover_legacy(self.context)
-        }
-
-    def root_child_and_grandchild_sources(self):
-        self.root_and_child_sources()
-        self.write_trace("grandchild", [
-            self.meta("grandchild-1", forked_from_id="child-1"),
-            self.turn("2026-08-11T03:00:01Z"),
-            {"timestamp": "2026-08-11T03:00:01.000Z", "type": "event_msg",
-             "payload": {"type": "task_started"}},
-            self.tool("inherited_tool", "inherited-call", "2026-08-11T03:00:02Z"),
-            self.tokens(100, 10, 100, 10, "2026-08-11T03:00:03Z"),
-            {"timestamp": "2026-08-11T03:00:04.000Z", "type": "event_msg",
-             "payload": {"type": "task_complete", "duration_ms": 3000}},
-            self.turn("2026-08-11T04:00:01Z"),
-            {"timestamp": "2026-08-11T04:00:01.000Z", "type": "event_msg",
-             "payload": {"type": "task_started"}},
-            self.tool("child_tool", "child-call", "2026-08-11T04:00:02Z"),
-            self.tokens(50, 5, 150, 15, "2026-08-11T04:00:03Z"),
-            {"timestamp": "2026-08-11T04:00:04.000Z", "type": "event_msg",
-             "payload": {"type": "task_complete", "duration_ms": 3000}},
-            self.turn("2026-08-11T05:00:01Z"),
-            {"timestamp": "2026-08-11T05:00:01.000Z", "type": "event_msg",
-             "payload": {"type": "task_started"}},
-            self.tool("grandchild_tool", "grandchild-call", "2026-08-11T05:00:02Z"),
-            self.tokens(20, 2, 170, 17, "2026-08-11T05:00:03Z"),
-        ], 30)
-        return {
-            source["physical_trace_id"]: source
-            for source in self.adapter.discover_legacy(self.context)
-        }
-
-    def test_legacy_detail_and_summary_use_the_same_corrected_child_rows(self):
-        sources = self.root_and_child_sources()
-
-        detail = self.adapter.recompute_legacy(sources["child-1"])
-        summary = self.adapter.summarize_legacy(sources["child-1"])
-
-        self.assertEqual(detail["total_tokens"], 55)
-        self.assertEqual(summary["tokens"], 55)
-        self.assertEqual(detail["total_tokens"], summary["tokens"])
-        self.assertAlmostEqual(detail["total_cost"], summary["cost"])
-        self.assertEqual(len(detail["executions"]), 1)
-        self.assertEqual(summary["turns"], 1)
-        self.assertEqual(
-            [tool["name"] for tool in detail["executions"][0]["tools"]],
-            ["child_tool"],
-        )
-        self.assertNotIn("complete", [event["kind"] for event in detail["trace"]])
-
-    def test_live_and_completed_throughput_use_only_corrected_child_rows(self):
-        sources = self.root_and_child_sources()
-
-        summary = self.adapter.summarize_legacy(sources["child-1"])
-
-        self.assertFalse(summary["throughput"]["available"])
-        self.assertTrue(summary["live_throughput"]["available"])
-        self.assertEqual(summary["live_throughput"]["completed_steps"], 1)
-        self.assertEqual(summary["live_throughput"]["measured_output_tokens"], 5)
-        self.assertEqual(summary["live_throughput"]["measured_seconds"], 2)
-        self.assertEqual(summary["live_throughput"]["output_tps"], 2.5)
-
-    def test_auto_review_child_inherits_its_linked_parent_model(self):
-        self.write_trace("parent", [
-            self.meta("parent-1"),
-            self.turn("2026-08-11T00:00:01Z"),
-        ], 10)
-        self.write_trace("auto-review", [
-            self.meta("auto-review-1", parent_thread_id="parent-1"),
-            {
-                "timestamp": "2026-08-11T01:00:01.000Z",
-                "type": "turn_context",
-                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
-            },
-            self.tokens(100, 10, 100, 10, "2026-08-11T01:00:02Z"),
-        ], 20)
-
-        sources = {
-            source["physical_trace_id"]: source
-            for source in self.adapter.discover_legacy(self.context)
-        }
-        native = next(
-            source for source in self.adapter.discover(self.context)
-            if source.locator.value.endswith("rollout-auto-review.jsonl")
-        )
-        detail = self.adapter.recompute_legacy(sources["auto-review-1"])
-        summary = self.adapter.summarize_legacy(sources["auto-review-1"])
-
-        self.assertEqual(sources["auto-review-1"]["model"], "gpt-5.6")
-        self.assertEqual(native.model_ref.model_id, "gpt-5.6")
-        self.assertEqual(detail["primary_model"], "gpt-5.6")
-        self.assertTrue(detail["availability"]["cost"])
-        self.assertGreater(detail["total_cost"], 0)
-        self.assertEqual(summary["primary_model"], "gpt-5.6")
-        self.assertTrue(summary["availability"]["cost"])
-        self.assertGreater(summary["cost"], 0)
-
-    def test_auto_review_child_without_a_linked_parent_stays_unknown(self):
-        self.write_trace("orphaned-auto-review", [
-            self.meta("orphaned-auto-review-1", parent_thread_id="missing-parent"),
-            {
-                "timestamp": "2026-08-11T01:00:01.000Z",
-                "type": "turn_context",
-                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
-            },
-        ], 20)
-
-        source = self.adapter.discover_legacy(self.context)[0]
-
-        self.assertEqual(source["model"], "unknown-model")
-
-    def test_auto_review_fork_without_a_desktop_parent_stays_unknown(self):
-        self.write_trace("parent", [
-            self.meta("parent-1"),
-            self.turn("2026-08-11T00:00:01Z"),
-        ], 10)
-        self.write_trace("forked-auto-review", [
-            self.meta("forked-auto-review-1", forked_from_id="parent-1"),
-            {
-                "timestamp": "2026-08-11T01:00:01.000Z",
-                "type": "turn_context",
-                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
-            },
-        ], 20)
-
-        sources = {
-            source["physical_trace_id"]: source
-            for source in self.adapter.discover_legacy(self.context)
-        }
-
-        self.assertEqual(sources["forked-auto-review-1"]["model"], "unknown-model")
-
-    def test_auto_review_child_with_a_cyclic_parent_stays_unknown(self):
-        self.write_trace("auto-review", [
-            self.meta("auto-review-1", parent_thread_id="parent-1"),
-            {
-                "timestamp": "2026-08-11T01:00:01.000Z",
-                "type": "turn_context",
-                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
-            },
-        ], 10)
-        self.write_trace("parent", [
-            self.meta("parent-1", parent_thread_id="auto-review-1"),
-            {
-                "timestamp": "2026-08-11T01:00:02.000Z",
-                "type": "turn_context",
-                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
-            },
-        ], 20)
-
-        sources = {
-            source["physical_trace_id"]: source
-            for source in self.adapter.discover_legacy(self.context)
-        }
-
-        self.assertEqual(sources["auto-review-1"]["model"], "unknown-model")
-
-    def test_auto_review_child_deduplicates_an_inherited_parent_token_row(self):
-        self.write_trace("parent", [
-            self.meta("parent-1"),
-            self.turn("2026-08-11T00:00:01Z"),
-            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:02Z"),
-        ], 10)
-        self.write_trace("auto-review", [
-            self.meta("auto-review-1", parent_thread_id="parent-1"),
-            {
-                "timestamp": "2026-08-11T01:00:01.000Z",
-                "type": "turn_context",
-                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
-            },
-            self.tokens(100, 10, 100, 10, "2026-08-11T01:00:02Z"),
-        ], 20)
-
-        sources = {
-            source["physical_trace_id"]: source
-            for source in self.adapter.discover_legacy(self.context)
-        }
-        summary = self.adapter.summarize_legacy(sources["auto-review-1"])
-
-        self.assertEqual(summary["tokens"], 0)
-        self.assertEqual(summary["turns"], 0)
-
-    def test_history_scan_rows_match_cross_session_internal_rows(self):
-        self.write_trace("root", [
-            self.meta("root-1"),
-            self.turn("2026-08-11T00:00:01Z"),
-            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:03Z"),
-        ], 10)
-        self.write_trace("root-resumed", [
-            self.meta("root-1"),
-            self.turn("2026-08-11T05:00:01Z"),
-            self.tokens(40, 4, 140, 14, "2026-08-11T05:00:03Z"),
-        ], 30)
-        self.write_trace("spawned", [
-            self.meta("spawned-1", parent_thread_id="root-1"),
-            self.turn("2026-08-11T06:00:01Z"),
-            self.tokens(20, 2, 20, 2, "2026-08-11T06:00:03Z"),
-        ], 40)
-        self.write_trace("empty", [self.meta("empty-1", logical_id="task-2")], 50)
-        sources = list(self.adapter.discover_legacy(self.context))
-        saved_xsess = dict(meter._xsess)
-        saved_summaries = dict(meter._summary_cache)
-
-        def key(row):
-            return (row["session"], row["turns"], row["tokens"], round(row["cost"], 9))
-
-        try:
-            meter._xsess.update({"data": None, "at": 0, "sessions": [], "internal_rows": (),
-                                 "project_model_stats": {}})
-            meter._summary_cache.clear()
-            with mock.patch.object(meter, "_codex_native_adapter", return_value=self.adapter):
-                meter.cross_session(sources=sources)
-                expected = [key(row) for row in meter._xsess["internal_rows"]]
-            meter._xsess.update({"data": None, "at": 0, "internal_rows": ()})
-            meter._summary_cache.clear()
-            with mock.patch.object(meter, "_codex_native_adapter", return_value=self.adapter), \
-                    mock.patch.object(meter, "all_session_sources", return_value=sources), \
-                    mock.patch.dict(meter._history_scan, {"progress": None, "last_complete": None}):
-                rows, coverage = meter.agent_history_rows(time.monotonic() + 10)
-                self.assertTrue(meter._history_scan["progress"]["done"].wait(10))
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_xsess)
-            meter._summary_cache.clear()
-            meter._summary_cache.update(saved_summaries)
-
-        self.assertTrue(coverage["complete"])
-        self.assertEqual(coverage["sessions_total"], coverage["sessions_scanned"])
-        self.assertEqual(len(expected), 3)
-        self.assertEqual([key(row) for row in rows], expected)
-
-    def test_all_session_rows_are_one_per_trace_file_with_exact_keys(self):
-        self.write_trace("root", [
-            self.meta("root-1"),
-            self.turn("2026-08-11T00:00:01Z"),
-            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:03Z"),
-        ], 10)
-        self.write_trace("root-resumed", [
-            self.meta("root-1"),
-            self.turn("2026-08-11T05:00:01Z"),
-            self.tokens(40, 4, 140, 14, "2026-08-11T05:00:03Z"),
-        ], 30)
-        self.write_trace("spawned", [
-            self.meta("spawned-1", parent_thread_id="root-1"),
-            self.turn("2026-08-11T06:00:01Z"),
-            self.tokens(20, 2, 20, 2, "2026-08-11T06:00:03Z"),
-        ], 40)
-        sources = list(self.adapter.discover_legacy(self.context))
-        self.assertEqual({source["id"] for source in sources}, {"task-1"})
-        saved_xsess = dict(meter._xsess)
-        saved_summaries = dict(meter._summary_cache)
-        try:
-            meter._xsess.update({
-                "data": None, "at": 0, "sessions": [], "internal_rows": (),
-                "project_model_stats": {},
-            })
-            meter._summary_cache.clear()
-            with mock.patch.object(meter, "_codex_native_adapter", return_value=self.adapter):
-                result = meter.cross_session(sources=sources)
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_xsess)
-            meter._summary_cache.clear()
-            meter._summary_cache.update(saved_summaries)
-
-        rows = result["sessions"]
-        self.assertEqual(len(rows), 3)
-        self.assertEqual({row["id"] for row in rows}, {"task-1"})
-        keys = {row["session"] for row in rows}
-        self.assertEqual(keys, {
-            "rollout-root.jsonl", "rollout-root-resumed.jsonl", "rollout-spawned.jsonl",
-        })
-        self.assertEqual(sum(row["tokens"] for row in rows), result["total_tokens"])
-        self.assertEqual(result["total_tokens"], 176)
-        self.assertAlmostEqual(sum(row["cost"] for row in rows), result["total_cost"])
-        by_key = {row["session"]: row for row in rows}
-        self.assertTrue(by_key["rollout-spawned.jsonl"].get("subagent"))
-        self.assertNotIn("subagent", by_key["rollout-root.jsonl"])
-        for row in rows:
-            resolved = meter.find_session(row["session"], sources=sources)
-            self.assertEqual(resolved["path"], row["path"])
-
-    def test_cross_session_daily_models_spend_and_budget_share_corrected_totals(self):
-        sources = self.root_child_and_grandchild_sources()
-        saved_xsess = dict(meter._xsess)
-        saved_summaries = dict(meter._summary_cache)
-        budget_now = datetime.datetime(2026, 8, 11, tzinfo=datetime.timezone.utc)
-        original_budget_status = meter.monthly_budget_status
-        try:
-            meter._xsess.update({
-                "data": None,
-                "at": 0,
-                "sessions": [],
-                "internal_rows": (),
-                "project_model_stats": {},
-            })
-            meter._summary_cache.clear()
-            with mock.patch.object(
-                meter, "_codex_native_adapter", return_value=self.adapter,
-            ), mock.patch.object(
-                meter,
-                "monthly_budget_status",
-                side_effect=lambda months, settings: original_budget_status(
-                    months, settings, now=budget_now,
-                ),
-            ):
-                result = meter.cross_session(sources=list(sources.values()))
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_xsess)
-            meter._summary_cache.clear()
-            meter._summary_cache.update(saved_summaries)
-
-        self.assertEqual(result["total_tokens"], 187)
-        self.assertEqual(result["total_executions"], 3)
-        self.assertAlmostEqual(
-            result["total_cost"],
-            sum(session["cost"] for session in result["sessions"]),
-        )
-        self.assertEqual(sum(
-            row["input_tokens"] + row["output_tokens"]
-            for row in result["model_stats"]["models"]
-        ), 187)
-        self.assertEqual(sum(row["tokens"] for row in result["daily"]), 187)
-        self.assertAlmostEqual(
-            sum(row["cost"] for row in result["daily"]),
-            result["total_cost"],
-        )
-        self.assertAlmostEqual(
-            sum(row["cost"] for row in result["spend"]["days"]),
-            result["total_cost"],
-        )
-        self.assertAlmostEqual(
-            sum(row["cost"] for row in result["monthly"]),
-            result["total_cost"],
-        )
-        self.assertEqual(result["budget"]["month"], "2026-08")
-        self.assertAlmostEqual(result["budget"]["spend"], result["total_cost"])
-        encoded = json.dumps(result)
-        for private_field in (
-            "physical_trace_id",
-            "logical_session_id",
-            "forked_from_id",
-            "parent_thread_id",
-            "lineage_parent_id",
-            "lineage_revision",
-        ):
-            self.assertNotIn(private_field, encoded)
-
-    def test_legacy_cache_signature_changes_with_lineage_revision(self):
-        source = {
-            "path": str(self.trace_root / "rollout-child.jsonl"),
-            "mtime": 10,
-            "title": "Child",
-            "lineage_revision": ("unresolved", "parent-1"),
-        }
-
-        before = meter.source_revision_signature(source)
-        after = meter.source_revision_signature({
-            **source,
-            "lineage_revision": ("resolved", "parent-1", "1", "2"),
-        })
-
-        self.assertNotEqual(before, after)
-
-
-class CurrentSessionSummaryTests(unittest.TestCase):
-    def row(self, session_id, mtime, **overrides):
-        row = {
-            "id": session_id,
-            "path": f"/private/traces/{session_id}.jsonl",
-            "title": f"private prompt for {session_id}",
-            "provider": "codex",
-            "client": "codex",
-            "runtime": "Codex",
-            "label": "Codex",
-            "project": "/Users/person/secret/repository",
-            "session_name": f"Session {session_id}",
-            "primary_model": "gpt-5.6",
-            "reasoning_effort": "xhigh",
-            "models": ["gpt-5.6"],
-            "cost": 1.25,
-            "cost_approx": True,
-            "availability": {"cost": True, "context": True},
-            "usage_basis": "reported",
-            "context": {
-                "latest": 50000, "window": 200000,
-                "latest_pct": 0.25, "estimated": False,
-            },
-            "_context_samples": [20000, 35000, 50000],
-            "turns": 3,
-            "mtime": mtime,
-            "terminal": False,
-            "throughput": {
-                "available": True, "output_tps": 24.5, "basis": "tool_free",
-            },
-        }
-        row.update(overrides)
-        return row
-
-    def test_opening_a_session_without_a_new_reply_does_not_make_it_live(self):
-        now = 50_000
-        opened = self.row("opened", now - 5, last_activity_ts=now - 3 * 3600)  # file touched, last reply hours ago
-        replying = self.row("replying", now - 5, last_activity_ts=now - 20)
-        quiet = self.row("quiet", now - 5, last_activity_ts=now - 600)
-        no_replies_yet = self.row("brand-new", now - 5)  # no reply recorded: the trace time still counts
-        result = {row["id"]: row for row in meter.current_session_summaries(
-            [opened, replying, quiet, no_replies_yet], now=now)}
-        self.assertNotIn("opened", result)
-        self.assertEqual(result["replying"]["activity_state"], "working")
-        self.assertEqual((result["quiet"]["activity_state"], result["quiet"]["idle_s"]), ("recent", 600))
-        self.assertIn("brand-new", result)
-
-    def test_filters_orders_limits_and_sanitizes_card_rows(self):
-        now = 10_000
-        rows = [
-            self.row(f"session-{index}", now - index * 10)
-            for index in range(10)
-        ]
-        rows.append(self.row("too-old", now - meter.CURRENT_SESSION_MAX_AGE_S - 1))
-        result = meter.current_session_summaries(rows, now=now)
-
-        self.assertEqual([row["id"] for row in result], [f"session-{index}" for index in range(10)])
-        self.assertEqual(result[0]["project"], "repository")
-        self.assertEqual(result[0]["session_name"], "Session session-0")
-        self.assertEqual(result[0]["reasoning_effort"], "xhigh")
-        self.assertEqual(result[0]["throughput"]["output_tps"], 24.5)
-        self.assertIsNone(result[0]["output_per_dollar"])
-        self.assertEqual(result[0]["context"]["samples"], [20000, 35000, 50000])
-        self.assertNotIn("_context_samples", result[0])
-        self.assertNotIn("path", result[0])
-        self.assertNotIn("title", result[0])
-        self.assertNotIn("private prompt", json.dumps(result))
-        self.assertNotIn("/Users/person", json.dumps(result))
-
-    def test_returns_every_live_session_up_to_the_payload_ceiling(self):
-        now = 10_000
-        rows = [
-            self.row(f"session-{index}", now - index)
-            for index in range(meter.CURRENT_SESSION_LIMIT + 5)
-        ]
-        result = meter.current_session_summaries(rows, now=now)
-
-        self.assertGreater(meter.CURRENT_SESSION_LIMIT, 8)
-        self.assertEqual(len(result), meter.CURRENT_SESSION_LIMIT)
-        self.assertEqual(result[0]["id"], "session-0")
-
-    def test_projects_output_per_covered_dollar_without_model_details(self):
-        row = self.row(
-            "mixed-coverage", 49_990,
-            availability={
-                "cost": False, "tokens": True, "output_tokens": True,
-                "context": True,
-            },
-            model_stats=[
-                {
-                    "model": "priced-model", "cost_covered_executions": 2,
-                    "cost_covered_output_tokens": 600,
-                    "cost_covered_cost": 2.0,
-                },
-                {
-                    "model": "unpriced-model", "cost_covered_executions": 0,
-                    "cost_covered_output_tokens": 0,
-                    "cost_covered_cost": 0.0,
-                },
-            ],
-        )
-
-        result = meter.current_session_summaries([row], now=50_000)[0]
-
-        self.assertEqual(result["output_per_dollar"], 300.0)
-        self.assertTrue(result["availability"]["output_per_dollar"])
-        self.assertNotIn("model_stats", result)
-        self.assertNotIn("priced-model", json.dumps(result))
-
-    def test_projects_only_valid_claude_desktop_resume_ids(self):
-        resumable = self.row("resumable", 49_990)
-        resumable["desktop_resume_id"] = "0f9f0062-51be-4131-acfa-51034ef23f99"
-        forged = self.row("forged", 49_980)
-        forged["desktop_resume_id"] = "0f9f0062-51be-4131-acfa-51034ef23f99&q=x"
-        plain = self.row("plain", 49_970)
-        results = {
-            row["id"]: row
-            for row in meter.current_session_summaries([resumable, forged, plain], now=50_000)
-        }
-        self.assertEqual(results["resumable"]["desktop_resume_id"], "0f9f0062-51be-4131-acfa-51034ef23f99")
-        self.assertIsNone(results["forged"]["desktop_resume_id"])
-        self.assertIsNone(results["plain"]["desktop_resume_id"])
-
-    def test_projects_bounded_capability_counts_with_unknown_loads(self):
-        known = self.row("known", 49_990)
-        known["capabilities"] = {
-            "skills": {"loaded": 75, "used": 2, "names": ["private"]},
-            "mcp_servers": {"loaded": 20, "used": 1},
-        }
-        unknown = self.row("unknown", 49_980)
-        results = {row["id"]: row for row in meter.current_session_summaries([known, unknown], now=50_000)}
-        self.assertEqual(results["known"]["capabilities"], {
-            "skills": {"loaded": 75, "used": 2, "basis": "unavailable"},
-            "mcp_servers": {"loaded": 20, "used": 1, "basis": "unavailable"},
-        })
-        self.assertEqual(results["unknown"]["capabilities"], {
-            "skills": {"loaded": None, "used": 0, "basis": "unavailable"},
-            "mcp_servers": {"loaded": None, "used": 0, "basis": "unavailable"},
-        })
-
-    def test_output_per_dollar_requires_output_and_nonzero_cost_evidence(self):
-        rows = [
-            self.row(
-                "missing-output", 59_990, output_tokens=250,
-                availability={"cost": True, "output_tokens": False, "context": True},
-            ),
-            self.row(
-                "zero-cost", 59_980, cost=0.0, output_tokens=250,
-                availability={"cost": True, "output_tokens": True, "context": True},
-            ),
-            self.row(
-                "covered", 59_970, cost=2.0, output_tokens=250,
-                availability={"cost": True, "output_tokens": True, "context": True},
-            ),
-        ]
-
-        result = {
-            row["id"]: row
-            for row in meter.current_session_summaries(rows, now=60_000)
-        }
-
-        self.assertIsNone(result["missing-output"]["output_per_dollar"])
-        self.assertFalse(result["missing-output"]["availability"]["output_per_dollar"])
-        self.assertIsNone(result["zero-cost"]["output_per_dollar"])
-        self.assertFalse(result["zero-cost"]["availability"]["output_per_dollar"])
-        self.assertEqual(result["covered"]["output_per_dollar"], 125.0)
-        self.assertTrue(result["covered"]["availability"]["output_per_dollar"])
-
-    def test_uses_working_waiting_and_recent_activity_states(self):
-        now = 20_000
-        rows = [
-            self.row("working", now - 10, terminal=False),
-            self.row("waiting", now - 20, terminal=True),
-            self.row("recent", now - meter.CURRENT_SESSION_WORKING_S - 1, terminal=False),
-        ]
-        result = {
-            row["id"]: row
-            for row in meter.current_session_summaries(rows, now=now)
-        }
-        self.assertEqual(result["working"]["activity_state"], "working")
-        self.assertEqual(result["waiting"]["activity_state"], "waiting")
-        self.assertEqual(result["recent"]["activity_state"], "recent")
-        self.assertEqual(result["working"]["context"]["latest_pct"], 0.25)
-
-    def test_duplicate_session_segments_prefer_active_work(self):
-        now = 25_000
-        rows = [
-            self.row("resumed", now - 15, terminal=False, turns=8),
-            self.row("resumed", now - 5, terminal=True, turns=120),
-        ]
-        result = meter.current_session_summaries(rows, now=now)
-        self.assertEqual(len(result), 1)
-        self.assertEqual(result[0]["id"], "resumed")
-        self.assertEqual(result[0]["activity_state"], "working")
-        self.assertEqual(result[0]["turns"], 8)
-
-    def test_keeps_context_tokens_without_inventing_a_window(self):
-        row = self.row(
-            "claude-session", 29_990, provider="claude", client="claude_code",
-            runtime="Claude Code", context={
-                "latest": 118000, "window": None,
-                "latest_pct": None, "estimated": False,
-            },
-        )
-        result = meter.current_session_summaries([row], now=30_000)[0]
-        self.assertEqual(result["context"]["latest"], 118000)
-        self.assertIsNone(result["context"]["window"])
-        self.assertIsNone(result["context"]["latest_pct"])
-
-    def test_context_samples_are_numeric_recent_and_bounded(self):
-        row = self.row(
-            "long-session", 39_990,
-            _context_samples=[*range(40), "invalid", -1, None],
-        )
-        result = meter.current_session_summaries([row], now=40_000)[0]
-        self.assertEqual(len(result["context"]["samples"]),
-                         meter.CURRENT_SESSION_CONTEXT_SAMPLES)
-        self.assertEqual(result["context"]["samples"], list(range(8, 40)))
-        self.assertTrue(all(isinstance(value, int)
-                            for value in result["context"]["samples"]))
-
-
-class SelectedSessionStateCacheTests(unittest.TestCase):
-    def test_reuses_unchanged_state_and_recomputes_after_trace_append(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_text('{"type":"session_meta"}\n')
-            source = {
-                "provider": "codex", "id": "session", "path": str(path),
-                "mtime": path.stat().st_mtime,
-            }
-            meter._session_state_cache.clear()
-            calls = []
-
-            def build(_source):
-                calls.append(len(calls) + 1)
-                return {"source": {"id": "session"}, "version": calls[-1]}
-
-            try:
-                with mock.patch.object(meter, "recompute", side_effect=build):
-                    first = meter.cached_session_state(source)
-                    first["version"] = 99
-                    second = meter.cached_session_state(source)
-                    path.write_text(path.read_text() + '{"type":"event"}\n')
-                    third = meter.cached_session_state(source)
-            finally:
-                meter._session_state_cache.clear()
-
-        self.assertEqual(calls, [1, 2])
-        self.assertEqual(second["version"], 1)
-        self.assertEqual(third["version"], 2)
-
-    def test_concurrent_misses_share_one_recompute(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_text('{"type":"session_meta"}\n')
-            source = {
-                "provider": "codex", "id": "session", "path": str(path),
-                "mtime": path.stat().st_mtime,
-            }
-            meter._session_state_cache.clear()
-            calls = []
-            started = threading.Event()
-            release = threading.Event()
-
-            def build(_source):
-                calls.append(1)
-                started.set()
-                release.wait(5)
-                return {"source": {"id": "session"}}
-
-            results = []
-            try:
-                with mock.patch.object(meter, "recompute", side_effect=build):
-                    threads = [
-                        threading.Thread(
-                            target=lambda: results.append(meter.cached_session_state(source))
-                        )
-                        for _ in range(8)
-                    ]
-                    threads[0].start()
-                    started.wait(5)
-                    # A live transcript grows while later pollers queue.
-                    with path.open("a") as handle:
-                        handle.write('{"type":"event"}\n')
-                    for thread in threads[1:]:
-                        thread.start()
-                    time.sleep(0.2)
-                    release.set()
-                    for thread in threads:
-                        thread.join(5)
-            finally:
-                meter._session_state_cache.clear()
-                meter._session_state_build_locks.clear()
-
-        self.assertEqual(len(calls), 1)
-        self.assertEqual(results, [{"source": {"id": "session"}}] * 8)
-
-
-class SessionRouteTests(unittest.TestCase):
-    def test_dashboard_accepts_root_and_unique_session_paths(self):
-        self.assertTrue(meter.is_dashboard_page_path("/"))
-        self.assertTrue(meter.is_dashboard_page_path("/sessions/019f16fa-dc6c-7a62-839c-25c15dca4e75"))
-        self.assertTrue(meter.is_dashboard_page_path("/sessions/claude%20session/"))
-
-    def test_dashboard_rejects_api_nested_and_empty_session_paths(self):
-        self.assertFalse(meter.is_dashboard_page_path("/session"))
-        self.assertFalse(meter.is_dashboard_page_path("/sessions/"))
-        self.assertFalse(meter.is_dashboard_page_path("/sessions/one/two"))
-
-    def test_dashboard_serves_only_explicitly_bundled_assets(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            page = root / "page.html"
-            font = root / "assets" / "fonts" / "Tektur-Variable.ttf"
-            logo = root / "assets" / "brand" / "logo-splunk-by-cisco-rgb-w.png"
-            effects = root / "assets" / "session-effects.js"
-            dithering = root / "assets" / "vendor" / "paper-shaders" / "shaders" / "dithering.js"
-            pulsing_border = root / "assets" / "vendor" / "paper-shaders" / "shaders" / "pulsing-border.js"
-            font.parent.mkdir(parents=True)
-            logo.parent.mkdir(parents=True)
-            effects.parent.mkdir(parents=True, exist_ok=True)
-            dithering.parent.mkdir(parents=True)
-            page.write_text("dashboard")
-            font.write_bytes(b"font")
-            logo.write_bytes(b"logo")
-            effects.write_text("export {}")
-            dithering.write_text("export {}")
-            pulsing_border.write_text("export {}")
-            with mock.patch.object(meter, "page_path", return_value=str(page)):
-                self.assertEqual(
-                    meter.dashboard_asset_path("/assets/fonts/Tektur-Variable.ttf"),
-                    str(font),
-                )
-                self.assertEqual(
-                    meter.dashboard_asset_path("/assets/brand/logo-splunk-by-cisco-rgb-w.png"),
-                    str(logo),
-                )
-                self.assertEqual(
-                    meter.dashboard_asset_content_type("/assets/fonts/Tektur-Variable.ttf"),
-                    "font/ttf",
-                )
-                self.assertEqual(
-                    meter.dashboard_asset_content_type("/assets/brand/logo-splunk-by-cisco-rgb-w.png"),
-                    "image/png",
-                )
-                self.assertEqual(
-                    meter.dashboard_asset_path("/assets/session-effects.js"),
-                    str(effects),
-                )
-                self.assertIsNone(meter.dashboard_asset_path(
-                    "/assets/vendor/paper-shaders/shaders/dithering.js"
-                ))
-                self.assertEqual(
-                    meter.dashboard_asset_path(
-                        "/assets/vendor/paper-shaders/shaders/pulsing-border.js"
-                    ),
-                    str(pulsing_border),
-                )
-                self.assertEqual(
-                    meter.dashboard_asset_content_type("/assets/session-effects.js"),
-                    "text/javascript; charset=utf-8",
-                )
-                self.assertIsNone(meter.dashboard_asset_path("/assets/fonts/OFL-Tektur.txt"))
-                self.assertIsNone(meter.dashboard_asset_path("/assets/brand/SOURCE.md"))
-                self.assertIsNone(meter.dashboard_asset_path(
-                    "/assets/vendor/paper-shaders/shaders/neuro-noise.js"
-                ))
-                self.assertIsNone(meter.dashboard_asset_path(
-                    "/assets/vendor/paper-shaders/shaders/god-rays.js"
-                ))
-                self.assertIsNone(meter.dashboard_asset_path("/assets/../meter.py"))
-
-
-class SessionTraceKeyProjectionTests(unittest.TestCase):
-    def test_spend_logs_and_current_sessions_carry_the_trace_key(self):
-        rows = [
-            {"id": "task-1", "session": "rollout-a.jsonl", "provider": "codex",
-             "_day_cost": {"2026-08-11": 2.0}, "mtime": 990, "turns": 1},
-            {"id": "task-1", "session": "rollout-b.jsonl", "provider": "codex",
-             "_day_cost": {"2026-08-11": 3.0}, "mtime": 995, "turns": 1},
-        ]
-        spend = meter.spend_log_summaries(rows, "2026-08-01", "2026-08-31")
-        self.assertEqual(
-            sorted(row["session"] for row in spend),
-            ["rollout-a.jsonl", "rollout-b.jsonl"],
-        )
-        current = meter.current_session_summaries(rows, now=1000)
-        self.assertEqual([row["session"] for row in current], ["rollout-b.jsonl"])
-
-
-class SessionDeleteTests(unittest.TestCase):
-    def test_moves_only_exact_discovered_jsonl_to_trash(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            source_dir = Path(tmp) / "logs"
-            trash_dir = Path(tmp) / "Trash"
-            source_dir.mkdir()
-            path = source_dir / "session-one.jsonl"
-            path.write_text('{"type":"test"}\n')
-            source = {
-                "id": "session-one", "session": path.name, "path": str(path),
-                "provider": "codex", "project": "/repo", "title": "One", "mtime": 1,
-            }
-            result = meter.trash_session_log("session-one", sources=[source], trash_dir=str(trash_dir))
-            trashed = trash_dir / result["trash_name"]
-            self.assertTrue(result["ok"])
-            self.assertFalse(path.exists())
-            self.assertTrue(trashed.exists())
-            self.assertEqual(trashed.read_text(), '{"type":"test"}\n')
-            self.assertNotIn(str(path), json.dumps(result))
-
-    def test_rejects_alias_and_unknown_session_ids(self):
-        source = {
-            "id": "canonical", "session": "alias.jsonl", "path": "/tmp/alias.jsonl",
-            "provider": "codex", "project": "/repo", "mtime": 1,
-        }
-        self.assertEqual(meter.trash_session_log("alias.jsonl", sources=[source])["error_code"], "not_found")
-        self.assertEqual(meter.trash_session_log("missing", sources=[source])["error_code"], "not_found")
-
-    def test_rejects_ambiguous_logical_id_without_deleting_either_trace(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            canonical = root / "canonical.jsonl"
-            duplicate = root / "duplicate.jsonl"
-            canonical.write_text('{}\n')
-            duplicate.write_text('{}\n')
-            source = {
-                "id": "shared", "session": canonical.name,
-                "path": str(canonical), "provider": "claude",
-                "project": "/repo", "mtime": 2,
-                "_aggregation_key": "claude:shared",
-                "_aggregation_canonical": True,
-                "_duplicate_paths": (str(canonical), str(duplicate)),
-            }
-
-            result = meter.trash_session_log(
-                "shared", sources=[source], trash_dir=str(root / "Trash")
-            )
-
-            self.assertFalse(result["ok"])
-            self.assertEqual(result["error_code"], "ambiguous_id")
-            self.assertTrue(canonical.exists())
-            self.assertTrue(duplicate.exists())
-
-    def rollout_pair(self, root):
-        first, second = root / "rollout-a.jsonl", root / "rollout-b.jsonl"
-        first.write_text('{"a":1}\n')
-        second.write_text('{"b":1}\n')
-        sources = [
-            {"id": "shared", "session": first.name, "path": str(first),
-             "provider": "codex", "project": "/repo", "mtime": 5},
-            {"id": "shared", "session": second.name, "path": str(second),
-             "provider": "codex", "project": "/repo", "mtime": 1},
-        ]
-        return first, second, sources
-
-    def test_logical_id_spanning_rollouts_is_ambiguous_without_trace(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            first, second, sources = self.rollout_pair(root)
-
-            result = meter.trash_session_log(
-                "shared", sources=sources, trash_dir=str(root / "Trash"),
-            )
-
-            self.assertEqual(result["error_code"], "ambiguous_id")
-            self.assertTrue(first.exists())
-            self.assertTrue(second.exists())
-
-    def test_trace_key_moves_exactly_the_selected_rollout(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            first, second, sources = self.rollout_pair(root)
-
-            result = meter.trash_session_log(
-                "shared", trace="rollout-b.jsonl", sources=sources,
-                trash_dir=str(root / "Trash"),
-            )
-
-            self.assertTrue(result["ok"])
-            self.assertTrue(first.exists())
-            self.assertFalse(second.exists())
-
-    def test_trace_key_must_belong_to_the_session_id(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            first, second, sources = self.rollout_pair(root)
-            for session_id, trace in (("other", "rollout-b.jsonl"), ("shared", "rollout-c.jsonl"),
-                                      ("shared", "../rollout-b.jsonl")):
-                result = meter.trash_session_log(
-                    session_id, trace=trace, sources=sources,
-                    trash_dir=str(root / "Trash"),
-                )
-                self.assertEqual(result["error_code"], "not_found")
-            self.assertTrue(first.exists())
-            self.assertTrue(second.exists())
-
-    def test_trace_key_longer_than_the_bound_is_rejected(self):
-        result = meter.trash_session_log("shared", trace="x" * 241, sources=[])
-        self.assertEqual(result["error_code"], "invalid_id")
-
-    def test_delete_route_checks_the_provider_of_the_exact_trace(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            first, second, sources = self.rollout_pair(root)
-            sources[1]["provider"] = "opencode"
-            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
-                    mock.patch.object(meter, "trash_session_log",
-                                      return_value={"ok": True}) as trash:
-                refused = meter.request_session_delete("shared", "rollout-b.jsonl")
-                allowed = meter.request_session_delete("shared", "rollout-a.jsonl")
-            self.assertEqual(refused["error_code"], "read_only_provider")
-            self.assertTrue(allowed["ok"])
-            trash.assert_called_once_with("shared", sources=sources, trace="rollout-a.jsonl")
-            self.assertTrue(first.exists())
-            self.assertTrue(second.exists())
-
-    def test_id_only_delete_of_a_read_only_multi_file_session_reports_read_only(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            first, second, sources = self.rollout_pair(Path(tmp))
-            for source in sources:
-                source["provider"] = "opencode"
-            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
-                    mock.patch.object(meter, "trash_session_log") as trash:
-                result = meter.request_session_delete("shared")
-            self.assertEqual(result["error_code"], "read_only_provider")
-            trash.assert_not_called()
-            self.assertTrue(first.exists())
-            self.assertTrue(second.exists())
-
-    def test_id_only_delete_of_a_mixed_provider_session_stays_ambiguous(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            first, second, sources = self.rollout_pair(root)
-            sources[1]["provider"] = "opencode"
-            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
-                    mock.patch.object(meter, "trash_session_log",
-                                      return_value={"ok": True}) as trash:
-                result = meter.request_session_delete("shared")
-            self.assertEqual(result["error_code"], "ambiguous_id")
-            trash.assert_not_called()
-            self.assertTrue(first.exists())
-            self.assertTrue(second.exists())
-
-    def test_delete_route_forwards_the_trace_key(self):
-        source = (Path(meter.__file__).resolve().parent / "token_meter" / "app.py").read_text()
-        self.assertIn(
-            'request_session_delete(payload.get("session_id"), payload.get("trace"))', source,
-        )
-
-    def test_trace_delete_keeps_the_claude_duplicate_guard(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            canonical, duplicate = root / "canonical.jsonl", root / "duplicate.jsonl"
-            canonical.write_text("{}\n")
-            duplicate.write_text("{}\n")
-            source = {
-                "id": "shared", "session": canonical.name, "path": str(canonical),
-                "provider": "claude", "project": "/repo", "mtime": 2,
-                "_aggregation_key": "claude:shared", "_aggregation_canonical": True,
-                "_duplicate_paths": (str(canonical), str(duplicate)),
-            }
-            result = meter.trash_session_log(
-                "shared", trace=canonical.name, sources=[source],
-                trash_dir=str(root / "Trash"),
-            )
-            self.assertEqual(result["error_code"], "ambiguous_id")
-            self.assertTrue(canonical.exists())
-            self.assertTrue(duplicate.exists())
-
-    def test_cursor_delete_moves_only_transcript_and_preserves_shared_database(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            transcript = root / "projects" / "repo" / "agent-transcripts" / "cursor-one" / "cursor-one.jsonl"
-            transcript.parent.mkdir(parents=True)
-            transcript.write_text('{"role":"user"}\n')
-            database = root / "state.vscdb"
-            database.write_bytes(b"shared cursor database")
-            source = {
-                "id": "cursor-one", "session": transcript.name, "path": str(transcript),
-                "provider": "cursor", "project": "/repo", "title": "Cursor", "mtime": 1,
-            }
-            result = meter.trash_session_log(
-                "cursor-one", sources=[source], trash_dir=str(root / "Trash")
-            )
-            self.assertTrue(result["ok"])
-            self.assertFalse(transcript.exists())
-            self.assertTrue(database.exists())
-            self.assertEqual(database.read_bytes(), b"shared cursor database")
-
-    def test_publish_after_delete_selects_newest_remaining_session(self):
-        sources = [{"id": "older", "path": "/tmp/older.jsonl", "mtime": 1},
-                   {"id": "newer", "path": "/tmp/newer.jsonl", "mtime": 2}]
-        published = []
-        with mock.patch.object(meter, "all_session_sources", return_value=sources), \
-                mock.patch.object(meter, "cross_session", return_value={"sessions": []}), \
-                mock.patch.object(meter, "recompute", return_value={"source": {"id": "newer"}}), \
-                mock.patch.object(meter, "publish", side_effect=published.append):
-            selected = meter.publish_after_session_delete()
-        self.assertEqual(selected, "newer")
-        self.assertEqual(published[0]["source"]["id"], "newer")
-
-
-class LiveCrossSessionRefreshTests(unittest.TestCase):
-    def test_membership_probe_uses_two_seconds_with_a_four_second_fallback(self):
-        self.assertFalse(meter.source_membership_probe_due(2.99, 1.0))
-        self.assertTrue(meter.source_membership_probe_due(3.0, 1.0))
-        self.assertFalse(meter.source_membership_fallback_due(4.99, 1.0))
-        self.assertTrue(meter.source_membership_fallback_due(5.0, 1.0))
-
-    def test_full_source_metadata_discovery_retains_the_ten_second_cadence(self):
-        self.assertTrue(meter.source_discovery_refresh_due(False, 1.0, 0.0))
-        self.assertFalse(meter.source_discovery_refresh_due(True, 10.99, 1.0))
-        self.assertTrue(meter.source_discovery_refresh_due(True, 11.0, 1.0))
-
-    def test_inventory_probe_ignores_active_growth_and_detects_a_resume(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            active = root / "project" / "active.jsonl"
-            inactive = root / "project" / "inactive.jsonl"
-            active.parent.mkdir()
-            active.write_text("{}\n")
-            inactive.write_text("{}\n")
-            sources = [
-                {"path": str(active), "provider": "codex"},
-                {"path": str(inactive), "provider": "codex"},
-            ]
-            targets = meter.source_inventory_probe_targets(
-                sources, roots=[str(root)], extra_files=[],
-            )
-            before = meter.source_inventory_probe_signature(
-                targets, current_path=str(active),
-            )
-
-            with active.open("a") as handle:
-                handle.write("{}\n")
-            active_only = meter.source_inventory_probe_signature(
-                targets, current_path=str(active),
-            )
-            with inactive.open("a") as handle:
-                handle.write("{}\n")
-            resumed = meter.source_inventory_probe_signature(
-                targets, current_path=str(active),
-            )
-
-        self.assertEqual(active_only, before)
-        self.assertNotEqual(resumed, before)
-
-    def test_inventory_probe_detects_a_new_nested_session_path(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            existing = root / "project" / "existing.jsonl"
-            existing.parent.mkdir()
-            existing.write_text("{}\n")
-            targets = meter.source_inventory_probe_targets(
-                [{"path": str(existing), "provider": "claude"}],
-                roots=[str(root)], extra_files=[],
-            )
-            before = meter.source_inventory_probe_signature(targets)
-
-            new_session = root / "project" / "new.jsonl"
-            new_session.write_text("{}\n")
-            after = meter.source_inventory_probe_signature(targets)
-
-        self.assertNotEqual(after, before)
-
-    def test_known_source_activity_refreshes_without_adapter_discovery(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            active_path = Path(tmp) / "active.jsonl"
-            inactive_path = Path(tmp) / "inactive.jsonl"
-            active_path.write_text("{}\n")
-            inactive_path.write_text("{}\n")
-            os.utime(active_path, (20, 20))
-            os.utime(inactive_path, (20, 20))
-            sources = [
-                {
-                    "provider": "codex", "id": "active",
-                    "path": str(active_path), "mtime": 10,
-                },
-                {
-                    "provider": "codex", "id": "inactive",
-                    "path": str(inactive_path), "mtime": 10,
-                },
-            ]
-
-            refreshed = meter.refresh_known_source_activity(
-                sources, current_path=str(active_path),
-            )
-
-        self.assertEqual(refreshed[0]["mtime"], 20)
-        self.assertEqual(refreshed[1]["mtime"], 10)
-        self.assertEqual(sources[0]["mtime"], 10)
-
-    def test_unchanged_known_activity_reuses_the_inventory_object(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            active_path = Path(tmp) / "active.jsonl"
-            active_path.write_text("{}\n")
-            os.utime(active_path, (20, 20))
-            sources = [{
-                "provider": "codex", "id": "active",
-                "path": str(active_path), "mtime": 20,
-            }]
-
-            refreshed = meter.refresh_known_source_activity(
-                sources, current_path=str(active_path),
-            )
-
-        self.assertIs(refreshed, sources)
-
-    def test_current_session_rebuilds_immediately_then_coalesces_changes(self):
-        initial = (100, 20)
-        changed = (101, 21)
-
-        self.assertTrue(meter.current_session_refresh_due(
-            initial, None, 10.0, 0.0,
-        ))
-        self.assertFalse(meter.current_session_refresh_due(
-            changed, initial, 11.49, 10.0,
-        ))
-        self.assertTrue(meter.current_session_refresh_due(
-            changed, initial, 11.5, 10.0,
-        ))
-        self.assertFalse(meter.current_session_refresh_due(
-            initial, initial, 20.0, 10.0,
-        ))
-
-    def test_session_detail_reuses_cached_cross_session_snapshot(self):
-        handler = object.__new__(meter.H)
-        handler.path = "/session?id=session-1"
-        handler.headers = {"Host": "127.0.0.1:8722"}
-        sent = []
-        handler._send = lambda body, *_args, **_kwargs: sent.append(json.loads(body))
-        cached = {"current_sessions": []}
-        rebuilder = mock.Mock(return_value={"current_sessions": []})
-        state = {"source": {"id": "session-1"}, "timing": {}}
-        source = {"id": "session-1", "path": "/logs/exact.jsonl"}
-        summary = {
-            "model_stats": [{"model": "exact-model", "executions": 2}],
-            "usage_basis": "reported",
-            "provenance": {"usage_basis": "reported"},
-        }
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["data"] = cached
-            with mock.patch.object(meter, "find_session", return_value=source), \
-                    mock.patch.object(meter, "cached_session_state", return_value=state), \
-                    mock.patch.object(meter, "session_summary", return_value=summary) as selected_summary, \
-                    mock.patch.object(meter, "cross_session", rebuilder), \
-                    mock.patch.object(meter, "attach_cross_session") as attach:
-                handler.do_GET()
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        rebuilder.assert_not_called()
-        attach.assert_called_once_with(state, cached)
-        selected_summary.assert_called_once_with(source)
-        self.assertEqual(sent[0]["selected_stats"], summary)
-
-    def test_full_sse_queue_keeps_subscriber_and_coalesces_to_latest_state(self):
-        q_ = meter.queue.Queue(maxsize=2)
-        q_.put_nowait("stale-one")
-        q_.put_nowait("stale-two")
-        self.assertTrue(meter.enqueue_latest(q_, "latest"))
-        self.assertEqual(q_.qsize(), 1)
-        self.assertEqual(q_.get_nowait(), "latest")
-
-    def test_source_signature_changes_when_a_background_log_changes(self):
-        before = meter.source_mtime_signature([
-            {"path": "/logs/current.jsonl", "mtime": 20},
-            {"path": "/logs/background.jsonl", "mtime": 10},
-        ])
-        after = meter.source_mtime_signature([
-            {"path": "/logs/current.jsonl", "mtime": 20},
-            {"path": "/logs/background.jsonl", "mtime": 11},
-        ])
-        self.assertNotEqual(before, after)
-
-    def test_session_membership_bypasses_the_cross_session_refresh_throttle(self):
-        before = meter.source_identity_signature([
-            {"id": "current", "provider": "codex", "path": "/logs/current.jsonl"},
-        ])
-        after = meter.source_identity_signature([
-            {"id": "current", "provider": "codex", "path": "/logs/current.jsonl"},
-            {"id": "new", "provider": "claude", "path": "/logs/new.jsonl"},
-        ])
-
-        self.assertNotEqual(before, after)
-        self.assertTrue(meter.cross_session_refresh_due(True, True, 10.1, 10.0))
-        self.assertFalse(meter.cross_session_refresh_due(True, False, 10.1, 10.0))
-        self.assertFalse(meter.cross_session_refresh_due(True, False, 24.9, 10.0))
-        self.assertTrue(meter.cross_session_refresh_due(True, False, 25.0, 10.0))
-
-    def test_publishing_inventory_evicts_only_disappeared_summary_paths(self):
-        cache = {
-            "/logs/live.jsonl": {"signature": (1, ""), "row": {"id": "live"}},
-            "/logs/stale.jsonl": {"signature": (1, ""), "row": {"id": "stale"}},
-        }
-        saved_inventory = dict(meter._SOURCE_INVENTORY)
-        try:
-            with mock.patch.object(meter, "_summary_cache", cache), \
-                    mock.patch.object(meter, "_RUNTIME_DISCOVERY_FAILURES", ()):
-                meter.publish_source_inventory([
-                    {"path": "/logs/live.jsonl", "provider": "codex"},
-                ])
-        finally:
-            meter._SOURCE_INVENTORY.clear()
-            meter._SOURCE_INVENTORY.update(saved_inventory)
-
-        self.assertEqual(list(cache), ["/logs/live.jsonl"])
-
-    def test_partial_discovery_failure_preserves_missing_summary_paths(self):
-        cache = {
-            "/logs/live.jsonl": {"signature": (1, ""), "row": {"id": "live"}},
-            "/logs/temporarily-missing.jsonl": {
-                "signature": (1, ""), "row": {"id": "missing"},
-            },
-        }
-        saved_inventory = dict(meter._SOURCE_INVENTORY)
-        try:
-            with mock.patch.object(meter, "_summary_cache", cache), \
-                    mock.patch.object(meter, "_RUNTIME_DISCOVERY_FAILURES", (object(),)):
-                meter.publish_source_inventory([
-                    {"path": "/logs/live.jsonl", "provider": "codex"},
-                ])
-        finally:
-            meter._SOURCE_INVENTORY.clear()
-            meter._SOURCE_INVENTORY.update(saved_inventory)
-
-        self.assertEqual(
-            list(cache), ["/logs/live.jsonl", "/logs/temporarily-missing.jsonl"],
-        )
-
-    def test_cross_session_refresh_replaces_cached_snapshot_before_publish(self):
-        saved_cache = dict(meter._xsess)
-        published = []
-        fresh = {"sessions": [{"id": "fresh"}], "capabilities": {}}
-        state = {"provider": "codex", "tools": {}, "source": {"id": "current"}}
-        try:
-            meter._xsess["data"], meter._xsess["at"] = {"sessions": [{"id": "stale"}]}, 123
-            result = meter.refresh_cross_session_state(
-                state, builder=lambda: fresh, publisher=published.append,
-            )
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertIs(result, fresh)
-        self.assertEqual(published[0]["xsession"]["sessions"][0]["id"], "fresh")
-
-    def test_logs_inventory_keeps_full_rows_beyond_state_preview(self):
-        saved_cache = dict(meter._xsess)
-        preview = [{"id": "recent"}]
-        full = [{"id": "recent"}, {"id": "older-claude", "client": "claude_code"}]
-        try:
-            meter._xsess.update({
-                "data": {"generated_at": 123, "sessions": preview, "total_sessions": 2},
-                "at": meter.time.time(),
-                "sessions": full,
-            })
-            result = meter.log_sessions_state()
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertEqual(result["sessions"], full)
-        self.assertEqual(result["total_sessions"], 2)
-        self.assertEqual(result["generated_at"], 123)
-
-    def test_logs_inventory_replaces_trace_paths_with_opaque_keys(self):
-        from token_meter.domain.compare import trace_key
-        saved_cache = dict(meter._xsess)
-        private = "/Users/private-user/.claude/projects/p/abc.jsonl"
-        full = [{"id": "abc", "path": private, "project": "~/p"}, {"id": "no-path"}]
-        try:
-            meter._xsess.update({
-                "data": {"generated_at": 1, "sessions": full[:1], "total_sessions": 2},
-                "at": meter.time.time(),
-                "sessions": full,
-            })
-            result = meter.log_sessions_state()
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertNotIn("private-user", json.dumps(result))
-        self.assertNotIn("path", result["sessions"][0])
-        self.assertEqual(result["sessions"][0]["key"], trace_key({"path": private}))
-        self.assertEqual(result["sessions"][0]["project"], "~/p")
-        self.assertEqual(result["sessions"][1], {"id": "no-path"})
-        self.assertEqual(full[0]["path"], private)
-
-    def test_logs_inventory_returns_loading_without_rebuilding_cold_history(self):
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess.update({"data": None, "at": 0, "sessions": []})
-            with mock.patch.object(
-                meter, "cross_session",
-                side_effect=AssertionError("logs request must not rebuild cold history"),
-            ):
-                result = meter.log_sessions_state()
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertTrue(result["loading"])
-        self.assertIsNone(result["total_sessions"])
-        self.assertEqual(result["sessions"], [])
-
-    def test_cross_session_separates_runtime_models_and_reported_alert_basis(self):
-        def row(source):
-            estimated = source["provider"] == "cursor"
-            cost = 2.0 if estimated else 1.0
-            tokens = 200 if estimated else 100
-            return {
-                **source, "turns": 1, "cost": cost, "tokens": tokens,
-                "input_tokens": tokens - 10, "output_tokens": 10,
-                "models": ["gpt-5.6"], "token_estimate": estimated,
-                "availability": meter.metric_availability(
-                    source["provider"], cost=True, tokens=True,
-                    input_tokens=True, output_tokens=True,
-                ),
-                "_model_cost": {"gpt-5.6": cost}, "_model_tok": {"gpt-5.6": tokens},
-                "_day_cost": {"2026-07-20": cost}, "model_stats": [],
-                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
-                "_tool_evidence": {},
-            }
-
-        sources = [
-            {"id": "codex", "path": "/tmp/codex", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/repo", "mtime": 2},
-            {"id": "cursor", "path": "/tmp/cursor", "provider": "cursor",
-             "runtime": "Cursor", "label": "Cursor", "project": "/repo", "mtime": 1},
-        ]
-        rows = {source["id"]: row(source) for source in sources}
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["data"], meter._xsess["at"] = None, 0
-            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
-                    mock.patch.object(meter, "session_summary",
-                                      side_effect=lambda source: rows[source["id"]]), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                result = meter.cross_session()
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertEqual({item["id"] for item in result["model_mix"]},
-                         {"gpt-5.6::Codex", "gpt-5.6::Cursor"})
-        self.assertEqual(result["usage_basis"], "mixed")
-        self.assertEqual(result["reported_cost"], 1.0)
-        self.assertEqual(result["estimated_cost"], 2.0)
-        self.assertEqual(result["trend"][0]["reported_cost"], 1.0)
-        self.assertEqual(result["trend"][0]["anomaly_basis"], "reported_only")
-
-    def test_cross_session_counts_adapter_owned_duplicate_identity_once(self):
-        def row(source):
-            return {
-                **source, "turns": 1, "cost": 1.0, "tokens": 100,
-                "input_tokens": 90, "output_tokens": 10,
-                "models": ["claude-test"], "token_estimate": False,
-                "availability": meter.metric_availability(
-                    "claude", cost=True, tokens=True,
-                    input_tokens=True, output_tokens=True,
-                ),
-                "_model_cost": {"claude-test": 1.0},
-                "_model_tok": {"claude-test": 100},
-                "_day_cost": {"2026-08-18": 1.0}, "model_stats": [],
-                "_model_daily": [], "_performance_samples": [],
-                "_wait_samples": [], "_tool_evidence": {},
-            }
-
-        canonical_path = "/tmp/claude-canonical.jsonl"
-        duplicate_path = "/tmp/claude-duplicate.jsonl"
-        sources = [
-            {
-                "id": "shared", "path": canonical_path, "provider": "claude",
-                "runtime": "Claude", "label": "Claude Desktop",
-                "project": "/repo", "mtime": 2,
-                "_aggregation_key": "claude:shared",
-                "_aggregation_canonical": True,
-            },
-            {
-                "id": "shared", "path": duplicate_path, "provider": "claude",
-                "runtime": "Claude", "label": "Claude Desktop",
-                "project": "/repo", "mtime": 1,
-                "_aggregation_key": "claude:shared",
-            },
-        ]
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["data"], meter._xsess["at"] = None, 0
-            with mock.patch.object(meter, "session_summary", side_effect=row), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                result = meter.cross_session(sources=sources)
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(result["total_sessions"], 1)
-        self.assertEqual(result["total_cost"], 1.0)
-        self.assertEqual(result["total_tokens"], 100)
-        self.assertNotIn(duplicate_path, json.dumps(result))
-
-    def test_cross_session_projects_subagent_usage_and_selected_group(self):
-        sources = [
-            {"id": "root", "path": "/tmp/root", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/repo",
-             "mtime": 2},
-            {"id": "child", "path": "/tmp/child", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/repo",
-             "mtime": 3},
-        ]
-
-        def summary(source):
-            child = source["id"] == "child"
-            cost = 2.0 if child else 1.0
-            tokens = 200 if child else 100
-            agent_record = {
-                "id": source["id"],
-                "parent_id": "root" if child else None,
-                "session_id": source["id"],
-                "runtime": "codex", "client": "Codex",
-                "kind": "spawned" if child else "root",
-                "depth": 1 if child else 0, "label": "Worker" if child else "",
-                "role": "researcher" if child else None,
-                "model": "gpt-5.6-sol", "activity_state": "working" if child else "recent",
-                "started_at": 1, "ended_at": None, "last_activity_at": 2,
-                "tokens": tokens, "tokens_available": True,
-                "input_tokens": tokens - 10, "output_tokens": 10,
-                "cache_read_tokens": 0, "cache_write_tokens": 0,
-                "reasoning_tokens": 0, "cost": cost, "cost_available": True,
-                "executions": 1, "attempts": 1, "retries": 0,
-                "failed_attempts": 0, "tool_calls": 0,
-                "agent_path": "/private/agent.md",
-            }
-            return {
-                **source, "turns": 1, "cost": cost, "tokens": tokens,
-                "input_tokens": tokens - 10, "output_tokens": 10,
-                "models": ["gpt-5.6-sol"], "token_estimate": False,
-                "availability": meter.metric_availability(
-                    "codex", cost=True, tokens=True,
-                    input_tokens=True, output_tokens=True,
-                ),
-                "_model_cost": {"gpt-5.6-sol": cost},
-                "_model_tok": {"gpt-5.6-sol": tokens},
-                "_day_cost": {"2026-08-18": cost}, "model_stats": [],
-                "_model_daily": [], "_performance_samples": [],
-                "_wait_samples": [], "_tool_evidence": {},
-                "_agent_records": [agent_record],
-            }
-
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess.update({"data": None, "at": 0, "agent_groups": ()})
-            with mock.patch.object(meter, "session_summary", side_effect=summary), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                cross = meter.cross_session(sources=sources)
-            state = meter.attach_cross_session({"source": {"id": "child"}}, cross)
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(cross["total_cost"], 3.0)
-        self.assertEqual(cross["total_tokens"], 300)
-        self.assertEqual(cross["agent_usage"]["totals"]["agents"], 1)
-        self.assertEqual(cross["agent_usage"]["totals"]["cost"], 2.0)
-        self.assertEqual(
-            cross["agent_usage"]["models"][0]["id"],
-            "gpt-5.6-sol::codex::spawned",
-        )
-        self.assertEqual(
-            cross["agent_usage"]["inventory"][0]["role"], "researcher",
-        )
-        self.assertEqual(
-            cross["agent_usage"]["inventory"][0]["root_session_id"], "root",
-        )
-        self.assertFalse(cross["agent_usage"]["inventory_truncated"])
-        self.assertEqual(state["agent_group"]["root_session_id"], "root")
-        self.assertEqual(state["agent_group"]["selected_agent_id"], "child")
-        self.assertEqual(len(state["agent_group"]["agents"]), 2)
-        encoded = json.dumps({"cross": cross, "group": state["agent_group"]})
-        self.assertNotIn("agent_path", encoded)
-        self.assertNotIn("/private/agent.md", encoded)
-        self.assertNotIn("_all_agents", encoded)
-        self.assertNotIn("_session_ids", encoded)
-
-    def test_cross_session_uses_physical_agents_without_changing_accounting_totals(self):
-        sources = [
-            {"id": "shared", "path": "/tmp/root-old", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
-             "physical_trace_id": "physical-root", "mtime": 1},
-            {"id": "shared", "path": "/tmp/root-new", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
-             "physical_trace_id": "physical-root", "mtime": 2},
-            {"id": "shared", "path": "/tmp/child-a", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
-             "physical_trace_id": "physical-child-a", "mtime": 3},
-            {"id": "shared", "path": "/tmp/child-b", "provider": "codex",
-             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
-             "physical_trace_id": "physical-child-b", "mtime": 4},
-        ]
-
-        def summary(source):
-            suffix = source["path"].rsplit("/", 1)[-1]
-            is_root = suffix.startswith("root")
-            cost = {"root-old": 1.0, "root-new": 2.0,
-                    "child-a": 3.0, "child-b": 4.0}[suffix]
-            tokens = int(cost * 100)
-            agent_id = "agent-root" if is_root else f"agent-{suffix}"
-            record = {
-                "id": agent_id,
-                "parent_id": None if is_root else "agent-root",
-                "session_id": "shared" if is_root else None,
-                "runtime": "codex", "client": "Codex",
-                "kind": "root" if is_root else "spawned",
-                "depth": 0 if is_root else 1,
-                "model": "gpt-5.6-sol", "activity_state": "recent",
-                "started_at": 1, "ended_at": 2, "last_activity_at": 2,
-                "tokens": tokens, "tokens_available": True,
-                "input_tokens": tokens - 10, "output_tokens": 10,
-                "cache_read_tokens": 0, "cache_write_tokens": 0,
-                "reasoning_tokens": 0, "cost": cost,
-                "cost_available": True, "executions": 1, "attempts": 1,
-                "retries": 0, "failed_attempts": 0, "tool_calls": 0,
-            }
-            return {
-                **source, "turns": 1, "cost": cost, "tokens": tokens,
-                "input_tokens": tokens - 10, "output_tokens": 10,
-                "models": ["gpt-5.6-sol"], "token_estimate": False,
-                "availability": meter.metric_availability(
-                    "codex", cost=True, tokens=True,
-                    input_tokens=True, output_tokens=True,
-                ),
-                "_model_cost": {"gpt-5.6-sol": cost},
-                "_model_tok": {"gpt-5.6-sol": tokens},
-                "_day_cost": {"2026-09-22": cost}, "model_stats": [],
-                "_model_daily": [], "_performance_samples": [],
-                "_wait_samples": [], "_tool_evidence": {},
-                "_agent_records": [record],
-            }
-
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess.update({"data": None, "at": 0, "agent_groups": ()})
-            with mock.patch.object(meter, "session_summary", side_effect=summary), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                cross = meter.cross_session(sources=sources)
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(cross["total_sessions"], 4)
-        self.assertEqual(cross["total_cost"], 10.0)
-        self.assertEqual(cross["total_tokens"], 1000)
-        self.assertEqual(cross["agent_usage"]["totals"]["agents"], 2)
-        self.assertEqual(cross["agent_usage"]["totals"]["cost"], 7.0)
-        project_scopes = [
-            scope for scope in cross["agent_usage"]["scopes"]
-            if scope.get("project") == "/luna-3"
-            and scope["window"] == "all" and scope["runtime"] == "codex"
-        ]
-        self.assertEqual(len(project_scopes), 1)
-        self.assertEqual(project_scopes[0]["totals"]["agents"], 2)
-
-
-class DashboardLayoutTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.page = Path(DASHBOARD_PAGE).read_text()
-        cls.session_effects = (
-            Path(meter.__file__).with_name("assets") / "session-effects.js"
-        ).read_text()
-
-    def test_current_detail_excludes_all_secondary_panels(self):
-        self.assertNotIn("data-panel=efficiency", self.page)
-        self.assertNotIn("id=panel-efficiency", self.page)
-        self.assertIn("const PANEL_KEYS=['summary'];", self.page)
-        self.assertNotIn("efficiency:'summary'", self.page)
-
-    def test_dashboard_uses_splunk_favicon_and_bundled_wordmark(self):
-        self.assertIn('rel=icon type="image/svg+xml"', self.page)
-        self.assertIn("data:image/svg+xml", self.page)
-        self.assertIn("M47.03 36.16v-7.58L10 10", self.page)
-        self.assertIn('class=logo role=img aria-label="Splunk by Cisco"', self.page)
-        self.assertIn('/assets/brand/logo-splunk-by-cisco-rgb-w.png', self.page)
-        self.assertIn('name=theme-color content="#07090c"', self.page)
-
-    def test_sessions_surfaces_include_agent_activity_and_usage_statistics(self):
-        for expected in (
-            "id=agent-activity",
-            "id=agent-activity-tree",
-            "id=agent-attention-detail",
-            "id=view-subagents",
-            "id=subagent-explorer",
-            "id=subagent-filter-status",
-            "id=subagent-filter-signal",
-            "id=subagent-view-tabs",
-            "id=subagent-compact-summary",
-            "id=subagent-workspace",
-            "id=subagent-results",
-            "id=subagent-inspector",
-            "renderAgentActivity(s);",
-            "renderSubagentExplorer(",
-            "Median / P95",
-            "groupSubagentSessions(",
-            "buildSubagentRoleRows(",
-        ):
-            self.assertIn(expected, self.page)
-        self.assertIn("Cost color compares children in this session", self.page)
-        self.assertIn("Cost and retry evidence", self.page)
-        self.assertIn("Work time", self.page)
-        self.assertIn("completed prompt-to-response time", self.page)
-        self.assertNotIn("<span>Elapsed</span>", self.page)
-        self.assertNotIn("evidenceMetric('Elapsed'", self.page)
-
-    def test_agent_activity_work_time_header_aligns_with_right_aligned_values(self):
-        self.assertIn(
-            ".agentTreeHeader .fieldtip{justify-content:flex-end}",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_explorer_prefers_roles_and_filters_status_and_signals(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('agentIdentityPresentation'));
-eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
-const usage={{inventory_count:3,inventory_truncated:false,inventory:[
- {{id:'a',root_session_id:'root-a',project:'/token-meter',runtime:'codex',model:'gpt',role:'token_meter_reviewer',label:'Heisenberg',activity_state:'complete',last_activity_at:100,tokens:10,tokens_available:true,cost:1,cost_available:true,work_time_s:30,attention:[]}},
- {{id:'b',root_session_id:'root-a',project:'/token-meter',runtime:'codex',model:'gpt',role:null,label:'Gauss',activity_state:'incomplete',last_activity_at:200,tokens:20,tokens_available:true,cost:4,cost_available:true,work_time_s:60,attention:[{{code:'peer_cost_outlier',explanation:'3x peers'}}]}},
- {{id:'c',root_session_id:'root-c',project:'/luna-3',runtime:'claude',model:'opus',role:null,label:'',activity_state:'working',last_activity_at:300,tokens:null,tokens_available:false,cost:null,cost_available:false,work_time_s:null,attention:[]}},
-]}};
-const result=filterSubagentInventory(usage,{{query:'gauss',runtime:'codex',project:'/token-meter',model:'gpt',status:'incomplete',signal:'peer_cost_outlier',window:'all',sort:'cost'}},400);
-const workSorted=filterSubagentInventory(usage,{{query:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'work'}},400);
-process.stdout.write(JSON.stringify({{
- role:agentIdentityPresentation(usage.inventory[0],0),
- nickname:agentIdentityPresentation(usage.inventory[1],1),
- fallback:agentIdentityPresentation(usage.inventory[2],2),
- result,workSorted,
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-
-        self.assertEqual(payload["role"], {
-            "primary": "token_meter_reviewer", "secondary": "Heisenberg",
-        })
-        self.assertEqual(payload["nickname"], {
-            "primary": "Gauss", "secondary": "",
-        })
-        self.assertEqual(payload["fallback"], {
-            "primary": "Agent 3", "secondary": "",
-        })
-        self.assertEqual([row["id"] for row in payload["result"]["rows"]], ["b"])
-        self.assertEqual(payload["result"]["summary"]["incomplete"], 1)
-        self.assertEqual(payload["result"]["summary"]["attention"], 1)
-        self.assertEqual(payload["result"]["summary"]["parentSessions"], 1)
-        self.assertTrue(payload["result"]["summary"]["complete"])
-        self.assertEqual(
-            [row["id"] for row in payload["workSorted"]["rows"]],
-            ["b", "a", "c"],
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_last_month_time_filter_bounds_sessions_subagents_and_role_days(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'';
-eval(['timeFilterBounds','agentIdentityPresentation','filterSubagentInventory','childRootId','localDateKey','dateKeyAgo','calendarMonthWindow','monthToDateWindow','modelRangeWindow','subagentRoleKey','subagentRoleDayRows','subagentModelKey','subagentModelDayRows','normalizedSubagentNavigationState'].map(extract).join('\\n'));
-eval(page.slice(page.indexOf('function allSessionsView('),page.indexOf('function allSessionsCountText(')));
-const DEFAULT_TIME_FILTER_WINDOW='30d';
-const subagentFilterDefaults={{query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'}};
-const now=new Date(2026,9,5,12).getTime(),at=(...parts)=>new Date(...parts).getTime()/1000;
-const bounds=timeFilterBounds('last_month',now);
-const stamps={{current:at(2026,9,1,0,0,1),lastStart:at(2026,8,1),lastEnd:at(2026,8,30,23,59,59),prior:at(2026,7,31,23,59,59)}};
-const inventory=Object.entries(stamps).map(([id,last])=>({{id,root_session_id:'root',runtime:'codex',label:id,activity_state:'complete',last_activity_at:last,attention:[]}}));
-const agents=filterSubagentInventory({{inventory}},{{window:'last_month',status:'all',signal:'all',sort:'recent'}},now/1000).rows.map(row=>row.id).sort();
-const sessions=allSessionsView(Object.entries(stamps).map(([id,mtime])=>({{id,provider:'codex',title:id,cost:1,mtime}})),{{rangeStart:bounds.start,rangeEnd:bounds.end}}).rows.map(row=>row.id).sort();
-const roleRow=day=>({{day,runtime:'codex',kind:'spawned',role:'reviewer',project:''}});
-const roleDays=subagentRoleDayRows({{role_days:['2026-10-01','2026-09-30','2026-09-01','2026-08-31'].map(roleRow)}},{{window:'last_month'}},now).map(row=>row.day);
-const monthBounds=timeFilterBounds('month',now);
-const monthAgents=filterSubagentInventory({{inventory}},{{window:'month',status:'all',signal:'all',sort:'recent'}},now/1000).rows.map(row=>row.id).sort();
-const monthSessions=allSessionsView(Object.entries(stamps).map(([id,mtime])=>({{id,provider:'codex',title:id,cost:1,mtime}})),{{rangeStart:monthBounds.start,rangeEnd:monthBounds.end}}).rows.map(row=>row.id).sort();
-const monthRoleDays=subagentRoleDayRows({{role_days:['2026-10-06','2026-10-05','2026-10-01','2026-09-30'].map(roleRow)}},{{window:'month'}},now).map(row=>row.day);
-const modelRow=day=>({{day,runtime:'codex',model:'gpt-5',project:''}});
-const lastMonthModelDays=subagentModelDayRows({{model_days:['2026-10-01','2026-09-30','2026-09-01','2026-08-31'].map(modelRow)}},{{window:'last_month'}},now).map(row=>row.day);
-const monthModelDays=subagentModelDayRows({{model_days:['2026-10-05','2026-10-01','2026-09-30'].map(modelRow)}},{{window:'month'}},now).map(row=>row.day);
-process.stdout.write(JSON.stringify({{
- agents,sessions,roleDays,monthAgents,monthSessions,monthRoleDays,lastMonthModelDays,monthModelDays,
- monthRestored:normalizedSubagentNavigationState('roles',{{window:'month'}}).filters.window,
- restored:normalizedSubagentNavigationState('roles',{{window:'last_month'}}).filters.window,
- rolling:timeFilterBounds('7d',now).end,
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload["agents"], ["lastEnd", "lastStart"])
-        self.assertEqual(payload["sessions"], ["lastEnd", "lastStart"])
-        self.assertEqual(payload["roleDays"], ["2026-09-01", "2026-09-30"])
-        self.assertEqual(payload["restored"], "last_month")
-        self.assertEqual(payload["rolling"], 0)
-        self.assertEqual(self.page.count(
-            "<option value=today>Today</option><option value=yesterday>Yesterday</option>"
-            "<option value=7d>7 days</option><option value=30d selected>30 days</option>"
-            "<option value=90d>90 days</option><option value=month>Month</option>"
-            "<option value=last_month>Last month</option><option value=all>All history</option></select>"
-        ), 2)
-        self.assertNotIn("value=24h", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_calendar_time_filters_bound_sessions_subagents_and_role_days(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'';
-eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('const DELIVERY_EVIDENCE_FILTERS=')).replace(/^const /gm,'var '));
-eval(['agentIdentityPresentation','filterSubagentInventory','childRootId','localDateKey','dateKeyAgo','calendarMonthWindow','monthToDateWindow','modelRangeWindow','subagentRoleKey','subagentRoleDayRows','normalizedSubagentNavigationState'].map(extract).join('\\n'));
-eval(page.slice(page.indexOf('function allSessionsView('),page.indexOf('function allSessionsCountText(')));
-const subagentFilterDefaults={{query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'}};
-const now=new Date(2026,9,5,12).getTime(),at=(...parts)=>new Date(...parts).getTime()/1000;
-const stamps={{today:at(2026,9,5,0,0,1),yesterdayStart:at(2026,9,4),yesterdayEnd:at(2026,9,4,23,59,59),monthStart:at(2026,9,1),lastMonth:at(2026,8,30,23,59,59)}};
-const inventory=Object.entries(stamps).map(([id,last])=>({{id,root_session_id:'root',runtime:'codex',label:id,activity_state:'complete',last_activity_at:last,attention:[]}}));
-const result={{}};
-for(const window of ['today','yesterday','month']){{
- const bounds=timeFilterBounds(window,now);
- result[window]={{
-  agents:filterSubagentInventory({{inventory}},{{window,status:'all',signal:'all',sort:'recent'}},now/1000).rows.map(row=>row.id).sort(),
-  sessions:allSessionsView(Object.entries(stamps).map(([id,mtime])=>({{id,provider:'codex',title:id,cost:1,mtime}})),{{rangeStart:bounds.start,rangeEnd:bounds.end}}).rows.map(row=>row.id).sort(),
-  roleDays:subagentRoleDayRows({{role_days:['2026-10-05','2026-10-04','2026-10-01','2026-09-30'].map(day=>({{day,runtime:'codex',kind:'spawned',role:'reviewer',project:''}}))}},{{window}},now).map(row=>row.day),
- }};
-}}
-process.stdout.write(JSON.stringify({{
- result,
- migrated:normalizeTimeFilterWindow('24h'),invalid:normalizeTimeFilterWindow('bogus'),
- restored:normalizedSubagentNavigationState('roles',{{window:'24h'}}).filters.window,
- restoredMonth:normalizedSubagentNavigationState('roles',{{window:'month'}}).filters.window,
- labels:TIME_FILTER_LABELS,
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        result = payload["result"]
-        self.assertEqual(result["today"]["agents"], ["today"])
-        self.assertEqual(result["today"]["sessions"], ["today"])
-        self.assertEqual(result["today"]["roleDays"], ["2026-10-05"])
-        self.assertEqual(result["yesterday"]["agents"], ["yesterdayEnd", "yesterdayStart"])
-        self.assertEqual(result["yesterday"]["sessions"], ["yesterdayEnd", "yesterdayStart"])
-        self.assertEqual(result["yesterday"]["roleDays"], ["2026-10-04"])
-        self.assertEqual(result["month"]["agents"], ["monthStart", "today", "yesterdayEnd", "yesterdayStart"])
-        self.assertEqual(result["month"]["roleDays"], ["2026-10-01", "2026-10-04", "2026-10-05"])
-        self.assertEqual(payload["migrated"], "today")
-        self.assertEqual(payload["invalid"], "30d")
-        self.assertEqual(payload["restored"], "today")
-        self.assertEqual(payload["restoredMonth"], "month")
-        self.assertEqual(payload["labels"]["month"], "Month")
-        self.assertNotIn("24h", payload["labels"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_explorer_withholds_filtered_totals_when_inventory_is_truncated(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
-const result=filterSubagentInventory({{inventory_count:1001,inventory_truncated:true,inventory:[{{id:'a',root_session_id:'root',runtime:'codex',label:'Agent A',activity_state:'complete',last_activity_at:100,attention:[]}}]}},{{query:'agent',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'recent'}},200);
-process.stdout.write(JSON.stringify(result));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertFalse(payload["summary"]["complete"])
-        self.assertIsNone(payload["summary"]["agents"])
-        self.assertEqual(payload["inventoryCount"], 1001)
-        self.assertEqual(len(payload["rows"]), 1)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_triage_preserves_context_and_pages_large_results(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('applySubagentPreset'));
-eval(extract('subagentPresetForFilters'));
-eval(extract('paginateSubagentRows'));
-const base={{query:'reviewer',runtime:'codex',project:'/token-meter',model:'gpt-5',status:'complete',signal:'retry_pressure',window:'7d',sort:'cost'}};
-const incomplete=applySubagentPreset(base,'incomplete');
-const attention=applySubagentPreset(base,'attention');
-const all=applySubagentPreset(base,'all');
-const rows=Array.from({{length:123}},(_,id)=>({{id}}));
-process.stdout.write(JSON.stringify({{
- incomplete,attention,all,
- presets:[subagentPresetForFilters(incomplete),subagentPresetForFilters(attention),subagentPresetForFilters(all),subagentPresetForFilters(base)],
- first:paginateSubagentRows(rows,50),
- complete:paginateSubagentRows(rows,150),
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-
-        for state in (payload["incomplete"], payload["attention"], payload["all"]):
-            self.assertEqual(state["runtime"], "codex")
-            self.assertEqual(state["project"], "/token-meter")
-            self.assertEqual(state["window"], "7d")
-            self.assertEqual(state["query"], "reviewer")
-            self.assertEqual(state["model"], "gpt-5")
-            self.assertEqual(state["sort"], "cost")
-        self.assertEqual(payload["incomplete"]["status"], "incomplete")
-        self.assertEqual(payload["incomplete"]["signal"], "all")
-        self.assertEqual(payload["attention"]["status"], "all")
-        self.assertEqual(payload["attention"]["signal"], "attention")
-        self.assertEqual(payload["all"]["status"], "all")
-        self.assertEqual(payload["all"]["signal"], "all")
-        self.assertEqual(payload["presets"], [
-            "incomplete", "attention", "all", "custom",
-        ])
-        self.assertEqual(len(payload["first"]["rows"]), 50)
-        self.assertEqual(payload["first"]["shown"], 50)
-        self.assertEqual(payload["first"]["total"], 123)
-        self.assertTrue(payload["first"]["hasMore"])
-        self.assertEqual(payload["first"]["nextLimit"], 100)
-        self.assertEqual(len(payload["complete"]["rows"]), 123)
-        self.assertFalse(payload["complete"]["hasMore"])
-        self.assertEqual(payload["complete"]["nextLimit"], 123)
-
-    def test_subagent_explorer_has_progressive_filters_and_evidence_inspector(self):
-        for expected in (
-            "id=subagent-view-tabs",
-            "aria-controls=subagent-results-panel",
-            "data-subagent-view=issues",
-            "data-subagent-view=sessions",
-            "data-subagent-view=roles",
-            "id=subagent-filter-more",
-            "id=subagent-filter-advanced",
-            "id=subagent-active-filters",
-            "id=subagent-workspace",
-            "id=subagent-results",
-            "id=subagent-results-panel role=tabpanel",
-            "id=subagent-inspector",
-            "data-subagent-open-parent",
-            "data-subagent-show-session",
-            "subagentWorkspace.roleView",
-            "expandedSubagentRoot=root",
-            "subagentInspector",
-        ):
-            self.assertIn(expected, self.page)
-        for removed in (
-            "id=subagent-triage",
-            "id=subagent-insights",
-            "id=subagent-explorer-summary",
-            "id=subagent-inventory-more",
-        ):
-            self.assertNotIn(removed, self.page)
-        self.assertIn("id=view-subagents", self.page)
-        self.assertIn("function renderSubagentInspector(", self.page)
-        self.assertIn("const incompletePill=compact('Incomplete'", self.page)
-        self.assertNotIn("compact('Needs review'", self.page)
-
-    def test_subagent_workspace_orders_roles_sessions_issues_and_defaults_to_roles(self):
-        tablist_start = self.page.index('id=subagent-view-tabs')
-        tablist_end = self.page.index('</div>', tablist_start)
-        tablist = self.page[tablist_start:tablist_end]
-        self.assertLess(tablist.index('data-subagent-view=roles'), tablist.index('data-subagent-view=sessions'))
-        self.assertLess(tablist.index('data-subagent-view=sessions'), tablist.index('data-subagent-view=issues'))
-        self.assertIn('data-subagent-view=roles aria-selected=true', tablist)
-        self.assertIn("localStorage.getItem('tm_subagent_view')||'roles'", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_work_sort_uses_user_facing_label_and_migrates_elapsed_preference(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const stored=new Map([['tm_subagent_filter_sort','elapsed']]),writes=[];
-const localStorage={{getItem:key=>stored.get(key)??null,setItem:(key,value)=>{{stored.set(key,String(value));writes.push([key,String(value)]);}}}};
-let subagentFilters;
-eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('function normalizeTimeFilterWindow(')).replace(/^const /gm,'var '));
-const initStart=page.indexOf('let subagentFilters={{');
-const initEnd=page.indexOf('const SUBAGENT_PAGE_SIZE',initStart);
-eval(page.slice(initStart,initEnd).replace('let subagentFilters=','subagentFilters='));
-const subagentFilterDefaults={{query:'',role:'',kind:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:DEFAULT_TIME_FILTER_WINDOW,sort:'recent'}};
-eval(extract('normalizedSubagentNavigationState'));
-eval(extract('subagentActiveFilterItems'));
-const restored=normalizedSubagentNavigationState('sessions',{{sort:'elapsed'}});
-const chip=subagentActiveFilterItems({{...subagentFilterDefaults,sort:'work'}}).find(item=>item.key==='sort');
-process.stdout.write(JSON.stringify({{saved:subagentFilters.sort,stored:stored.get('tm_subagent_filter_sort'),writes,restored:restored.filters.sort,chip}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-
-        self.assertEqual(payload["saved"], "work")
-        self.assertEqual(payload["stored"], "work")
-        self.assertIn(["tm_subagent_filter_sort", "work"], payload["writes"])
-        self.assertEqual(payload["restored"], "work")
-        self.assertEqual(payload["chip"], {
-            "key": "sort", "label": "Sort", "value": "Work time",
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_time_filter_defaults_to_thirty_days_and_labels_all_history(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(page.slice(page.indexOf('const TIME_FILTER_WINDOWS='),page.indexOf('function normalizeTimeFilterWindow(')).replace(/^const /gm,'var '));
-const initStart=page.indexOf('let subagentFilters={{'),initEnd=page.indexOf('const SUBAGENT_PAGE_SIZE',initStart);
-const defaultsLine=page.slice(page.indexOf('const subagentFilterDefaults='),page.indexOf('function persistSubagentFilter(')).replace(/^const /,'var ');
-const persistSource=extract('persistSubagentFilter'),chipsSource=extract('subagentActiveFilterItems');
-function load(entries){{
- const stored=new Map(entries);
- const localStorage={{getItem:key=>stored.get(key)??null,setItem:(key,value)=>stored.set(key,String(value)),removeItem:key=>stored.delete(key)}};
- let subagentFilters;
- eval(page.slice(initStart,initEnd).replace('let subagentFilters=','subagentFilters='));
- eval(defaultsLine);
- const subagentFilterStorage={{window:'tm_subagent_filter_time'}};
- eval(persistSource);
- const loaded=subagentFilters.window;
- subagentFilters.window='all';persistSubagentFilter('window');const keptAll=stored.get('tm_subagent_filter_time')??null;
- subagentFilters.window='30d';persistSubagentFilter('window');const atDefault=stored.get('tm_subagent_filter_time')??null;
- return {{loaded,keptAll,atDefault,defaults:subagentFilterDefaults}};
-}}
-const fresh=load([]),bogus=load([['tm_subagent_filter_time','bogus']]),saved=load([['tm_subagent_filter_time','all']]);
-const subagentFilterDefaults=fresh.defaults;
-const appFilterLabel=row=>row.provider,projectFilterLabel=value=>value;
-eval(chipsSource);
-const chip=window=>subagentActiveFilterItems({{...subagentFilterDefaults,window}}).find(item=>item.key==='window')||null;
-process.stdout.write(JSON.stringify({{
- fresh:fresh.loaded,bogus:bogus.loaded,saved:saved.loaded,keptAll:fresh.keptAll,atDefault:fresh.atDefault,
- defaultChip:chip('30d'),allChip:chip('all'),sevenChip:chip('7d'),
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload["fresh"], "30d")
-        self.assertEqual(payload["bogus"], "30d")
-        self.assertEqual(payload["saved"], "all")
-        self.assertEqual(payload["keptAll"], "all")
-        self.assertIsNone(payload["atDefault"])
-        self.assertIsNone(payload["defaultChip"])
-        self.assertEqual(payload["allChip"], {"key": "window", "label": "Time", "value": "All history"})
-        self.assertEqual(payload["sevenChip"], {"key": "window", "label": "Time", "value": "7 days"})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_summary_tags_toggle_incomplete_and_attention_filters(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)return null;let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}return null;}}
-const source=extract('toggleSubagentSummaryFilter');
-if(!source)process.stdout.write(JSON.stringify({{missing:true}}));
-else{{
- eval(source);
- const start={{query:'reviewer',runtime:'codex',project:'/token-meter',model:'gpt',status:'all',signal:'all',window:'7d',sort:'cost'}};
- process.stdout.write(JSON.stringify({{
-  missing:false,
-  incomplete:toggleSubagentSummaryFilter(start,'incomplete'),
-  incompleteOff:toggleSubagentSummaryFilter(toggleSubagentSummaryFilter(start,'incomplete'),'incomplete'),
-  attention:toggleSubagentSummaryFilter(start,'attention'),
-  outlier:toggleSubagentSummaryFilter(start,'peer_cost_outlier'),
- }}));
-}}
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-
-        self.assertFalse(payload.get("missing", False))
-        self.assertEqual(payload["incomplete"]["status"], "incomplete")
-        self.assertEqual(payload["incomplete"]["signal"], "all")
-        self.assertEqual(payload["incompleteOff"]["status"], "all")
-        self.assertEqual(payload["attention"]["signal"], "attention")
-        self.assertEqual(payload["attention"]["status"], "all")
-        self.assertEqual(payload["outlier"]["signal"], "peer_cost_outlier")
-        self.assertEqual(payload["outlier"]["query"], "reviewer")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_drilldown_adds_restorable_browser_history(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const calls=[];
-const history={{state:{{sessionScope:'all'}},replaceState(state,title,url){{this.state=state;calls.push(['replace',state.subagent,url]);}},pushState(state,title,url){{this.state=state;location.href=String(url);location.hash='#'+String(url).split('#')[1];calls.push(['push',state.subagent,url]);}}}};
-const location={{href:'http://127.0.0.1:8722/#subagents',hash:'#subagents'}};
-const localStorage={{setItem(){{}},removeItem(){{}}}};
-const subagentFilterDefaults={{query:'',runtime:'',project:'',model:'',status:'all',signal:'all',window:'all',sort:'recent'}};
-let subagentView='roles',subagentFilters={{...subagentFilterDefaults,project:'/token-meter',window:'30d'}},selectedSubagentId='child',expandedSubagentRoot='root';
-const persistSubagentFilter=()=>{{}},resetSubagentResultView=()=>{{}};
-eval(['normalizedSubagentNavigationState','restoreSubagentNavigationState','openSubagentRoleRuns'].map(extract).join('\\n'));
-openSubagentRoleRuns('token_meter_reviewer','codex','spawned');
-const drilldown={{view:subagentView,filters:subagentFilters}};
-restoreSubagentNavigationState(calls[0][1]);
-process.stdout.write(JSON.stringify({{calls,drilldown,restored:{{view:subagentView,filters:subagentFilters}},sessionScope:history.state.sessionScope}}));
-"""
-        completed = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        payload = json.loads(completed.stdout)
-
-        self.assertEqual([call[0] for call in payload["calls"]], ["replace", "push"])
-        self.assertEqual(payload["calls"][0][1]["view"], "roles")
-        self.assertEqual(payload["calls"][0][1]["filters"]["project"], "/token-meter")
-        self.assertEqual(payload["drilldown"]["view"], "sessions")
-        self.assertEqual(payload["calls"][1][2], "/#sessions-subagents")
-        self.assertEqual(payload["drilldown"]["filters"]["role"], "token_meter_reviewer")
-        self.assertEqual(payload["drilldown"]["filters"]["kind"], "spawned")
-        self.assertEqual(payload["restored"]["view"], "roles")
-        self.assertEqual(payload["restored"]["filters"]["window"], "30d")
-        self.assertEqual(payload["sessionScope"], "all")
-
-    def test_session_detail_back_control_markup_names_origin_list(self):
-        view = self.page.index("id=view-session")
-        back = self.page.index("id=session-back-row")
-        title = self.page.index("id=session-page-title")
-        self.assertLess(view, back)
-        self.assertLess(back, title)
-        self.assertIn(
-            '<div class=sessionBackRow id=session-back-row data-current-detail>'
-            '<button class="tbtn sessionBack" id=session-back type=button aria-label="Back to Current sessions">'
-            '<span aria-hidden=true>←</span><span id=session-back-label>Current sessions</span></button></div>',
-            self.page,
-        )
-        self.assertIn("$('session-back').onclick=openSessionBack;", self.page)
-        self.assertIn("if(!overview)renderSessionBack();", self.page)
-        self.assertIn(".sessionBackRow{display:flex;margin-bottom:10px}", self.page)
-        self.assertIn("sessionListBack:!replace&&sessionListBackAvailable(sessionReturnScope)", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_detail_back_returns_to_origin_list(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',start)+1,depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const SESSION_SCOPES=['current','all','compare','subagents'];
-const calls=[];
-let location={{pathname:'/',hash:'#sessions-all'}};
-const history={{state:null,back(){{calls.push(['back']);}},pushState(state,title,url){{this.state=state;const [path,hash]=String(url).split('#');location={{pathname:path||'/',hash:hash?'#'+hash:''}};calls.push(['push',url]);}},replaceState(state){{this.state=state;}}}};
-const elements={{}};
-const $=id=>elements[id]||(elements[id]={{textContent:'',attrs:{{}},setAttribute(name,value){{this.attrs[name]=value;}}}});
-let sessionScope='all',sessionReturnScope='current',sessionRequest=0,pinned=null;
-const applyHashRoute=()=>{{}},refreshSelectedSession=()=>Promise.resolve();
-const openSessionScope=scope=>calls.push(['scope',scope]);
-eval(['routedSessionId','sessionRoute','normalizeSessionScope','sessionScopeRoute','sessionScopeLabel','sessionListBackAvailable','renderSessionBack','openSessionBack','selectSession'].map(extract).join('\\n'));
-const result={{}};
-selectSession('abc',{{returnScope:'all'}});
-renderSessionBack();
-result.fromList={{state:history.state,label:$('session-back-label').textContent,aria:$('session-back').attrs['aria-label']}};
-openSessionBack();
-result.fromListCalls=calls.splice(0);
-location={{pathname:'/',hash:'#spend'}};
-selectSession('def');
-openSessionBack();
-result.fromSpend={{state:history.state,calls:calls.splice(0)}};
-selectSession('ghi',{{returnScope:'compare'}});
-result.sessionToSession=history.state;
-calls.splice(0);
-location={{pathname:'/sessions/deep#summary',hash:'#summary'}};
-history.state=null;sessionReturnScope='current';
-renderSessionBack();
-openSessionBack();
-result.deepLink={{label:$('session-back-label').textContent,aria:$('session-back').attrs['aria-label'],calls:calls.splice(0)}};
-result.labels=['current','all','compare','subagents','bogus'].map(sessionScopeLabel);
-eval(extract('applyLocationRoute'));
-elements['view-session']={{classList:{{contains:()=>true}}}};
-location={{pathname:'/sessions/xyz',hash:'#summary'}};
-history.state={{sessionScope:'compare',sessionListBack:true}};
-sessionScope='current';sessionReturnScope='current';
-applyLocationRoute();
-renderSessionBack();
-result.reload={{scope:sessionReturnScope,label:$('session-back-label').textContent}};
-openSessionBack();
-result.reloadCalls=calls.splice(0);
-process.stdout.write(JSON.stringify(result));
-"""
-        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        payload = json.loads(completed.stdout)
-
-        self.assertEqual(payload["fromList"]["state"], {"sessionScope": "all", "sessionListBack": True})
-        self.assertEqual(payload["reload"], {"scope": "compare", "label": "Compare"})
-        self.assertEqual(payload["reloadCalls"], [["back"]])
-        self.assertEqual(payload["fromList"]["label"], "All sessions")
-        self.assertEqual(payload["fromList"]["aria"], "Back to All sessions")
-        self.assertEqual(payload["fromListCalls"], [["push", "/sessions/abc#summary"], ["back"]])
-        self.assertEqual(payload["fromSpend"]["state"], {"sessionScope": "all", "sessionListBack": False})
-        self.assertEqual(payload["fromSpend"]["calls"], [["push", "/sessions/def#summary"], ["scope", "all"]])
-        self.assertEqual(payload["sessionToSession"], {"sessionScope": "compare", "sessionListBack": False})
-        self.assertEqual(payload["deepLink"]["label"], "Current sessions")
-        self.assertEqual(payload["deepLink"]["aria"], "Back to Current sessions")
-        self.assertEqual(payload["deepLink"]["calls"], [["scope", "current"]])
-        self.assertEqual(
-            payload["labels"],
-            ["Current sessions", "All sessions", "Compare", "Subagents", "Current sessions"],
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_compare_keys_forked_traces_and_routes_compare_scope(self):
-        self.assertIn("id=session-scope-compare", self.page)
-        self.assertIn("id=session-compare role=tabpanel", self.page)
-        self.assertIn("fetch(`/session/compare?ids=${encodeURIComponent(key)}`", self.page)
-        self.assertIn("{id:'compare-sessions',label:'Compare sessions'", self.page)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const SESSION_SCOPES=['current','all','compare','subagents'];
-eval(extract('normalizeSessionScope'));eval(extract('sessionScopeRoute'));eval(extract('compareKeyFor'));
-eval(extract('mergeAllSessionInventory'));eval(extract('compareDelta'));
-const parent={{id:'root',key:'tparent',title:'Same'}};
-const fork={{id:'root',key:'tfork',title:'Same'}};
-const merged=mergeAllSessionInventory([parent,fork],[{{...fork,cost:2}}]);
-process.stdout.write(JSON.stringify({{
- route:sessionScopeRoute('compare'),
- keys:[compareKeyFor(parent),compareKeyFor(fork),compareKeyFor({{id:'only'}}),compareKeyFor({{id:'o',key:'topencode'}}),compareKeyFor({{key:'tkiro'}}),compareKeyFor({{}}),compareKeyFor({{id:7}})],
- merged:merged.length,
- liveWins:merged.find(row=>row.key===fork.key).cost,
- cheaper:compareDelta({{lower:true}},0.5,1),
- costlier:compareDelta({{lower:true}},3,1),
- neutral:compareDelta({{}},2.5,2),
- points:compareDelta({{lower:false,points:true}},0.9,0.6),
- missing:compareDelta({{lower:true}},null,1),
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload["route"], "sessions-compare")
-        self.assertEqual(payload["keys"], ["tparent", "tfork", "only", "topencode", "tkiro", "", "7"])
-        self.assertEqual(payload["merged"], 2)
-        self.assertEqual(payload["liveWins"], 2)
-        self.assertIn("better", payload["cheaper"])
-        self.assertIn("−50%", payload["cheaper"])
-        self.assertIn("worse", payload["costlier"])
-        self.assertIn("3.0×", payload["costlier"])
-        self.assertNotIn("better", payload["neutral"])
-        self.assertNotIn("worse", payload["neutral"])
-        self.assertIn("+30 pts", payload["points"])
-        self.assertIn("better", payload["points"])
-        self.assertEqual(payload["missing"], "")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_compare_clears_stale_missing_notice_when_selection_empties(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`async function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',start)+1,depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-let compareIds=[],compareData={{sessions:[]}},compareError='',compareNotice='1 selected session could not be loaded right now.',compareMissing=['tgone'],compareLoadedKey='tgone',compareLoading=false,compareRequestSeq=0,rendered=0;
-function renderComparison(){{rendered++;}}
-eval(extract('loadComparison'));
-loadComparison().then(()=>process.stdout.write(JSON.stringify({{compareNotice,compareMissing,compareData,rendered}})));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload, {"compareNotice": "", "compareMissing": [], "compareData": None, "rendered": 1})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagents_have_a_primary_page_and_canonical_return_route(self):
-        self.assertIn("id=tab-subagents", self.page)
-        self.assertIn("id=view-subagents", self.page)
-        self.assertIn("id=session-scope-subagents", self.page)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const SESSION_SCOPES=['current','all','subagents'];
-eval(extract('normalizeSessionScope'));
-eval(extract('sessionScopeRoute'));
-process.stdout.write(JSON.stringify({{subagents:sessionScopeRoute('subagents'),all:sessionScopeRoute('all'),current:sessionScopeRoute('current')}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload, {
-            "subagents": "sessions-subagents", "all": "sessions-all", "current": "sessions",
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_runs_model_distribution_is_exact_and_runtime_scoped(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('timeFilterBounds'));eval(extract('filterSubagentInventory'));
-eval(extract('subagentModelDistribution'));
-const rows=[
- {{id:'1',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-x',cost:2,cost_available:true}},
- {{id:'2',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-x',cost_available:false}},
- {{id:'3',runtime:'claude',kind:'spawned',role:'token_meter_reviewer',model:'gpt-x',cost:3,cost_available:true}},
- {{id:'4',runtime:'codex',role:'tester',label:'token_meter_reviewer helper',model:'gpt-y',cost:9,cost_available:true}},
- {{id:'5',runtime:'codex',kind:'internal',role:'token_meter_reviewer',model:'gpt-y',cost:11,cost_available:true}},
-];
-const result=filterSubagentInventory({{inventory:rows}},{{role:'token_meter_reviewer',kind:'spawned',status:'all',signal:'all',window:'all',sort:'recent'}});
-process.stdout.write(JSON.stringify({{ids:result.rows.map(row=>row.id),models:subagentModelDistribution(result.rows)}}));
-"""
-        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        payload = json.loads(completed.stdout)
-        self.assertEqual(payload["ids"], ["1", "2", "3"])
-        self.assertEqual(len(payload["models"]), 2)
-        self.assertEqual(payload["models"][0]["runtime"], "codex")
-        self.assertEqual(payload["models"][0]["runs"], 2)
-        self.assertEqual(payload["models"][0]["costCovered"], 1)
-        self.assertEqual(payload["models"][0]["cost"], 2)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_session_rows_keep_spawned_run_count(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const selectedSubagentId='',expandedSubagentRoot='not-this-root';
-const esc=value=>String(value),f=value=>String(value),countWord=(value,word)=>value===1?word:`${{word}}s`,money=value=>`$${{Number(value).toFixed(2)}}`,compactNumber=value=>String(value),currentSessionAge=()=> 'now',durationShort=value=>`${{value}}s`;
-const agentIdentityPresentation=(row)=>({{primary:row.role||row.label,secondary:''}}),subagentParentPresentation=()=>({{title:'Parent run',project:'token-meter'}});
-eval(extract('groupSubagentSessions'));
-eval(extract('subagentCostHeat'));
-eval(extract('subagentGroupHtml'));
-const rows=[
- {{id:'a',role:'reviewer',kind:'spawned',activity_state:'complete',model:'gpt',cost:1,cost_available:true,tokens:10,tokens_available:true,work_time_s:600,attention:[]}},
- {{id:'b',role:'tester',kind:'spawned',activity_state:'incomplete',model:'gpt',cost:2,cost_available:true,tokens:20,tokens_available:true,work_time_s:null,attention:[]}},
-];
-rows.forEach(row=>{{row.root_session_id='root';row.project='/token-meter';}});
-const html=subagentGroupHtml(groupSubagentSessions(rows,false,'work')[0],0,new Map(),false);
-process.stdout.write(JSON.stringify({{html}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertIn("Spawned runs", payload["html"])
-        self.assertIn("<b>2</b>", payload["html"])
-        self.assertIn("Work time", payload["html"])
-        self.assertIn("600s", payload["html"])
-        self.assertIn("work time --", payload["html"])
-        self.assertIn("subagentCostHeat", payload["html"])
-        self.assertIn("--cost-fill:100%", payload["html"])
-        self.assertNotIn("Need review", payload["html"])
-        self.assertNotIn("Needs attention", payload["html"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_cost_color_is_relative_and_unavailable_cost_is_neutral(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('subagentCostHeat'));
-process.stdout.write(JSON.stringify({{low:subagentCostHeat(1,10,true),high:subagentCostHeat(10,10,true),missing:subagentCostHeat(null,10,false)}}));
-"""
-        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        result = json.loads(completed.stdout)
-        self.assertIn("--cost-fill:10%", result["low"])
-        self.assertIn("--cost-fill:100%", result["high"])
-        self.assertNotEqual(result["low"], result["high"])
-        self.assertEqual(result["missing"], "")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_role_name_search_keeps_exact_cost_trend_and_comparison(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(['selectSubagentUsageScope','subagentRoleKey','subagentRoleFineFilters','subagentRoleDayRows','buildSubagentRoleEconomics','buildSubagentModelTrends','subagentModelDayRows','subagentModelKey'].map(extract).join('\\n'));
-const reviewer={{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',agents:2,known_cost:4,cost_available:true,cost_covered_agents:2}};
-const tester={{runtime:'codex',kind:'spawned',role:'token_meter_tester',agents:1,known_cost:9,cost_available:true,cost_covered_agents:1}};
-const usage={{scopes:[{{runtime:'',project:'',window:'7d',roles:[reviewer,tester],comparison:{{roles:[{{...reviewer,agents:1,known_cost:3,cost_covered_agents:1}},tester]}}}}],role_days:[{{...reviewer,day:'2026-09-27'}},{{...tester,day:'2026-09-27'}}]}};
-const filters={{query:'reviewer',runtime:'',project:'',window:'7d',model:'',status:'all',signal:'all'}};
-process.stdout.write(JSON.stringify(buildSubagentRoleEconomics(usage,filters,Date.parse('2026-09-28T12:00:00'))));
-"""
-        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        result = json.loads(completed.stdout)
-        self.assertIsNone(result["reason"])
-        self.assertEqual(result["runs"], 2)
-        self.assertEqual(result["cost"], 4)
-        self.assertEqual(result["previousCost"], 3)
-        self.assertEqual([row["role"] for row in result["roles"]], ["token_meter_reviewer"])
-        self.assertEqual([row["role"] for row in result["days"]], ["token_meter_reviewer"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_table_reports_total_covered_spend(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,compactNumber=value=>String(value),appFilterLabel=({{provider}})=>provider;
-eval(extract('buildSubagentRoleRows'));
-eval(extract('renderSubagentRoles'));
-const html=renderSubagentRoles([
- {{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt',activity_state:'complete',cost:1,cost_available:true,tokens:100,tokens_available:true,attention:[]}},
- {{runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt',activity_state:'complete',cost:3,cost_available:true,tokens:200,tokens_available:true,attention:[]}},
- {{runtime:'codex',kind:'spawned',role:'token_meter_tester',model:'gpt',activity_state:'complete',cost:null,cost_available:false,tokens:50,tokens_available:true,attention:[]}},
-]);
-process.stdout.write(JSON.stringify({{html}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertIn("Total spend", payload["html"])
-        self.assertIn("$4.00", payload["html"])
-        self.assertIn("token_meter_tester", payload["html"])
-        self.assertIn("<b>--</b>", payload["html"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_economics_compares_spend_volume_and_cost_per_run(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(['selectSubagentUsageScope','subagentRoleKey','subagentRoleFineFilters','subagentRoleDayRows','buildSubagentRoleEconomics','buildSubagentModelTrends','subagentModelDayRows','subagentModelKey'].map(extract).join('\\n'));
-const current=[
- {{id:'reviewer::codex::spawned',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost:6,cost_available:true,cost_covered_agents:2,known_tokens:600,tokens:600,tokens_available:true,token_covered_agents:2,median_cost:3,p95_cost:4,incomplete_agents:1,attention_agents:1}},
- {{id:'tester::codex::spawned',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost:2,cost_available:true,cost_covered_agents:1,known_tokens:200,tokens:200,tokens_available:true,token_covered_agents:1,median_cost:2,p95_cost:2,incomplete_agents:0,attention_agents:0}},
-];
-const previous=[
- {{id:'reviewer::codex::spawned',runtime:'codex',kind:'spawned',role:'reviewer',agents:1,known_cost:8,cost:8,cost_available:true,cost_covered_agents:1,median_cost:8,p95_cost:8,incomplete_agents:0,attention_agents:0}},
-];
-const usage={{scopes:[{{window:'7d',runtime:'codex',project:'/repo',roles:current,comparison:{{roles:previous}}}}],role_day_count:2,role_days_truncated:false,role_days:[
- {{day:'2026-09-24',project:'/repo',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true,cost_covered_agents:2}},
- {{day:'2026-09-23',project:'/repo',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost_available:true,cost_covered_agents:1}},
-]}};
-const base={{query:'',runtime:'codex',project:'/repo',model:'',status:'all',signal:'all',window:'7d',sort:'recent'}};
-const result=buildSubagentRoleEconomics(usage,base,Date.parse('2026-09-24T12:00:00'));
-const partial=buildSubagentRoleEconomics({{...usage,scopes:[{{...usage.scopes[0],roles:[{{...current[0],known_cost:3,cost:null,cost_available:false,cost_covered_agents:1}}]}}]}},base,Date.parse('2026-09-24T12:00:00'));
-const uncovered=buildSubagentRoleEconomics({{...usage,scopes:[{{...usage.scopes[0],roles:[{{...current[0],known_cost:0,cost:null,cost_available:false,cost_covered_agents:0}}]}}]}},base,Date.parse('2026-09-24T12:00:00'));
-const filtered=buildSubagentRoleEconomics(usage,{{...base,status:'incomplete'}},Date.parse('2026-09-24T12:00:00'));
-process.stdout.write(JSON.stringify({{result,partial,uncovered,filtered}}));
-"""
-        completed = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        payload = json.loads(completed.stdout)
-
-        result = payload["result"]
-        self.assertEqual(result["runs"], 3)
-        self.assertEqual(result["cost"], 8)
-        self.assertAlmostEqual(result["averageCost"], 8 / 3)
-        self.assertEqual(result["previousRuns"], 1)
-        self.assertEqual(result["previousCost"], 8)
-        self.assertEqual(result["costChange"], 0)
-        self.assertAlmostEqual(result["averageCostChange"], -2 / 3)
-        reviewer = next(row for row in result["roles"] if row["role"] == "reviewer")
-        self.assertEqual(reviewer["costChange"], -0.25)
-        self.assertEqual(reviewer["runChange"], 1)
-        self.assertEqual(payload["partial"]["cost"], 3)
-        self.assertEqual(payload["partial"]["costCovered"], 1)
-        self.assertEqual(payload["partial"]["averageCost"], 3)
-        self.assertIsNone(payload["partial"]["costChange"])
-        self.assertIsNone(payload["partial"]["averageCostChange"])
-        self.assertIsNone(payload["uncovered"]["cost"])
-        self.assertIsNone(payload["uncovered"]["averageCost"])
-        self.assertEqual(payload["filtered"]["reason"], "filtered")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_economics_renders_a_clear_chart_for_each_role(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,appFilterLabel=({{provider}})=>provider;
-let subagentRoleChartMode='average';
-eval(['subagentRoleKey','renderSubagentRoleSparkline','renderSubagentRoleEconomics','renderSubagentTrendSparkline','renderSubagentModelTrends','subagentModelKey'].map(extract).join('\\n'));
-const economics={{reason:null,window:'7d',runs:3,cost:8,averageCost:8/3,costCovered:3,previousRuns:1,previousCost:8,costChange:0,averageCostChange:-2/3,runChange:2,incomplete:1,attention:1,previousIncomplete:0,roles:[
- {{id:'reviewer::codex::spawned',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost:6,cost_available:true,cost_covered_agents:2,known_tokens:600,tokens_available:true,token_covered_agents:2,median_cost:3,p95_cost:4,incomplete_agents:1,attention_agents:1,costChange:-.25,runChange:1,averageCostChange:-.625}},
- {{id:'tester::codex::spawned',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost:2,cost_available:true,cost_covered_agents:1,known_tokens:200,tokens_available:true,token_covered_agents:1,median_cost:2,p95_cost:2,incomplete_agents:0,attention_agents:0,costChange:.2,runChange:0,averageCostChange:.2}},
-],days:[
- {{day:'2026-09-23',runtime:'codex',kind:'spawned',role:'reviewer',agents:1,known_cost:4,cost_available:true,cost_covered_agents:1}},
- {{day:'2026-09-24',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true,cost_covered_agents:2}},
- {{day:'2026-09-23',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:1,cost_available:true,cost_covered_agents:1}},
- {{day:'2026-09-24',runtime:'codex',kind:'spawned',role:'tester',agents:1,known_cost:2,cost_available:true,cost_covered_agents:1}},
-]}};
-const partial=renderSubagentRoleEconomics({{...economics,runs:2,cost:3,averageCost:3,costCovered:1,costChange:null,averageCostChange:null}});
-const allHistory=renderSubagentRoleEconomics({{...economics,window:'all',previousRuns:null,previousCost:null,costChange:null,averageCostChange:null,runChange:null,roles:economics.roles.map(row=>({{...row,costChange:null,averageCostChange:null,runChange:null}}))}});
-process.stdout.write(JSON.stringify({{html:renderSubagentRoleEconomics(economics),partial,allHistory}}));
-"""
-        completed = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        payload = json.loads(completed.stdout)
-
-        html = payload["html"]
-        self.assertIn("Role trends", html)
-        self.assertIn("Cost / run", html)
-        self.assertEqual(html.count("<svg"), 2)
-        self.assertIn('aria-label="reviewer cost per run trend"', html)
-        self.assertIn('aria-label="tester cost per run trend"', html)
-        self.assertLess(html.index('subagentRoleKpi'), html.index('Role spend'))
-        self.assertLess(html.index('Cost / run'), html.index('Role spend'))
-        self.assertIn('2026-09-23', html)
-        self.assertIn('2026-09-24', html)
-        self.assertNotIn('>1 review<', html)
-        self.assertIn("data-subagent-inspect-role=", html)
-        self.assertIn("reviewer", html)
-        self.assertIn("tester", html)
-        self.assertIn("View runs", html)
-        self.assertNotIn("What changed", html)
-        self.assertNotIn("Role spend over time", html)
-        self.assertIn("Covered role spend", payload["partial"])
-        self.assertIn("Cost / covered run", payload["partial"])
-        self.assertIn("$3.00", payload["partial"])
-        self.assertIn("1 / 2 cost-covered", payload["partial"])
-        self.assertIn("Named runs", payload["partial"])
-        self.assertNotIn("No comparable baseline", payload["allHistory"])
-        self.assertNotIn("<small>--</small>", payload["allHistory"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_economics_withholds_truncated_period_insights(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const esc=value=>String(value),f=value=>String(value),pct=value=>`${{Math.round(value*100)}}%`,money=value=>`$${{Number(value).toFixed(2)}}`,appFilterLabel=({{provider}})=>provider;
-let subagentRoleChartMode='spend';
-eval(['subagentRoleKey','renderSubagentRoleSparkline','renderSubagentRoleEconomics','renderSubagentTrendSparkline','renderSubagentModelTrends','subagentModelKey'].map(extract).join('\\n'));
-const economics={{reason:null,window:'7d',runs:2,cost:6,averageCost:3,costCovered:2,previousRuns:1,previousCost:2,costChange:2,averageCostChange:.5,runChange:1,incomplete:0,attention:0,previousIncomplete:0,trendTruncated:true,roles:[
- {{runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true,cost_covered_agents:2,median_cost:3,p95_cost:4,incomplete_agents:0,attention_agents:0,costChange:2,runChange:1}},
-],days:[{{day:'2026-09-24',runtime:'codex',kind:'spawned',role:'reviewer',agents:2,known_cost:6,cost_available:true}}]}};
-const spend=renderSubagentRoleEconomics(economics);
-subagentRoleChartMode='runs';
-const runs=renderSubagentRoleEconomics(economics);
-process.stdout.write(JSON.stringify({{spend,runs}}));
-"""
-        completed = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        payload = json.loads(completed.stdout)
-        for html in payload.values():
-            self.assertIn("Trend unavailable", html)
-            self.assertIn("daily history was truncated", html)
-            self.assertNotIn("What changed", html)
-            self.assertNotIn("Higher spend for reviewer", html)
-        self.assertNotIn("+1 vs prior", payload["runs"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_role_charts_do_not_hide_lower_spend_roles(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const esc=value=>String(value);
-let subagentRoleChartMode='spend';
-eval(['subagentRoleKey','renderSubagentRoleSparkline','renderSubagentTrendSparkline'].map(extract).join('\\n'));
-const roles=Array.from({{length:6}},(_,index)=>({{runtime:'codex',kind:'spawned',role:`role_${{index+1}}`}}));
-const days=roles.map((row,index)=>({{day:'2026-09-24',...row,agents:1,known_cost:6-index,cost_available:true}}));
-process.stdout.write(roles.map(row=>renderSubagentRoleSparkline({{trendTruncated:false,days}},row)).join(''));
-"""
-        completed = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        self.assertEqual(completed.stdout.count("<svg"), 6)
-        self.assertIn('aria-label="role_5 spend trend"', completed.stdout)
-        self.assertIn('aria-label="role_6 spend trend"', completed.stdout)
-        self.assertNotIn("Other roles", completed.stdout)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_workspace_groups_parent_sessions_and_prioritizes_issues(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('groupSubagentSessions'));
-const rows=[
- {{id:'quiet',root_session_id:'root-quiet',project:'/quiet',activity_state:'complete',last_activity_at:300,cost:10,cost_available:true,attention:[]}},
- {{id:'incomplete',root_session_id:'root-incomplete',project:'/work',activity_state:'incomplete',last_activity_at:200,cost:4,cost_available:true,attention:[]}},
- {{id:'attention-2',root_session_id:'root-attention',project:'/work',activity_state:'complete',last_activity_at:90,cost:null,cost_available:false,attention:[]}},
- {{id:'attention',root_session_id:'root-attention',project:'/work',activity_state:'complete',last_activity_at:100,cost:1,cost_available:true,attention:[{{code:'peer_cost_outlier'}}]}},
-];
-process.stdout.write(JSON.stringify({{issues:groupSubagentSessions(rows,true),sessions:groupSubagentSessions(rows,false)}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-
-        self.assertEqual(
-            [row["rootSessionId"] for row in payload["issues"]],
-            ["root-attention", "root-incomplete"],
-        )
-        self.assertEqual(len(payload["sessions"]), 3)
-        attention = payload["issues"][0]
-        self.assertEqual(attention["agents"], 2)
-        self.assertEqual(attention["attention"], 1)
-        self.assertEqual(attention["incomplete"], 0)
-        self.assertEqual(attention["costCovered"], 1)
-        self.assertEqual(attention["cost"], 1)
-        self.assertEqual(
-            [row["id"] for row in attention["rows"]],
-            ["attention", "attention-2"],
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_roles_preserve_runtime_kind_and_calculate_review_metrics(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('buildSubagentRoleRows'));
-const rows=[
- {{id:'a',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-a',activity_state:'complete',cost:1,cost_available:true,tokens:100,tokens_available:true,attention:[]}},
- {{id:'b',runtime:'codex',kind:'spawned',role:'token_meter_reviewer',model:'gpt-a',activity_state:'incomplete',cost:3,cost_available:true,tokens:300,tokens_available:true,attention:[{{code:'retry_pressure'}}]}},
- {{id:'c',runtime:'claude',kind:'spawned',role:'token_meter_reviewer',model:'opus',activity_state:'complete',cost:8,cost_available:true,tokens:800,tokens_available:true,attention:[]}},
- {{id:'d',runtime:'codex',kind:'spawned',role:null,model:'gpt-a',activity_state:'complete',cost:5,cost_available:true,tokens:500,tokens_available:true,attention:[]}},
-];
-process.stdout.write(JSON.stringify(buildSubagentRoleRows(rows)));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-
-        self.assertEqual(len(payload), 2)
-        claude, codex = payload
-        self.assertEqual((claude["runtime"], claude["role"]), ("claude", "token_meter_reviewer"))
-        self.assertEqual((codex["runtime"], codex["kind"]), ("codex", "spawned"))
-        self.assertEqual(codex["agents"], 2)
-        self.assertEqual(codex["incomplete"], 1)
-        self.assertEqual(codex["attention"], 1)
-        self.assertEqual(codex["incompleteRate"], 0.5)
-        self.assertEqual(codex["attentionRate"], 0.5)
-        self.assertEqual(codex["medianCost"], 2)
-        self.assertEqual(codex["p95Cost"], 3)
-        self.assertEqual(codex["knownTokens"], 400)
-        self.assertEqual(codex["topModel"], "gpt-a")
-
-    def test_sessions_all_uses_exact_coverage_copy_without_ambiguous_suffixes(self):
-        start = self.page.index("function renderAllSessionStats(")
-        end = self.page.index("function currentSessionAge(", start)
-        block = self.page[start:end]
-        self.assertIn("sessionCoverageCopy", block)
-        self.assertNotIn("?' partial'", block)
-        self.assertNotIn(" incl. est", block)
-
-        start = self.page.index("function renderSubagentUsage(")
-        end = self.page.index("function renderAllSessions(", start)
-        subagent_block = self.page[start:end]
-        self.assertIn("group_cost_covered_sessions", subagent_block)
-        self.assertIn("parent sessions have complete group cost", subagent_block)
-        self.assertNotIn("group-cost coverage", subagent_block)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_browser_agent_attention_adds_cap_and_live_growth_only_with_cost_evidence(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(page.match(/^const money=.*$/m)[0].replace('const money','globalThis.money'));
-eval(extract('deriveAgentAttention'));
-const group={{root_session_id:'root',totals:{{cost:2,cost_available:true}},agents:[
- {{id:'root',kind:'root',cost:0.5,cost_available:true,activity_state:'recent'}},
- {{id:'child',kind:'spawned',cost:1.5,cost_available:true,activity_state:'working'}}
-],attention:[{{agent_id:'child',level:'needs_attention',reasons:[{{code:'retry_pressure',explanation:'3 retries'}}]}}]}};
-const covered=deriveAgentAttention(group,1,new Map([['root:child',1.0]]));
-const partial=deriveAgentAttention({{...group,totals:{{cost:null,cost_available:false}},agents:[group.agents[0],{{...group.agents[1],cost:null,cost_available:false}}]}},1,new Map([['root:child',1.0]]));
-process.stdout.write(JSON.stringify({{covered,partial}}));
-"""
-
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        covered = {
-            row["agent_id"]: [reason["code"] for reason in row["reasons"]]
-            for row in payload["covered"]
-        }
-        partial = {
-            row["agent_id"]: [reason["code"] for reason in row["reasons"]]
-            for row in payload["partial"]
-        }
-        self.assertEqual(covered["root"], ["cap_exceeded"])
-        self.assertEqual(covered["child"], [
-            "retry_pressure", "cap_exceeded", "observed_live_growth",
-        ])
-        self.assertEqual(partial["child"], ["retry_pressure"])
-        self.assertNotIn("root", partial)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_subagent_usage_scope_supports_project_filters_and_blocks_text_search(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('selectSubagentUsageScope'));
-const usage={{totals:{{agents:9}},scope_truncated:false,scopes:[
- {{window:'all',runtime:'',project:'',totals:{{agents:9}}}},
- {{window:'7d',runtime:'codex',project:'~/Documents/github/token-meter',totals:{{agents:2}}}},
-]}};
-process.stdout.write(JSON.stringify({{
- supported:selectSubagentUsageScope(usage,'codex','7d','~/Documents/github/token-meter',false),
- blocked:selectSubagentUsageScope(usage,'codex','7d','~/Documents/github/token-meter',true),
- missing:selectSubagentUsageScope(usage,'codex','7d','~/Documents/github/luna-3',false),
- truncated:selectSubagentUsageScope({{...usage,scope_truncated:true}},'codex','7d','~/Documents/github/luna-3',false),
-}}));
-"""
-
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertIsNotNone(payload["supported"]["usage"])
-        self.assertEqual(payload["supported"]["usage"]["totals"]["agents"], 2)
-        self.assertIsNone(payload["supported"]["reason"])
-        self.assertIsNone(payload["blocked"]["usage"])
-        self.assertEqual(payload["blocked"]["reason"], "filtered")
-        self.assertIsNone(payload["missing"]["usage"])
-        self.assertEqual(payload["missing"]["reason"], "empty")
-        self.assertIsNone(payload["truncated"]["usage"])
-        self.assertEqual(payload["truncated"]["reason"], "unavailable")
-
-    def test_current_header_keeps_one_line_session_start_message_visible(self):
-        self.assertIn('class="card previewStartStrip"', self.page)
-        self.assertIn("id=preview-start", self.page)
-        self.assertIn("function sessionStartMessage(s)", self.page)
-        self.assertIn("$('preview-start').textContent=startMessage", self.page)
-        current = self.page.split('<div class="view on" id=view-session>', 1)[1].split(
-            "<div class=view id=view-models>", 1
-        )[0]
-        self.assertLess(current.index("id=preview-start"), current.index("id=preview-run-chart-slot"))
-        self.assertIn("text-overflow:ellipsis;white-space:nowrap", self.page)
-
-    def test_current_output_card_shows_trace_backed_output_speed(self):
-        for marker in ("id=preview-speed", "s.throughput||{}", "speedFmt(throughput.output_tps)",
-                       "tool-free", "end-to-end", "reasoning and thinking output",
-                       "external tool-result tokens"):
-            self.assertIn(marker, self.page)
-        self.assertIn(".previewSpeed .v{color:var(--accent)", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_unavailable_cost_value_explains_why_it_is_not_zero(self):
-        match = re.search(
-            r"const COST_UNAVAILABLE_TIP=.*?^function setCostValue\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs an unavailable-cost helper")
-        script = """
-const element={classList:{values:new Set(),toggle(name,on){on?this.values.add(name):this.values.delete(name);}},attributes:{},setAttribute(name,value){this.attributes[name]=String(value);},removeAttribute(name){delete this.attributes[name];}};
-const $=id=>element;
-""" + match.group(0) + """
-setCostValue('cost','$1.25',true);
-const available={text:element.textContent,classes:[...element.classList.values],attributes:{...element.attributes}};
-setCostValue('cost','$1.25',false);
-console.log(JSON.stringify({available,unavailable:{text:element.textContent,classes:[...element.classList.values],attributes:{...element.attributes}}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["available"], {
-            "text": "$1.25", "classes": [], "attributes": {},
-        })
-        self.assertEqual(rendered["unavailable"]["text"], "--")
-        self.assertEqual(rendered["unavailable"]["classes"], ["fieldtip"])
-        self.assertIn("not $0", rendered["unavailable"]["attributes"]["data-tip"])
-        self.assertIn("locally stored usage", rendered["unavailable"]["attributes"]["aria-description"])
-
-    def test_cross_session_cost_placeholders_share_the_unavailable_cost_explanation(self):
-        for renderer, helper in (
-            ("function logRowContent(s){", "costValueHtml("),
-            ("function renderAllSessionStats(sessions){", "costValueHtml("),
-            ("function renderCurrentDaySummary(xs){", "setCostValue("),
-            ("function renderSpend(xs){", "setCostValue("),
-            ("function renderCurrentSessions(state=LATEST){", "costValueHtml("),
-        ):
-            section = self.page.split(renderer, 1)[1].split("\nfunction ", 1)[0]
-            self.assertIn(helper, section, renderer)
-
-    def test_current_session_cost_tooltip_does_not_add_a_nested_tab_stop(self):
-        session_cards = self.page.split("function renderCurrentSessions(state=LATEST){", 1)[1].split(
-            "const currentSessionGrid=$('current-session-grid');", 1
-        )[0]
-        self.assertIn("costValueHtml(money(row.cost)+(estimate?' est':''),costAvailable,false),costLabel=costPartial?'Cost, at least':'Cost'", session_cards)
-        self.assertIn("const costTipAttrs=costAvailable?'':costUnavailableAttrs();", session_cards)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_active_session_surfaces_prefer_live_throughput(self):
-        match = re.search(
-            r"function sessionDisplayThroughput\(session\)\{.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs one shared speed selector")
-        script = match.group(0) + """
-const completed = {throughput:{available:true,output_tps:85.4},live_throughput:{available:false}};
-const active = {throughput:{available:true,output_tps:85.4},live_throughput:{available:true,output_tps:41.2}};
-console.log(JSON.stringify({
-  completed: sessionDisplayThroughput(completed).output_tps,
-  active: sessionDisplayThroughput(active).output_tps,
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "completed": 85.4,
-            "active": 41.2,
-        })
-        self.assertGreaterEqual(self.page.count("sessionDisplayThroughput(s)"), 2)
-        self.assertIn("sessionDisplayThroughput(row)", self.page)
-
-    def test_session_detail_is_one_run_surface_without_subtabs(self):
-        for marker in (
-            "id=current-tabs", "data-current-panel=", "id=preview-surface-activity",
-            "id=preview-surface-tools", "id=preview-surface-insights",
-            "id=preview-surface-alerts", "id=panel-activity", "id=panel-tools",
-            "id=panel-insights", "id=panel-alerts", "function renderTrace(",
-            "function renderTools(",
-        ):
-            self.assertNotIn(marker, self.page)
-        self.assertIn("const PANEL_KEYS=['summary'];", self.page)
-        self.assertIn("const CURRENT_PANEL_KEYS=['sessions','run'];", self.page)
-        for removed_route in ("activity", "tools", "alerts"):
-            self.assertIn(f"{removed_route}:'summary'", self.page)
-        self.assertNotIn("insights:'summary'", self.page)
-        self.assertNotIn("efficiency:'summary'", self.page)
-
-    def test_codex_session_detail_links_to_the_desktop_thread(self):
-        for marker in (
-            'id=session-desktop-link',
-            'aria-label="Open this session in the Codex desktop app"',
-            'function desktopSessionTarget(session)',
-            "provider==='codex'",
-            'codex://threads/${encodeURIComponent(id)}',
-            'function renderDesktopSessionLink(session)',
-            'link.hidden=!target',
-            "link.removeAttribute('href')",
-            'renderDesktopSessionLink(s);',
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_claude_sessions_link_to_the_desktop_code_session(self):
-        for marker in (
-            "provider==='claude'",
-            "/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i",
-            'claude://resume?session=${encodeURIComponent(resume)}',
-            "label:'Open in Claude'",
-            "label:'Open in Codex'",
-            'link.textContent=target.label',
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_current_session_cards_offer_a_sibling_desktop_link(self):
-        render = self.page[self.page.index("function renderCurrentSessions("):]
-        render = render[:render.index("\nfunction ")]
-        self.assertIn("desktopSessionTarget(row)", render)
-        self.assertIn('<div class=currentSessionSlot', render)
-        self.assertIn('class=currentSessionDesktop', render)
-        self.assertIn('draggable=false', render)
-        self.assertIn("</button>${desktopLink}</div>", render)
-        self.assertIn(".currentSessionSlot{", self.page)
-        self.assertIn(".currentSessionDesktop{", self.page)
-
-    def test_browser_operational_alerts_are_budget_only(self):
-        self.assertNotIn("function isNotifiableInsight(i)", self.page)
-        self.assertNotIn("fireNotification('Token insight'", self.page)
-        self.assertNotIn("id=spike", self.page)
-        self.assertNotIn("tm_spike", self.page)
-        self.assertNotIn("s.last_turn_cost>spike", self.page)
-        self.assertIn(
-            "fireNotification('Token Meter session budget'",
-            self.page,
-        )
-        self.assertIn(
-            "fireNotification(isExceeded?'Token Meter budget exceeded':'Token Meter monthly budget'",
-            self.page,
-        )
-        self.assertIn("n.title!=='Token insight'", self.page)
-        self.assertIn(
-            "String(n.body||'').startsWith('Last execution cost ')",
-            self.page,
-        )
-        settings = self.page[self.page.index("id=view-settings"):]
-        rail = self.page[self.page.index("<div class=top aria-label="):self.page.index("<div id=session-depot")]
-        for marker in (
-            "class=budgetBrowserAlerts", "class=budgetBrowserAlertsCopy",
-            "Browser delivery",
-        ):
-            self.assertNotIn(marker, settings)
-        for marker in (
-            "id=panel-alerts", "id=notify role=switch", "id=notify-test",
-            "id=notify-log", 'aria-label="Toggle browser budget alerts"',
-        ):
-            self.assertNotIn(marker, self.page)
-        self.assertNotIn("id=notify", rail)
-
-    def test_budget_alert_controls_share_the_set_budgets_header(self):
-        config = self.page[
-            self.page.index('id=budget-config'):
-            self.page.index('class="budgetFormGroup budgetRuntimeFields"')
-        ]
-        header = config[
-            config.index("class=budgetConfigHead"):
-            config.index("class=budgetFormGroup")
-        ]
-
-        self.assertIn("Set budgets</h2>", header)
-        self.assertIn("class=budgetAlertInline", header)
-        self.assertIn("class=budgetThresholds", header)
-        self.assertIn("id=budget-input-threshold-early", header)
-        self.assertIn("id=budget-input-threshold-mid", header)
-        self.assertIn("id=budget-input-threshold-full", header)
-        self.assertIn("class=budgetNotifySwitch", header)
-        self.assertIn("class=sw aria-hidden=true", header)
-        self.assertIn("id=budget-input-notifications", header)
-        self.assertNotIn("Default for sessions without a saved cap.", config)
-        self.assertNotIn("Browser delivery", config)
-
-    def test_monthly_budget_alerts_recover_missed_exceeded_state(self):
-        for marker in (
-            "function budgetExceededAlertState()",
-            "tm_monthly_budget_exceeded_alerts",
-            "previous=state[status.month]",
-            "Array.isArray(previous)?previous",
-            "over=Number((status.alert_percent??status.percent)||0)>=1",
-            "exceededState=budgetExceededAlertState()",
-            "monthExceeded.inApp===true",
-            "monthExceeded.browser===true",
-            "deliverMissedBrowserAlert",
-            "notifyOn&&canNotify&&Notification.permission==='granted'",
-            "Token Meter budget exceeded",
-            "requireInteraction:isExceeded",
-            "pushAppNotice(title,body",
-            "state[status.month]=[...new Set([...seen,...crossed])]",
-            "inApp:inAppNotified||alertExceeded",
-            "browser:browserNotified||deliverMissedBrowserAlert",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn(
-            "status.settings?.native_notifications===false",
-            self.page,
-        )
-        self.assertNotIn(
-            "if(!Array.isArray(seen)){state[status.month]=crossed",
-            self.page,
-        )
-
-    def test_old_current_summary_is_only_a_hidden_renderer_depot(self):
-        for marker in (
-            "id=session-depot hidden", "id=usage-details", "tm_usage_details_open",
-            "id=cost", "id=input-tok", "id=output-tok", "id=output-tps",
-            "id=ov-duration", "id=ov-context",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("class=view id=session-depot", self.page)
-        self.assertNotIn("class=\"view on\" id=session-depot", self.page)
-
-    def test_current_summary_keeps_session_budget_slider(self):
-        summary = self.page[
-            self.page.index("id=panel-summary"):
-            self.page.index("<div class=foot>")
-        ]
-        for marker in (
-            "id=session-budget-control", "id=budget-slider type=range",
-            "id=budget type=number", "id=session-budget-spend",
-            "function syncSessionBudgetControls", "function persistSessionBudget",
-            "function queueSessionBudget", "const sessionBudgetWrites=new Map()",
-            "'/settings/session-budget'", "s?.session_budget?.budget_usd",
-            "$('budget-slider').addEventListener('input'",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("id=budget-slider type=range", summary)
-        self.assertIn("id=budget type=number", summary)
-        self.assertNotIn("id=panel-alerts", self.page)
-        self.assertNotIn("Only budget crossings create alerts.", self.page)
-        self.assertNotIn(
-            "Set a live-run cap without changing the machine-wide monthly budget.",
-            summary,
-        )
-
-    def test_execution_chart_marks_a_single_observed_value(self):
-        chart = self.page[
-            self.page.index("function drawIO(series)"):
-            self.page.index("function renderOverview(s)")
-        ]
-        self.assertIn("const validPoints=[]", chart)
-        self.assertIn("validPoints.length===1", chart)
-        self.assertIn("const singlePoint=", chart)
-
-    def test_settings_default_session_budget_preserves_saved_session_caps(self):
-        for marker in (
-            "id=budget-input-session-default",
-            "Default session budget",
-            "function sessionBudgetForSession(s)",
-            "defaultSessionBudget=Number(settings.default_session_budget||10)",
-            "s?.session_budget?.budget_usd",
-            "legacySessionBudgets",
-            "default_session_budget:budgetNumber('budget-input-session-default')",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_session_budget_writes_are_serialized_and_migration_is_superseded(self):
-        budget = self.page[
-            self.page.index("const SESSION_BUDGET_SLIDER_MIN"):
-            self.page.index("function dollarInputValue")
-        ]
-        self.assertIn("while(entry.pending)", budget)
-        self.assertIn("if(entry.saving)return entry.promise", budget)
-        self.assertIn("queueSessionBudget(CURRENT,n)", budget)
-        self.assertIn(
-            "syncSessionBudgetControls(sessionBudgetForSession(s),s)", budget,
-        )
-
-    def test_promoted_current_is_dense_complete_and_settings_stay_dedicated(self):
-        for marker in (
-            "id=tab-session", 'class="view on" id=view-session',
-            "id=preview-run-chart-slot",
-            "id=preview-run-budget-slot", "id=preview-token-split-slot",
-            "id=preview-surface-run",
-            "id=session-token-split-home", "id=session-token-split-module",
-            "class=\"card previewStartStrip\"", "class=settingsPageLayout",
-            "class=\"card settingsMap\"", "data-settings-target=agent-access",
-            "function restoreCurrentModules()", "function showCurrentPanel(panel)",
-            "function renderCurrentRun(s)",
-            "if(h==='preview-settings')", "setHashRoute('settings',{replace:true,apply:false})",
-            "const legacyCurrentRoutes={preview:'summary','preview-run':'summary'",
-        ):
-            self.assertIn(marker, self.page)
-        for metric_id in (
-            "preview-speed", "preview-wait",
-            "preview-context", "preview-executions", "preview-tools",
-            "preview-tool-results", "preview-cache-rate", "preview-cache-saved",
-            "preview-burn", "preview-cost-task", "preview-started-at",
-            "preview-last-at",
-        ):
-            self.assertIn(f"id={metric_id}", self.page)
-        for removed_id in (
-            "preview-input", "preview-output", "preview-thinking", "preview-avg-cost",
-        ):
-            self.assertNotIn(f"id={removed_id}", self.page)
-        for unique_id in (
-            "iochart", "sembar", "session-token-split-module", "budget", "agent-access",
-            "model-pricing-settings", "update-settings",
-        ):
-            self.assertEqual(
-                len(re.findall(rf"\bid={re.escape(unique_id)}(?:\s|>)", self.page)),
-                1,
-                f"{unique_id} must be moved, not cloned",
-            )
-        self.assertNotIn("id=tab-preview", self.page)
-        self.assertNotIn("id=view-preview", self.page)
-        current = self.page.split('<div class="view on" id=view-session>', 1)[1].split(
-            "<div class=view id=view-models>", 1
-        )[0]
-        self.assertNotIn("Settings map", current)
-        self.assertNotIn("id=agent-access", current)
-        self.assertNotIn("id=frustration-settings", current)
-        self.assertNotIn("id=model-pricing-settings", current)
-        self.assertNotIn("What needs attention", current)
-        self.assertNotIn("Open original Current", current)
-        self.assertNotIn("Experimental", current)
-        self.assertNotIn("Current preview", current)
-        self.assertNotIn("previewKpi fieldtip", current)
-        self.assertLess(current.index("id=preview-start"), current.index("id=preview-run-chart-slot"))
-        self.assertLess(
-            current.index("id=preview-run-chart-slot"),
-            current.index("id=preview-token-split-slot"),
-        )
-        self.assertIn("previewSpeed", current)
-        self.assertIn("text-overflow:ellipsis;white-space:nowrap", self.page)
-        self.assertIn(
-            "if(t!=='session')restoreCurrentModules();",
-            self.page,
-        )
-        self.assertIn(
-            "mountCurrentModule('preview-run-chart-slot','session-chart-module')",
-            self.page,
-        )
-        self.assertIn(
-            "mountCurrentModule('preview-token-split-slot','session-token-split-module')",
-            self.page,
-        )
-        self.assertIn(
-            "['session-token-split-home','session-token-split-module']",
-            self.page,
-        )
-        for marker in (
-            "id=current-tabs", "data-current-panel=", "id=preview-activity-slot",
-            "id=preview-tools-slot", "id=preview-efficiency-slot",
-            "id=preview-alerts-slot", "id=preview-surface-activity",
-            "id=preview-surface-tools", "id=preview-surface-insights",
-            "id=preview-surface-alerts", "id=session-activity-home",
-            "id=session-tools-home", "id=session-insights-home",
-            "id=session-alerts-home", "id=panel-activity", "id=panel-tools",
-            "id=panel-insights", "id=panel-alerts",
-            "mountCurrentModule(`preview-${panel}-slot`,`panel-${panel}`)",
-            "const button=event.target.closest('[data-current-panel]');",
-        ):
-            self.assertNotIn(marker, self.page)
-        self.assertIn("const CURRENT_PANEL_KEYS=['sessions','run'];", self.page)
-        self.assertIn("const PANEL_KEYS=['summary'];", self.page)
-        self.assertNotIn("mountCurrentModule('preview-settings", self.page)
-
-    def test_builder_recap_is_a_separate_document(self):
-        primary = self.page.split("<div class=navPrimary>", 1)[1].split("</div>", 1)[0]
-        performance = re.search(
-            r'<a[^>]+id=tab-performance[^>]*>.*?</a>', primary, re.S
-        )
-        self.assertIsNotNone(performance)
-        anchor = performance.group(0)
-        for marker in (
-            "class=tab", "href=/performance", "data-label=Performance",
-            "aria-label=Performance", "<span class=tabLabel>Performance</span>",
-        ):
-            self.assertIn(marker, anchor)
-        self.assertNotIn("aria-keyshortcuts", anchor)
-        self.assertNotIn("tabShortcut", anchor)
-        self.assertLess(primary.index("id=tab-efficiency"), primary.index("id=tab-git"))
-        self.assertLess(primary.index("id=tab-git"), primary.index("id=tab-performance"))
-        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
-            "<div class=view id=view-git>", 1
-        )[0]
-        self.assertNotIn("id=e-builder-recap", efficiency)
-        for rejected in (
-            "id=view-performance-card", "performance-card", ".recapPageHead",
-            "const builderRecapState=", "function drawBuilderRecap(",
-            "recap-canvas", "recap-download",
-        ):
-            self.assertNotIn(rejected, self.page)
-
-    def test_model_stats_is_a_first_class_top_level_route(self):
-        for marker in ("id=tab-models", "id=view-models", "id=m-speed", "id=m-chart",
-                       "id=m-table", "renderModelStats", "aggregateModelDays"):
-            self.assertIn(marker, self.page)
-        self.assertRegex(self.page, r"id=tab-models[^>]*>.*?<span class=tabLabel>Models</span>")
-        self.assertIn("if(routedSessionId()&&history.pushState)", self.page)
-        self.assertIn("$('tab-models').onclick=()=>openTopLevelRoute('models')", self.page)
-        self.assertIn("if(h==='models'||h==='frustration')", self.page)
-        self.assertLess(self.page.index("id=tab-session"), self.page.index("id=tab-models"))
-        self.assertNotIn("Timing evidence", self.page)
-        diagnostics = self.page.split("id=m-diagnostics", 1)[1].split("</details>", 1)[0]
-        self.assertIn("cross-runtime output pace remains diagnostic rather than a model verdict.", diagnostics)
-        self.assertIn("<summary><span>Speed &amp; timing diagnostics</span></summary>", diagnostics)
-        self.assertIn("<tr><td colspan=10><div class=\"modelEmpty emptyState\">No model activity in this window</div>", self.page)
-
-    def test_language_signals_are_removed_from_the_dashboard(self):
-        for removed in (
-            "id=model-frustration", "id=frustration-settings", "id=positive-terms",
-            "id=f-chart", "id=f-collapse", "User language signals", "Language signals",
-            "/settings/language-signals", "renderFrustration", "language_signals",
-            "frustrationSection", "signalPanel", "tm_language_signals_collapsed",
-        ):
-            self.assertNotIn(removed, self.page)
-        self.assertIn("if(h==='models'||h==='frustration'){", self.page)
-        self.assertIn("if(h==='frustration')setHashRoute('models',{replace:true,apply:false});", self.page)
-        self.assertIn(".signalEmpty{", self.page)
-        self.assertIn(
-            "body.spectrumApp :is(.sessionStart,.toast,.capReview,.agentDiscovery,.previewStartStrip,.modelScopeStatus){border-left-width:1px}",
-            self.page,
-        )
-
-    def test_models_page_is_a_ranked_spend_leaderboard(self):
-        models = self.page.split("id=view-models", 1)[1].split("id=view-daily", 1)[0]
-        order = [models.index(marker) for marker in (
-            "id=m-spend", "id=m-mix", "id=m-speedchart", "id=m-table", "id=m-diagnostics",
-        )]
-        self.assertEqual(order, sorted(order))
-        for marker in (
-            "Where your spend goes", "Model mix over time", "data-model-mix=cost",
-            "data-model-mix=output", "data-model-mix=executions",
-            "Speed &amp; timing diagnostics",
-        ):
-            self.assertIn(marker, models)
-        diagnostics = models.split("id=m-diagnostics", 1)[1]
-        speed_block = diagnostics.split("id=m-change-label", 1)[0]
-        self.assertIn("id=m-speed-label", speed_block)
-        self.assertIn("cross-runtime output pace remains diagnostic rather than a model verdict.", speed_block)
-        for marker in ("id=m-speed", "id=m-change", "id=m-wait", "id=m-chart", "id=m-metric"):
-            self.assertIn(marker, diagnostics)
-        self.assertNotIn("id=m-input", models)
-        self.assertNotIn("Logs (all)", models)
-        table_head = models.split("id=m-table><thead>", 1)[1].split("</thead>", 1)[0]
-        self.assertEqual(table_head.count("<th"), 10)
-        self.assertEqual(
-            [key for key in ("model", "cost", "cost_per_exec", "cache", "executions", "output", "speed", "wait", "pushback")
-             if f"data-model-sort={key} data-tip=" in table_head],
-            ["model", "cost", "cost_per_exec", "cache", "executions", "output", "speed", "wait", "pushback"],
-        )
-        self.assertIn("does not change with the History filter", table_head)
-        self.assertNotIn("<span class=\"fieldtip modelHelp\" tabindex=0", table_head)
-        self.assertEqual(table_head.count('<button class="modelSortBtn fieldtip modelHelp" type=button'), 9)
-        for marker in (
-            "const MODEL_SORT_KEYS=['model','cost','cost_per_exec','cache','executions','output','speed','wait','pushback'];",
-            "localStorage.setItem('tm_model_speed_models',JSON.stringify(modelSpeedSelection))",
-            "localStorage.removeItem('tm_model_speed_models')",
-            "renderModelSpeedChart(groups,ranking,top,rangeWindow);",
-            "localStorage.setItem('tm_model_sort',JSON.stringify(modelSort))",
-            "localStorage.setItem('tm_model_mix_metric',metric)",
-            "localStorage.setItem('tm_model_diagnostics_open'",
-            "without cost data ${uncosted===1?'is':'are'} excluded, not counted as $0.",
-            "th.setAttribute('aria-sort'",
-            "aria-expanded=${expanded}",
-            "data-model-clear",
-            "setLogHtml($('m-table').querySelector('tbody'),",
-            "const focus=modelFocusKey();", "restoreModelFocus(focus);",
-            "perExecPartial?'*':''",
-            '<div class=modelSpendBar id=m-spend-bar role=group',
-        ):
-            self.assertIn(marker, self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_models_leaderboard_groups_variants_and_never_counts_missing_cost_as_zero(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-function constLine(name){{const start=page.indexOf(`const ${{name}}=`);if(start<0)throw Error(`missing ${{name}}`);return page.slice(start,page.indexOf('\\n',start));}}
-['MODEL_COUNTER_KEYS','MODEL_ARRAY_KEYS','metricAvailable','metricPartial','usageProvenance','usageBasis','hasLocalEstimate'].forEach(name=>eval(constLine(name).replace(/^const /,'globalThis.')));
-['modelWaitDistribution','modelMedian','modelDayInRange','aggregateModelDays','efficiencyMetrics','modelGroupKey','modelGroupRows','modelBoardValue','sortModelBoard','modelSpendRanking'].forEach(name=>eval(`globalThis.${{name}}=${{extract(name)}}`));
-globalThis.modelSort={{key:'cost',direction:'desc'}};
-const day=(d,extra)=>({{day:d,availability:{{tokens:true,cost:true,cache:true}},executions:10,output_tokens:100,input_tokens:1000,cache_read_tokens:800,cache_covered_input_tokens:1000,wait_samples:1,wait_seconds:5,wait_durations_s:[5],...extra}});
-const models=[
- {{id:'sol::Codex::high',model:'sol',runtime:'Codex',reasoning_effort:'high',logs:3,daily:[day('2026-09-30',{{cost:6}}),day('2026-01-01',{{cost:100}})]}},
- {{id:'sol::Codex::xhigh',model:'sol',runtime:'Codex',reasoning_effort:'xhigh',logs:2,daily:[day('2026-09-30',{{cost:4}})]}},
- {{id:'sol::Cursor',model:'sol',runtime:'Cursor',logs:1,daily:[day('2026-09-30',{{cost:0,availability:{{tokens:true,cost:false}}}})]}},
- {{id:'opus::Claude-3P',model:'opus',runtime:'Claude-3P',logs:5,daily:[day('2026-09-30',{{cost:7,executions:2}})]}},
- {{id:'part::Codex',model:'part',runtime:'Codex',logs:1,daily:[day('2026-09-30',{{cost:6,executions:10,cost_covered_executions:6,cost_covered_cost:6}})]}},
- {{id:'big::Cursor',model:'big',runtime:'Cursor',logs:1,daily:[day('2026-09-30',{{output_tokens:999999,availability:{{tokens:true,cost:false}}}})]}},
-];
-const window={{days:['2026-09-30'],daySet:new Set(['2026-09-30'])}};
-const groups=modelGroupRows(models,window),byKey=Object.fromEntries(groups.map(g=>[g.key,g]));
-const ranking=modelSpendRanking(groups);
-process.stdout.write(JSON.stringify({{
- keys:groups.map(g=>g.key).sort(),
- solVariants:byKey['sol::Codex'].variants.length,
- solCost:modelBoardValue(byKey['sol::Codex'],'cost'),
- cursorCost:modelBoardValue(byKey['sol::Cursor'],'cost'),
- opusPerExec:modelBoardValue(byKey['opus::Claude-3P'],'cost_per_exec'),
- partialPerExec:modelBoardValue(byKey['part::Codex'],'cost_per_exec'),
- speedNone:modelBoardValue(byKey['sol::Codex'],'speed'),
- solCache:modelBoardValue(byKey['sol::Codex'],'cache'),
- ranking:ranking.map(g=>g.key),
- byExecAsc:sortModelBoard(groups,{{key:'executions',direction:'asc'}}).map(g=>g.key),
- byCostAsc:sortModelBoard(groups,{{key:'cost',direction:'asc'}}).map(g=>g.key),
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload["keys"], ["big::Cursor", "opus::Claude-3P", "part::Codex", "sol::Codex", "sol::Cursor"])
-        self.assertEqual(payload["solVariants"], 2)
-        self.assertEqual(payload["solCost"], 10)
-        self.assertIsNone(payload["cursorCost"])
-        self.assertEqual(payload["opusPerExec"], 3.5)
-        self.assertAlmostEqual(payload["solCache"], 0.8)
-        self.assertEqual(payload["partialPerExec"], 1.0)
-        self.assertIsNone(payload["speedNone"])
-        self.assertEqual(payload["ranking"], ["sol::Codex", "opus::Claude-3P", "part::Codex", "big::Cursor", "sol::Cursor"])
-        self.assertEqual(payload["byExecAsc"][0], "opus::Claude-3P")
-        self.assertEqual(set(payload["byCostAsc"][-2:]), {"sol::Cursor", "big::Cursor"})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_models_speed_series_is_time_weighted_smoothed_and_defaults_to_timed_top_five(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-['localDateKey','modelCalendarDays','modelSpeedBasis','modelSpeedSeries','modelSpeedDefaultKeys','modelSmoothPath'].forEach(name=>eval(`globalThis.${{name}}=${{extract(name)}}`));
-const days=['d1','d2','d3','d4','d5'];
-const daily=[
- {{day:'d1',timed_output_tokens:100,timed_seconds:10,timed_samples:1}},
- {{day:'d2',timed_output_tokens:900,timed_seconds:30,timed_samples:3}},
- {{day:'d4',timed_output_tokens:50,timed_seconds:5,timed_samples:1,tool_free_output_tokens:40,tool_free_seconds:2,tool_free_samples:1}},
- {{day:'d5',timed_output_tokens:0,timed_seconds:0,timed_samples:0}},
-];
-const series=modelSpeedSeries(daily,days,'timed');
-const toolFree=modelSpeedSeries(daily,days,'tool_free');
-const ranking=[1,2,3,4,5,6,7].map(n=>({{key:'g'+n,window:{{available:n!==2}}}}));
-const path=modelSmoothPath([[0,10],[50,20],[100,15]]);
-process.stdout.write(JSON.stringify({{
- series,toolFree,
- basisTimed:modelSpeedBasis({{tool_free_samples:0,tool_free_seconds:0}}),
- basisTool:modelSpeedBasis({{tool_free_samples:2,tool_free_seconds:4}}),
- defaults:modelSpeedDefaultKeys(ranking),
- path,single:modelSmoothPath([[0,1]]),
- calendar:modelCalendarDays(['2026-05-03','2026-05-01','bad','2026-05-01']),
- sparse:modelSpeedSeries([{{day:'2026-05-01',timed_output_tokens:100,timed_seconds:10}},{{day:'2026-05-03',timed_output_tokens:900,timed_seconds:30}}],modelCalendarDays(['2026-05-01','2026-05-03']),'timed'),
-}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual([point["day"] for point in payload["series"]], ["d1", "d2", "d4"])
-        d1, d2, d4 = payload["series"]
-        self.assertAlmostEqual(d1["value"], 1000 / 40)
-        self.assertAlmostEqual(d2["value"], 1000 / 40)
-        self.assertAlmostEqual(d4["value"], 50 / 5)
-        self.assertAlmostEqual(d2["raw"], 30)
-        self.assertEqual(d2["samples"], 3)
-        self.assertEqual([point["day"] for point in payload["toolFree"]], ["d4"])
-        self.assertAlmostEqual(payload["toolFree"][0]["value"], 20)
-        self.assertEqual(payload["basisTimed"], "timed")
-        self.assertEqual(payload["basisTool"], "tool_free")
-        self.assertEqual(payload["defaults"], ["g1", "g3", "g4", "g5", "g6"])
-        self.assertTrue(payload["path"].startswith("M0.0,10.0 C"))
-        self.assertEqual(payload["path"].count(" C"), 2)
-        self.assertEqual(payload["single"], "")
-        self.assertEqual(payload["calendar"], ["2026-05-01", "2026-05-02", "2026-05-03"])
-        self.assertEqual([round(point["value"], 6) for point in payload["sparse"]], [10.0, 30.0])
-
-    CHART_GAP_HARNESS = r"""
-const fs=require('fs');
-const page=fs.readFileSync(__PAGE__,'utf8');
-function extract(name){let start=page.indexOf(`function ${name}(`);if(start<0)throw Error(`missing ${name}`);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}throw Error(`unclosed ${name}`);}
-function load(names){names.forEach(name=>eval(`globalThis.${name}=${extract(name)}`));}
-function attrs(html,tag,cls){return [...html.matchAll(new RegExp(`<${tag} class=${cls} ([^>]*)/?>`,'g'))].map(match=>Object.fromEntries([...match[1].matchAll(/([\w-]+)="([^"]*)"/g)].map(pair=>[pair[1],pair[2]])));}
-"""
-
-    def run_chart_gap_harness(self, body):
-        script = self.CHART_GAP_HARNESS.replace(
-            "__PAGE__", json.dumps(str(Path(DASHBOARD_PAGE))),
-        ) + body
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        return json.loads(result.stdout)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_chart_gap_runs_split_daily_points_and_bridge_only_interior_gaps(self):
-        payload = self.run_chart_gap_harness(r"""
-load(['chartGapRuns','chartGapBridge']);
-const runs=chartGapRuns([{index:1},{index:2},{index:4},{index:6},{index:7}]);
-process.stdout.write(JSON.stringify({
- segments:runs.segments.map(run=>run.map(point=>point.index)),
- bridges:runs.bridges.map(pair=>pair.map(point=>point.index)),
- edges:chartGapRuns([{index:3},{index:4}]),
- empty:chartGapRuns([]),
- bridge:chartGapBridge(1,2.25,30,40),
-}));
-""")
-        self.assertEqual(payload["segments"], [[1, 2], [4], [6, 7]])
-        self.assertEqual(payload["bridges"], [[2, 4], [4, 6]])
-        self.assertEqual(payload["edges"]["bridges"], [])
-        self.assertEqual(len(payload["edges"]["segments"]), 1)
-        self.assertEqual(payload["empty"], {"segments": [], "bridges": []})
-        self.assertEqual(
-            payload["bridge"],
-            '<line class=chartGapBridge x1="1.0" y1="2.3" x2="30.0" y2="40.0"/>',
-        )
-        self.assertIn(":where(.chartGapBridge){", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_bridges_gaps_marks_isolated_days_and_never_plots_zero(self):
-        payload = self.run_chart_gap_harness(r"""
-load(['chartGapRuns','chartGapBridge','efficiencyChartPointerIndex','efficiencyChartKeyIndex','efficiencyChartMetricPresentation','efficiencyChartInspection','efficiencyChartAnnouncement','efficiencyChartSmoothPath','renderEfficiencyChart']);
-class AttrNode{constructor(){this.attrs={};}setAttribute(name,value){this.attrs[name]=String(value);}}
-class InspectNode extends AttrNode{constructor(){super();this.line=new AttrNode();this.dot=new AttrNode();}querySelector(selector){return selector==='line'?this.line:this.dot;}}
-class SvgNode extends AttrNode{constructor(parent){super();this.parentElement=parent;this.dataset={};this.inspect=null;}set innerHTML(value){this.html=value;this.inspect=new InspectNode();}get innerHTML(){return this.html;}querySelector(selector){return selector==='.efficiencyChartInspect'?this.inspect:null;}getBoundingClientRect(){return {left:0,width:520};}matches(){return false;}}
-const tip={hidden:true,textContent:'',style:{}},status={textContent:''};
-const svg=new SvgNode({querySelector(selector){return selector==='.efficiencyChartTip'?tip:status;}});
-globalThis.$=()=>svg;globalThis.esc=value=>String(value);globalThis.pct=value=>`${Math.round(value*100)}%`;globalThis.compactNumber=value=>String(Math.round(value));
-const values=[null,10,20,null,15,null,30,25,null];
-const trend=values.map((value,index)=>({day:`2026-08-${String(index+1).padStart(2,'0')}`,metrics:{output_per_dollar:value}}));
-renderEfficiencyChart('chart',trend,'output_per_dollar','Output per covered dollar');
-const html=svg.innerHTML,x=index=>9+index*502/8,y=value=>10+70-(value/30)*70;
-svg.onfocus();svg.onkeydown({key:'Home',preventDefault(){}});const leading=tip.textContent;
-['ArrowRight','ArrowRight','ArrowRight'].forEach(key=>svg.onkeydown({key,preventDefault(){}}));const gap=tip.textContent;
-process.stdout.write(JSON.stringify({
- bridges:attrs(html,'line','chartGapBridge'),
- expectedBridges:[[x(2),y(20),x(4),y(15)],[x(4),y(15),x(6),y(30)]].map(row=>row.map(value=>value.toFixed(1))),
- dots:attrs(html,'circle','efficiencyChartDot').map(dot=>[dot.cx,dot.cy]),
- expectedIsolated:[x(4).toFixed(1),y(15).toFixed(1)],
- lines:attrs(html,'path','efficiencyChartLine').map(path=>path.d),
- baseline:(10+70).toFixed(1),
- missingX:[0,3,5,8].map(index=>x(index).toFixed(1)),
- leading,gap,
-}));
-""")
-        self.assertEqual(
-            [[b["x1"], b["y1"], b["x2"], b["y2"]] for b in payload["bridges"]],
-            payload["expectedBridges"],
-        )
-        self.assertIn(payload["expectedIsolated"], payload["dots"])
-        self.assertEqual(len(payload["lines"]), 2, "only multi-day runs draw a solid line")
-        for path in payload["lines"]:
-            coordinates = re.findall(r"(-?\d+\.\d)\s(-?\d+\.\d)", path)
-            self.assertNotIn(payload["baseline"], [y for _, y in coordinates])
-            for missing_x in payload["missingX"]:
-                self.assertNotIn(missing_x, [x for x, _ in coordinates])
-        self.assertEqual(payload["leading"], "Aug 1 · No data")
-        self.assertEqual(payload["gap"], "Aug 4 · No data")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_model_speed_and_trend_charts_bridge_gaps_instead_of_smoothing_through_them(self):
-        payload = self.run_chart_gap_harness(r"""
-load(['chartGapRuns','chartGapBridge','modelSpeedSeries','modelSpeedBasis','modelSpeedDefaultKeys','modelSmoothPath','renderModelSpeedChart','modelTrendRowHasUsage','modelTrendPaint','modelTokensPerExecution','drawModelTrend']);
-eval(page.slice(page.indexOf('const metricAvailable='),page.indexOf('\n',page.indexOf('const metricAvailable='))).replace(/^const /,'globalThis.'));
-const nodes={};
-function node(id){return nodes[id]||(nodes[id]={id,style:{},dataset:{},textContent:'',innerHTML:'',offsetWidth:100,offsetHeight:40,setAttribute(){},parentElement:{getBoundingClientRect(){return {left:0,top:0,width:1040};}},querySelectorAll:()=>[]});}
-Object.assign(globalThis,{$:node,esc:value=>String(value),f:value=>String(value),countWord:(n,word)=>word,setLogHtml(){},speedFmt:value=>value.toFixed(1),waitFmt:String,compactNumber:value=>String(Math.round(value)),modelScopeLabel:()=>'all',modelRangeLabel:()=>'8 days',modelRange:'8',modelSpeedSelection:null,MODEL_SPEED_MAX_SERIES:8,MODEL_SPEED_EXTRA_COLORS:['c2'],modelRankedColors:top=>new Map(top.map(group=>[group.key,'c1'])),CHART:{lbl:'lbl',grid:'grid',ink:'ink'},svgTextPx:()=>12,MODEL_OUTPUT_BAR_FILL:'bar',MODEL_OUTPUT_BAR_STROKE:'barStroke',modelTrendMetric:'speed'});
-const start=page.indexOf('const MODEL_TREND_METRICS=');eval('globalThis.MODEL_TREND_METRICS='+page.slice(start+'const MODEL_TREND_METRICS='.length,page.indexOf('\n};',start)+3));
-const days=['d0','d1','d2','d3','d4','d5','d6','d7'],timed=[1,2,4,6];
-const daily=timed.map(index=>({day:days[index],timed_output_tokens:100*(index+1),timed_seconds:10,timed_samples:1}));
-const group={key:'g',model:'m',runtime:'Codex',estimated:false,daily,window:{available:true,output_tps:10}};
-const speedHits=[];node('m-speedchart-svg').querySelectorAll=()=>days.map((_,index)=>{const hit={dataset:{speedDay:String(index)}};speedHits.push(hit);return hit;});
-renderModelSpeedChart([group],[group],[group],{days});
-const speed=node('m-speedchart-svg').innerHTML,speedTip=node('m-speedchart-tip');
-speedHits[3].onpointerenter({clientX:10,clientY:10});const speedGapTip=speedTip.style.display==='block'?speedTip.innerHTML:'hidden';
-const trendHits=[];node('m-chart').querySelectorAll=()=>days.map(()=>{const hit={};trendHits.push(hit);return hit;});
-const point=index=>timed.includes(index)?{day:days[index],executions:1,output_tokens:100,availability:{tokens:true},perf:{available:true,output_tps:index+1}}:{day:days[index],perf:{available:false}};
-drawModelTrend({days,series:[{id:'g',model:'m · Codex',color:'c1',estimated:false,points:days.map((_,index)=>point(index))}]});
-const trend=node('m-chart').innerHTML,trendTip=node('m-chart-tip');
-trendHits[0].onpointerenter({clientX:10,clientY:10});const trendGapTip=trendTip.style.display==='block'?trendTip.innerHTML:'hidden';
-process.stdout.write(JSON.stringify({
- speedBridges:attrs(speed,'line','chartGapBridge').length,
- speedCurves:(speed.match(/<path d="M[^"]*"/g)||[]).map(path=>(path.match(/ C/g)||[]).length),
- speedDots:(speed.match(/<circle /g)||[]).length,
- speedGapTip,
- trendBridges:attrs(trend,'line','chartGapBridge').length,
- trendLines:(trend.match(/<path d="M[^"]*"/g)||[]).map(path=>(path.match(/ L/g)||[]).length),
- trendDots:(trend.match(/<circle /g)||[]).length,
- trendGapTip,
-}));
-""")
-        self.assertEqual(payload["speedBridges"], 2)
-        self.assertEqual(payload["speedCurves"], [1], "only the d1-d2 run is a solid curve")
-        self.assertEqual(payload["speedDots"], 2, "isolated d4 and d6 render as dots")
-        self.assertIn("No data", payload["speedGapTip"])
-        self.assertIn("d3", payload["speedGapTip"])
-        self.assertEqual(payload["trendBridges"], 2)
-        self.assertEqual(payload["trendLines"], [1])
-        self.assertEqual(payload["trendDots"], 4)
-        self.assertIn("No data", payload["trendGapTip"])
-        self.assertIn("d0", payload["trendGapTip"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_models_focus_restore_keeps_the_focused_control_and_scopes_to_its_container(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const start=page.indexOf('const MODEL_FOCUS_KEYS=');eval('globalThis.MODEL_FOCUS_KEYS='+page.slice(start+'const MODEL_FOCUS_KEYS='.length,page.indexOf(';',start)));
-eval('globalThis.modelFocusKey='+extract('modelFocusKey'));eval('globalThis.restoreModelFocus='+extract('restoreModelFocus'));
-function node(id,dataset,parent){{const el={{id,dataset:dataset||{{}},parent,children:[],isConnected:true,label:id,
- contains(other){{for(let cur=other;cur;cur=cur.parent)if(cur===this)return true;return false;}},
- closest(sel){{const ids=sel.split(',').map(x=>x.trim().slice(1));for(let cur=this;cur;cur=cur.parent)if(ids.includes(cur.id))return cur;return null;}},
- querySelectorAll(sel){{const attr=sel.slice(1,-1),key=attr.slice(5).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());const out=[];const walk=n=>{{n.children.forEach(c=>{{if(key in c.dataset)out.push(c);walk(c);}});}};walk(this);return out;}},
- focus(){{document.activeElement=this;}}}};if(parent)parent.children.push(el);byId[id]=el;return el;}}
-const byId={{}};globalThis.document={{activeElement:null}};globalThis.$=id=>byId[id]||null;
-const view=node('view-models');const bar=node('m-spend-bar',{{}},view),legend=node('m-spend-legend',{{}},view),table=node('m-table',{{}},view);
-const seg=node('seg',{{modelIds:'a::Codex::high\\na::Codex::xhigh'}},bar),chip=node('chip',{{modelIds:'a::Codex::high\\na::Codex::xhigh'}},legend);
-const expand=node('expand-old',{{modelExpand:'a::Codex'}},table);
-const results={{}};
-chip.focus();let focus=modelFocusKey();restoreModelFocus(focus);results.chipUnchanged=document.activeElement.label;
-focus=modelFocusKey();chip.isConnected=false;legend.children=[];const chip2=node('chip-new',{{modelIds:chip.dataset.modelIds}},legend);restoreModelFocus(focus);results.chipRebuilt=document.activeElement.label;
-expand.focus();focus=modelFocusKey();expand.isConnected=false;table.children=[];node('expand-new',{{modelExpand:'a::Codex'}},table);restoreModelFocus(focus);results.expandRebuilt=document.activeElement.label;
-const outside=node('outside',{{modelIds:'x'}},null);outside.focus();results.outsideKey=modelFocusKey();
-process.stdout.write(JSON.stringify(results));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        self.assertEqual(payload["chipUnchanged"], "chip")
-        self.assertEqual(payload["chipRebuilt"], "chip-new")
-        self.assertEqual(payload["expandRebuilt"], "expand-new")
-        self.assertIsNone(payload["outsideKey"])
-
-    def test_selected_session_token_split_fills_the_chart_column_gap(self):
-        run_grid = self.page.split('<div class=previewRunGrid>', 1)[1].split(
-            '<aside class=previewDecision>', 1
-        )[0]
-        self.assertIn('class=previewChartColumn', run_grid)
-        self.assertIn('id=preview-run-chart-slot', run_grid)
-        self.assertIn('id=preview-token-split-slot', run_grid)
-        self.assertLess(
-            run_grid.index('id=preview-run-chart-slot'),
-            run_grid.index('id=preview-token-split-slot'),
-        )
-        self.assertIn(
-            ".previewChartColumn{display:grid;grid-template-rows:minmax(0,1fr) auto;gap:12px;min-width:0}",
-            self.page,
-        )
-
-    def test_leaving_the_tour_through_a_link_offers_a_way_back(self):
-        self.assertIn('<button class="deckPrimary tourReturn" id=tour-return type=button hidden>', self.page)
-        self.assertIn("@media(prefers-reduced-motion:reduce){.tourReturn,.tourReturnArrow{animation:none}}", self.page)
-        self.assertIn("@keyframes tourReturnIn{from{transform:translateY(16px) scale(.94)}to{transform:none}}", self.page, "never starts invisible")
-        self.assertIn("const TOUR_RETURN_KEY='tm_tour_return';", self.page)
-        self.assertIn("$('tour-return').onclick=returnToTour;\nrestoreTourReturn();", self.page)
-        self.assertIn("value.host==='learn'?'Back to Learn':'Back to the tour'", self.page)
-        self.assertIn("const from={index:deckHosts.learn.index,hash:location.hash,host:'learn'};", self.page)
-        self.assertIn("if(tourReturn?.host==='learn'&&(h==='learn'||h==='learn-agent-access'))showTourReturn(null);", self.page)
-        self.assertIn("if(route){openDeckRoute(route,target);if(from)showTourReturn(from);}", self.page)
-        self.assertIn("$('tour-return').onclick=returnToTour;", self.page)
-        self.assertIn("window.addEventListener('popstate',()=>{if(tourReturn&&location.hash===tourReturn.hash)returnToTour();});", self.page)
-        self.assertIn(" showTourReturn(null);\n const start=welcomeStartSlide(index);", self.page)
-
-    def test_git_spend_headers_explain_covered_spend(self):
-        tip = "Covered spend: estimated spend from sessions with cost evidence in these projects."
-        for attr in ("data-delivery-model-sort=covered_cost", "data-delivery-sort=covered_cost"):
-            self.assertIn(f'{attr} data-tip="{tip}" aria-description="{tip}">Spend<', self.page)
-
-    def test_review_fixes_keep_focus_targets_and_timestamps(self):
-        # The inventory heading receives programmatic focus, so it must be focusable.
-        self.assertIn("<h2 id=c-inventory-title tabindex=-1>All capabilities</h2>", self.page)
-        self.assertIn("$('c-inventory-title').focus(", self.page)
-        # Detail view keeps the date/time line break instead of collapsing it.
-        self.assertIn(
-            "body.sessionRoute #view-session.sessionDetail .previewTimes b{overflow:visible;white-space:pre-line;line-height:1.35}",
-            self.page,
-        )
-        self.assertIn("$('preview-started-at').textContent=(dt12(timing.start_local)||'--').replace(' ','\\n');", self.page)
-        # The welcome tour opened from the palette returns focus to where the palette opened.
-        self.assertIn("const returnFocus=commandReturnFocus;commandReturnFocus=null;openWelcome(null,{returnFocus});", self.page)
-        self.assertNotIn("WELCOME_PANELS[2].title=", self.page)
-
-    def test_selected_session_columns_share_top_and_bottom_edges(self):
-        decision = self.page.split('<aside class=previewDecision>', 1)[1].split('</aside>', 1)[0]
-        # The right column opens with a heading row matching the left column's
-        # "Execution Profile" heading, so the first cards start on one line.
-        self.assertTrue(decision.lstrip().startswith(
-            '<div class=section-h><h2>Session cost</h2><span class=hint>estimate</span></div>'
-        ))
-        self.assertLess(decision.index('class=section-h'), decision.index('id=preview-status-card'))
-        self.assertLess(decision.index('id=preview-status-card'), decision.index('id=preview-run-budget-slot'))
-        for rule in (
-            # Both columns stretch to the row height; the first card in each
-            # column absorbs slack so the last cards end on one line.
-            ".previewRunGrid{display:grid;grid-template-columns:minmax(0,1.75fr) minmax(300px,.65fr);gap:12px;align-items:stretch}",
-            ".previewChartColumn{display:grid;grid-template-rows:minmax(0,1fr) auto;gap:12px;min-width:0}",
-            ".previewChartSlot{display:grid}",
-            ".previewChartSlot #session-chart-module{display:grid;grid-template-rows:auto minmax(0,1fr);gap:12px}",
-            ".previewChartSlot .section-h,.previewDecision>.section-h{margin:0}",
-            ".previewDecision{display:grid;grid-template-columns:minmax(0,1fr);grid-template-rows:auto minmax(0,1fr) auto;gap:12px}",
-            # The wider 18px inset must not push the budget slider past the
-            # narrow 1024px right column.
-            ".previewRunBudgetSlot .sessionBudgetTrack{grid-template-columns:52px minmax(0,1fr) 60px}",
-            ".previewStatus{display:flex;flex-direction:column;",
-            ".previewStatus .previewPressure{margin-block:auto}",
-            # Right-column cards share the left cards' 18px inner edge.
-            "body.sessionRoute #view-session.sessionDetail .previewRunBudgetSlot .sessionBudget{padding:18px;",
-            # Context pressure uses the same label treatment as Started/Last activity.
-            ".previewPressureHead>span{color:var(--faint);font-size:var(--fs-11);text-transform:uppercase;letter-spacing:.04em}",
-        ):
-            self.assertIn(rule, self.page)
-        self.assertNotIn("#view-session.sessionDetail .previewRunGrid{gap:14px}", self.page)
-        self.assertNotIn(".previewChartSlot .section-h{margin:0 0 10px}", self.page)
-
-    def test_efficiency_is_the_only_top_level_name_and_route(self):
-        for marker in (
-            "id=tab-efficiency", "id=view-efficiency", "data-page-signal=efficiency",
-            "id=e-project", "id=e-model-picker", "id=e-model-options", "id=e-model-summary",
-            "id=e-range", "id=e-output-dollar", "id=e-reasoning-ratio",
-            "id=e-output-dollar-chart", "id=e-reasoning-chart",
-            "id=e-context-load", "id=e-cache-hit", "id=e-model-table",
-            "data-efficiency-sort=cache_hit_ratio",
-            "data-efficiency-sort=cost", "data-efficiency-sort=output_per_dollar",
-            "function renderEfficiency", "function efficiencyMetrics",
-            "function renderEfficiencyChart", "function sortEfficiencyRows",
-            "y2=\"${pad.top}\"", "r=\"3.5\"",
-            "$('tab-efficiency').onclick=()=>openTopLevelRoute('efficiency')",
-            "if(h==='efficiency')", "renderActiveEfficiency()",
-            "tm_efficiency_range",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertRegex(
-            self.page,
-            r"id=tab-efficiency[^>]*>.*?<span class=tabLabel>Efficiency</span>",
-        )
-        nav_ids = [
-            "tab-session", "tab-daily", "tab-models", "tab-efficiency",
-            "tab-learn", "tab-capabilities", "tab-settings",
-        ]
-        positions = [self.page.index(f"id={tab_id}") for tab_id in nav_ids]
-        self.assertEqual(positions, sorted(positions))
-        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
-            "<div class=view id=view-learn>", 1
-        )[0]
-        self.assertIn("Output / $", efficiency)
-        self.assertIn("Reasoning ratio", efficiency)
-        self.assertIn("Cache hit ratio", efficiency)
-        self.assertNotIn("Output / exec", efficiency)
-        self.assertNotIn("output_per_execution", self.page)
-        self.assertIn("Mechanical efficiency", efficiency)
-        self.assertIn("Spend", efficiency)
-        self.assertNotIn("Cache leverage", efficiency)
-        self.assertNotIn("Retry waste", efficiency)
-        self.assertNotIn("Efficiency score", efficiency)
-        self.assertNotIn("recommendation", efficiency.lower())
-        for stale in (
-            "id=tab-insights", "id=view-insights", "route:'insights'",
-            "tm_insights_range", "function renderInsights",
-        ):
-            self.assertNotIn(stale, self.page)
-
-    def test_efficiency_table_keeps_model_app_and_effort_as_columns(self):
-        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
-            "<div class=view id=view-learn>", 1
-        )[0]
-        for header in (">Model<", ">App<", ">Reasoning effort<"):
-            self.assertIn(header, efficiency)
-        self.assertIn(
-            "<td><div class=modelName title=\"${esc(row.model)}\">${esc(row.model)}</div></td><td>${esc(row.runtime)}",
-            self.page,
-        )
-
-    def test_models_table_labels_effort_qualified_runtime_rows(self):
-        self.assertIn(
-            "`${modelEffortLabel(only)} · ${f(only.logs)} ${countWord(only.logs,'log')}`",
-            self.page,
-        )
-        self.assertIn("<div class=modelVariantName>${esc(modelEffortLabel(variant))}<small>${f(variant.logs)} ${countWord(variant.logs,'log')}</small>", self.page)
-
-    def test_selected_session_has_a_compact_two_metric_efficiency_module(self):
-        summary = self.page.split('<div class="session-panel on" id=panel-summary>', 1)[1].split(
-            '<details class=usageDetails', 1
-        )[0]
-        for marker in (
-            "id=session-efficiency", "id=session-output-dollar",
-            "id=session-output-dollar-note", "id=session-reasoning-ratio",
-            "id=session-reasoning-ratio-note", "function renderSessionEfficiency",
-            "function sessionEfficiencySource", "aggregateModelDays(source.model_stats||[])",
-            "id=preview-run-efficiency-slot",
-            "mountCurrentModule('preview-run-efficiency-slot','session-efficiency')",
-            "['session-efficiency-home','session-efficiency']",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertLess(summary.index("id=session-efficiency"), summary.index("id=session-budget-home"))
-        session_efficiency = summary.split("id=session-efficiency", 1)[1].split(
-            "id=session-budget-home", 1
-        )[0]
-        self.assertEqual(session_efficiency.count('class="sessionEfficiencyMetric metric"'), 2)
-        self.assertIn("Output / $", session_efficiency)
-        self.assertIn("Reasoning ratio", session_efficiency)
-        self.assertNotIn("<svg", session_efficiency)
-        self.assertNotIn("By model", session_efficiency)
-
-    def test_selected_session_efficiency_is_inside_the_run_status_card(self):
-        run_surface = self.page.split('id=preview-surface-run', 1)[1].split(
-            '<div class=previewKpis', 1
-        )[0]
-        status_card = run_surface.split('id=preview-status-card', 1)[1].split(
-            '</section>', 1
-        )[0]
-        self.assertIn('id=preview-run-efficiency-slot', status_card)
-        self.assertLess(
-            status_card.index('id=preview-run-efficiency-slot'),
-            status_card.index('class=previewPressure'),
-        )
-        self.assertIn(
-            ".previewStatus .previewRunEfficiencySlot .sessionEfficiency{grid-template-columns:repeat(2",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_efficiency_uses_the_matching_cross_session_summary(self):
-        match = re.search(
-            r"function sessionEfficiencySource\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match)
-        script = r"""
-const stateSessionId=state=>state?.source?.id||null;
-""" + match.group(0) + r"""
-const matched={source:{id:'selected',key:'tright'},model_stats:[],xsession:{sessions:[
-  {id:'other',key:'tother',model_stats:[{model:'wrong-id'}]},
-  {id:'selected',key:'twrong',model_stats:[{model:'wrong-trace'}]},
-  {id:'selected',key:'tright',model_stats:[{model:'right'}],usage_basis:'reported'},
-]}};
-const direct={source:{id:'direct'},model_stats:[{model:'fallback'}],xsession:{sessions:[]}};
-const stale={source:{id:'selected',key:'tmissing'},model_stats:[{model:'fail-closed'}],xsession:{sessions:[
-  {id:'selected',key:'twrong',model_stats:[{model:'wrong-trace'}]},
-]}};
-const attached={source:{id:'selected',key:'tright'},selected_stats:{model_stats:[{model:'attached-exact'}],usage_basis:'reported'},xsession:{sessions:[
-  {id:'selected',key:'tright',model_stats:[{model:'stale-cross'}]},
-]}};
-console.log(JSON.stringify({matched:sessionEfficiencySource(matched),direct:sessionEfficiencySource(direct),stale:sessionEfficiencySource(stale),attached:sessionEfficiencySource(attached)}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["matched"]["model_stats"][0]["model"], "right")
-        self.assertEqual(payload["matched"]["usage_basis"], "reported")
-        self.assertEqual(payload["direct"]["model_stats"][0]["model"], "fallback")
-        self.assertEqual(payload["stale"]["model_stats"][0]["model"], "fail-closed")
-        self.assertEqual(payload["attached"]["model_stats"][0]["model"], "attached-exact")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_efficiency_recovers_explicit_reasoning_coverage_from_summary_counts(self):
-        match = re.search(
-            r"function normalizeSessionEfficiencyAggregate\(.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(match)
-        script = match.group(0) + r"""
-console.log(JSON.stringify({
-  exact:normalizeSessionEfficiencyAggregate({
-    executions:10,reasoning_executions:8,reasoning_tokens:30,
-    reasoning_output_tokens:80,availability:{reasoning_tokens:false},
-  }),
-  structural:normalizeSessionEfficiencyAggregate({
-    executions:10,reasoning_executions:0,reasoning_tokens:0,
-    reasoning_output_tokens:0,thinking_executions:4,availability:{},
-  }),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertTrue(payload["exact"]["availability"]["reasoning_tokens"])
-        self.assertFalse(payload["structural"]["availability"]["reasoning_tokens"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_metrics_are_bounded_and_keep_unavailable_evidence_null(self):
-        match = re.search(
-            r"function efficiencyMetrics\(row\)\{.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs one shared efficiency formula")
-        script = match.group(0) + r"""
-const complete = efficiencyMetrics({
-  input_tokens:1000, output_tokens:200, cost:2, executions:2,
-  token_covered_executions:2, io_covered_executions:2,
-  cost_covered_output_tokens:200, cost_covered_cost:2,
-  cache_read_tokens:500, reasoning_tokens:50, reasoning_output_tokens:100,
-  reasoning_executions:1, reasoning_unavailable_executions:1,
-  attempts:4, retries:1, failed_attempts:1, attempt_samples:1,
-  availability:{tokens:true,cost:true,cache:true,reasoning_tokens:true,attempts:true},
-});
-const missing = efficiencyMetrics({
-  input_tokens:100, output_tokens:20, cost:0, executions:0,
-  availability:{tokens:true,cost:false,cache:false,reasoning_tokens:false,attempts:false},
-});
-const partial = efficiencyMetrics({
-  input_tokens:110, output_tokens:110, cost:.1, executions:3,
-  token_covered_executions:2, io_covered_executions:1,
-  cost_covered_output_tokens:10, cost_covered_cost:.1,
-  coverage:{tokens:{complete:false}},
-  availability:{tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
-});
-const coveredZero = efficiencyMetrics({
-  input_tokens:10, output_tokens:0, cost:1, executions:1,
-  token_covered_executions:1, io_covered_executions:1,
-  cost_covered_executions:1, cost_covered_output_tokens:0,
-  cost_covered_cost:1,
-  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
-});
-const inputOnly = efficiencyMetrics({
-  input_tokens:10, output_tokens:0, cost:1, executions:1,
-  token_covered_executions:0, io_covered_executions:0,
-  cost_covered_executions:0,
-  cost_covered_output_tokens:0,
-  availability:{tokens:true,input_tokens:true,output_tokens:false,cost:true,cache:false,reasoning_tokens:false,attempts:false},
-});
-const zeroInput = efficiencyMetrics({
-  input_tokens:0, output_tokens:10, cost:1, executions:1,
-  token_covered_executions:1, io_covered_executions:1,
-  cost_covered_executions:1, cost_covered_output_tokens:10,
-  cost_covered_cost:1,
-  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
-});
-const partialPaired = efficiencyMetrics({
-  input_tokens:600, output_tokens:15, cost:.1, executions:3,
-  token_covered_executions:3, io_covered_executions:2,
-  io_covered_input_tokens:100, io_covered_output_tokens:10,
-  coverage:{tokens:{complete:false}},
-  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
-});
-const noPaired = efficiencyMetrics({
-  input_tokens:600, output_tokens:15, cost:.1, executions:3,
-  token_covered_executions:3, io_covered_executions:0,
-  io_covered_input_tokens:0, io_covered_output_tokens:0,
-  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false,reasoning_tokens:false,attempts:false},
-});
-console.log(JSON.stringify({complete,missing,partial,coveredZero,inputOnly,zeroInput,partialPaired,noPaired}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["complete"], {
-            "output_per_dollar": 100,
-            "reasoning_ratio": 0.5,
-            "context_load": 5,
-            "cache_hit_ratio": 0.5,
-            "retry_waste": 0.25,
-            "failure_rate": 0.25,
-        })
-        self.assertEqual(payload["missing"], {
-            "output_per_dollar": None,
-            "reasoning_ratio": None,
-            "context_load": 5,
-            "cache_hit_ratio": None,
-            "retry_waste": None,
-            "failure_rate": None,
-        })
-        self.assertEqual(payload["partial"]["output_per_dollar"], 100)
-        self.assertIsNone(payload["partial"]["context_load"])
-        self.assertEqual(payload["coveredZero"]["output_per_dollar"], 0)
-        self.assertIsNone(payload["inputOnly"]["output_per_dollar"])
-        self.assertEqual(payload["zeroInput"]["context_load"], 0)
-        self.assertEqual(payload["partialPaired"]["context_load"], 10)
-        self.assertIsNone(payload["noPaired"]["context_load"])
-
-    def test_efficiency_uses_one_range_for_overall_and_per_model_statistics(self):
-        for marker in (
-            "const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all']",
-            "tm_efficiency_range", "tm_efficiency_project", "efficiencyRangeWindow", "efficiencyModelRows",
-            "aggregateModelDays(efficiencyModelRows", "efficiencyMetrics(overall)",
-            "efficiencyMetrics(row.window)", "efficiencyTrendDays",
-            "Thinking / reasoning coverage", "thinking_executions",
-            "token ratio unavailable", "e-reasoning-chart",
-            "includes local estimates", "token_covered_executions",
-            "Compare similar work · no quality judgment.",
-        ):
-            self.assertIn(marker, self.page)
-
-        self.assertIn(
-            "metric.output_per_dollar===null?'unavailable':data.coverage?.cost?.complete?'covered':'partial'",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_model_filters_keep_runtime_identities_distinct(self):
-        match = re.search(
-            r"function filterEfficiencyModels\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match, "Efficiency needs to filter by model-runtime ID")
-        script = match.group(0) + r"""
-const rows=[
-  {id:'gpt-5.6::Codex',model:'gpt-5.6',runtime:'Codex'},
-  {id:'gpt-5.6::Cursor',model:'gpt-5.6',runtime:'Cursor'},
-  {id:'claude-opus::Claude Code',model:'claude-opus',runtime:'Claude Code'},
-];
-console.log(JSON.stringify({
-  all:filterEfficiencyModels(rows,[]).map(row=>row.id),
-  selected:filterEfficiencyModels(rows,['gpt-5.6::Cursor']).map(row=>row.id),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "all": ["gpt-5.6::Codex", "gpt-5.6::Cursor", "claude-opus::Claude Code"],
-            "selected": ["gpt-5.6::Cursor"],
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_legacy_model_runtime_filter_expands_to_effort_rows(self):
-        match = re.search(
-            r"function migrateModelRuntimeFilters\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match, "Legacy model filters need effort-row migration")
-        script = match.group(0) + r"""
-const rows=[
-  {id:'gpt-5.6::Codex::high',model:'gpt-5.6',runtime:'Codex'},
-  {id:'gpt-5.6::Codex::xhigh',model:'gpt-5.6',runtime:'Codex'},
-  {id:'gpt-5.6::Codex::unavailable',model:'gpt-5.6',runtime:'Codex'},
-  {id:'gpt-5.6::Cursor::unavailable',model:'gpt-5.6',runtime:'Cursor'},
-];
-console.log(JSON.stringify({
-  legacy:migrateModelRuntimeFilters(['gpt-5.6::Codex'],rows),
-  unavailable:migrateModelRuntimeFilters(['gpt-5.6::Codex::unavailable'],rows),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "legacy": [
-                "gpt-5.6::Codex::high", "gpt-5.6::Codex::xhigh",
-                "gpt-5.6::Codex::unavailable",
-            ],
-            "unavailable": ["gpt-5.6::Codex::unavailable"],
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_model_toggle_waits_for_the_selected_project_scope(self):
-        match = re.search(
-            r"function rerenderActiveEfficiency\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match, "Efficiency needs to avoid rendering stale project stats")
-        script = match.group(0) + r"""
-let activeEfficiencyStats={models:['all-projects']};
-let activeEfficiencyScope='';
-let efficiencyProject='project-b';
-let rendered=0,requested=0;
-function renderEfficiency(){rendered++;}
-function renderActiveEfficiency(){requested++;}
-rerenderActiveEfficiency();
-activeEfficiencyScope='project-b';
-rerenderActiveEfficiency();
-console.log(JSON.stringify({rendered,requested}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {"rendered": 1, "requested": 1})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_model_effort_label_keeps_known_and_unavailable_budgets_separate(self):
-        match = re.search(r"function modelEffortLabel\(.*?\n\}", self.page, re.DOTALL)
-        self.assertIsNotNone(match, "Model rows need an explicit effort-group label")
-        script = match.group(0) + r"""
-console.log(JSON.stringify({
-  known:modelEffortLabel({reasoning_effort:'xhigh'}),
-  opus:modelEffortLabel({thinking_executions:2}),
-  missing:modelEffortLabel({}),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "known": "xhigh",
-            "opus": "thinking unavailable",
-            "missing": "unavailable",
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_effort_reads_default_only_for_apps_that_record_effort(self):
-        script = "\n".join(re.search(rf"function {name}\(.*?\n\}}", self.page, re.DOTALL).group(0)
-                           for name in ("modelEffortLabel", "efficiencyEffortLabel")) + r"""
-console.log(JSON.stringify([
-  efficiencyEffortLabel({reasoning_effort:'xhigh',providers:['codex']}),
-  efficiencyEffortLabel({providers:['claude'],thinking_executions:9}),
-  efficiencyEffortLabel({providers:['codex']}),
-  efficiencyEffortLabel({providers:['cursor']}),
-  efficiencyEffortLabel({providers:['claude','cursor']}),
-]));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        self.assertEqual(json.loads(result.stdout), ["xhigh", "default", "default", "unavailable", "unavailable"])
-        self.assertIn("effort=efficiencyEffortLabel(row)", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_delta_compares_latest_two_covered_days(self):
-        match = re.search(r"function efficiencyTrendDelta\(.*?\n\}", self.page, re.DOTALL)
-        self.assertIsNotNone(match, "Efficiency charts need a comparable-day delta helper")
-        script = match.group(0) + r"""
-console.log(JSON.stringify({
-  up:efficiencyTrendDelta([
-    {metrics:{output_per_dollar:100}}, {metrics:{output_per_dollar:null}},
-    {metrics:{output_per_dollar:125}},
-  ],'output_per_dollar'),
-  down:efficiencyTrendDelta([
-    {metrics:{reasoning_ratio:.5}}, {metrics:{reasoning_ratio:.4}},
-  ],'reasoning_ratio'),
-  unavailable:efficiencyTrendDelta([
-    {metrics:{output_per_dollar:0}}, {metrics:{output_per_dollar:25}},
-  ],'output_per_dollar'),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "up": {"text": "↑ 25.0% vs prior covered day", "direction": "up"},
-            "down": {"text": "↓ 20.0% vs prior covered day", "direction": "down"},
-            "unavailable": {"text": "No comparable prior day", "direction": ""},
-        })
-        self.assertIn('id=e-output-dollar-change', self.page)
-        self.assertIn('id=e-reasoning-change', self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_charts_smooth_daily_segments_and_default_to_thirty_days(self):
-        match = re.search(
-            r"function efficiencyChartSmoothPath\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(
-            match, "Efficiency charts need a smooth path helper for daily segments",
-        )
-        script = match.group(0) + r"""
-const rows=[
-  {index:0,value:50}, {index:1,value:30}, {index:2,value:10},
-];
-console.log(JSON.stringify({
-  smooth:efficiencyChartSmoothPath(rows,row=>row.index*10,value=>value),
-  pair:efficiencyChartSmoothPath(rows.slice(0,2),row=>row.index*10,value=>value),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "smooth": "M0.0 50.0 C3.3 43.3 6.7 36.7 10.0 30.0 C13.3 23.3 16.7 16.7 20.0 10.0",
-            "pair": "M0.0 50.0 L10.0 30.0",
-        })
-        self.assertIn("let efficiencyRange=localStorage.getItem('tm_efficiency_range')||'30';", self.page)
-        self.assertIn("if(!EFFICIENCY_RANGES.includes(efficiencyRange))efficiencyRange='30';", self.page)
-        efficiency_range = self.page.split('id=e-range aria-label="Efficiency history range">', 1)[1].split("</select>", 1)[0]
-        self.assertIn('<option value=30 selected>30 days</option>', efficiency_range)
-        self.assertNotIn('<option value=7 selected>', efficiency_range)
-        self.assertIn(
-            "renderTrendDelta('e-reasoning-change',reasoningDelta,'down',!comparison);",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_period_comparison_matches_today_yesterday_and_range_windows(self):
-        date_key = re.search(r"function dateKeyAgo\(.*\n", self.page)
-        self.assertIsNotNone(date_key, "Efficiency windows need date-key arithmetic")
-        functions = ["function localDateKey(date){return String(date.getFullYear())+'-'+String(date.getMonth()+1).padStart(2,'0')+'-'+String(date.getDate()).padStart(2,'0');}", date_key.group(0)]
-        for name in (
-            "calendarMonthWindow", "monthToDateWindow", "modelRangeWindow",
-            "efficiencyComparisonWindows", "efficiencyPeriodDelta",
-        ):
-            match = re.search(rf"function {name}\(.*?\n\}}", self.page, re.DOTALL)
-            self.assertIsNotNone(match, f"Efficiency needs {name} for matched comparisons")
-            functions.append(match.group(0))
-        script = "\n".join(functions) + r"""
-const now=new Date(2026,8,1,15,20,0);
-const today=efficiencyComparisonWindows('today',now);
-const yesterday=efficiencyComparisonWindows('yesterday',now);
-const seven=efficiencyComparisonWindows('7',now);
-const lastMonth=efficiencyComparisonWindows('last_month',new Date(2026,2,15,9,0,0));
-const month=efficiencyComparisonWindows('month',new Date(2026,2,15,9,0,0));
-console.log(JSON.stringify({
-  month:{first:month.current.days[0],last:month.current.days.at(-1),count:month.current.days.length,priorFirst:month.prior.days[0],priorLast:month.prior.days.at(-1),label:month.label},
-  lastMonth:{first:lastMonth.current.days[0],last:lastMonth.current.days.at(-1),count:lastMonth.current.days.length,priorFirst:lastMonth.prior.days[0],priorLast:lastMonth.prior.days.at(-1),label:lastMonth.label},
-  all:efficiencyComparisonWindows('all',now),
-  today:{current:today.current.days,prior:today.prior.days,label:today.label},
-  yesterday:{current:yesterday.current.days,prior:yesterday.prior.days,label:yesterday.label},
-  seven:{current:seven.current.days,prior:seven.prior.days,label:seven.label},
-  increase:efficiencyPeriodDelta({output_per_dollar:125},{output_per_dollar:100},'output_per_dollar','yesterday'),
-  unavailable:efficiencyPeriodDelta({output_per_dollar:25},{output_per_dollar:0},'output_per_dollar','yesterday'),
-  currentMissing:efficiencyPeriodDelta({context_load:null},{context_load:254},'context_load','prior 7 days'),
-  priorMissing:efficiencyPeriodDelta({context_load:12},{context_load:null},'context_load','prior 7 days'),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "month": {
-                "first": "2026-03-01", "last": "2026-03-15", "count": 15,
-                "priorFirst": "2026-02-01", "priorLast": "2026-02-28",
-                "label": "last month",
-            },
-            "lastMonth": {
-                "first": "2026-02-01", "last": "2026-02-28", "count": 28,
-                "priorFirst": "2026-01-01", "priorLast": "2026-01-31",
-                "label": "the month before",
-            },
-            "all": None,
-            "today": {
-                "current": ["2026-09-01"], "prior": ["2026-08-31"],
-                "label": "yesterday",
-            },
-            "yesterday": {
-                "current": ["2026-08-31"], "prior": ["2026-08-30"],
-                "label": "the day before",
-            },
-            "seven": {
-                "current": ["2026-08-26", "2026-08-27", "2026-08-28", "2026-08-29", "2026-08-30", "2026-08-31", "2026-09-01"],
-                "prior": ["2026-08-19", "2026-08-20", "2026-08-21", "2026-08-22", "2026-08-23", "2026-08-24", "2026-08-25"],
-                "label": "prior 7 days",
-            },
-            "increase": {"text": "↑ 25.0% vs yesterday", "direction": "up"},
-            "unavailable": {"text": "No comparable prior period", "direction": ""},
-            "currentMissing": {"text": "No comparable prior period", "direction": ""},
-            "priorMissing": {"text": "No comparable prior period", "direction": ""},
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_comparison_badge_hides_without_a_matching_period(self):
-        tone_match = re.search(
-            r"function trendTone\(.*?\n\}", self.page, re.DOTALL,
-        )
-        render_match = re.search(
-            r"function renderTrendDelta\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(tone_match)
-        self.assertIsNotNone(render_match)
-        script = tone_match.group(0) + "\n" + render_match.group(0) + r"""
-const badge={hidden:false,dataset:{},primary:{textContent:''},secondary:{textContent:''},querySelector(selector){return selector==='strong'?this.primary:this.secondary;}};
-const $=id=>badge;
-renderTrendDelta('e-output-dollar-change',{text:'No comparable prior period',direction:''},'up',true);
-console.log(JSON.stringify({hidden:badge.hidden,direction:badge.dataset.direction}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {"hidden": True, "direction": ""})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_comparison_badge_keeps_the_prior_day_relation(self):
-        tone_match = re.search(
-            r"function trendTone\(.*?\n\}", self.page, re.DOTALL,
-        )
-        match = re.search(
-            r"function renderTrendDelta\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(tone_match)
-        self.assertIsNotNone(match, "Efficiency badges need one renderer for comparison copy")
-        script = tone_match.group(0) + "\n" + match.group(0) + r"""
-const badge={dataset:{},primary:{textContent:''},secondary:{textContent:''},querySelector(selector){return selector==='strong'?this.primary:this.secondary;}};
-const $=id=>badge;
-renderTrendDelta('e-output-dollar-change',{text:'↓ 7.5% vs prior covered day',direction:'down'});
-const available={primary:badge.primary.textContent,secondary:badge.secondary.textContent,direction:badge.dataset.direction};
-renderTrendDelta('e-output-dollar-change',{text:'No comparable prior day',direction:''});
-console.log(JSON.stringify({available,unavailable:{primary:badge.primary.textContent,secondary:badge.secondary.textContent,direction:badge.dataset.direction}}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "available": {
-                "primary": "↓ 7.5%",
-                "secondary": "vs prior covered day",
-                "direction": "down",
-            },
-            "unavailable": {
-                "primary": "No comparable prior day",
-                "secondary": "",
-                "direction": "",
-            },
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_comparison_tone_respects_each_metric_direction(self):
-        match = re.search(
-            r"function trendTone\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match, "Efficiency badges need an explicit metric direction rule")
-        script = match.group(0) + r"""
-console.log(JSON.stringify({
-  outputUp:trendTone({direction:'up'},'up'),
-  outputDown:trendTone({direction:'down'},'up'),
-  contextDown:trendTone({direction:'down'},'down'),
-  contextUp:trendTone({direction:'up'},'down'),
-  unavailable:trendTone({direction:''},'up'),
-  neutral:trendTone({direction:'up'},''),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "outputUp": "improving",
-            "outputDown": "degrading",
-            "contextDown": "improving",
-            "contextUp": "degrading",
-            "unavailable": "",
-            "neutral": "",
-        })
-
-    def test_efficiency_comparisons_sit_beside_each_value_without_a_box(self):
-        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
-            "<div class=view id=view-learn>", 1,
-        )[0]
-        for value_id, comparison_id in (
-            ("e-output-dollar", "e-output-dollar-change"),
-            ("e-reasoning-ratio", "e-reasoning-change"),
-            ("e-context-load", "e-context-load-change"),
-            ("e-cache-hit", "e-cache-hit-change"),
-        ):
-            self.assertRegex(
-                efficiency,
-                rf'<div class="v mono" id={value_id}>.*?</div><div class=trendDelta id={comparison_id}[^>]*>',
-            )
-        self.assertEqual(efficiency.count('valueWithDelta"><div class="v mono"'), 4)
-        self.assertIn(":where(.valueWithDelta){display:flex;flex-wrap:wrap;align-items:center", self.page)
-        self.assertIn(":where(.trendDelta>strong){font-family:var(--font-mono);font-size:var(--fs-20)", self.page)
-        self.assertNotIn("efficiencySupportDelta", self.page)
-        self.assertNotRegex(self.page, r"\.efficiencyTrendDelta[^{]*\{")
-        self.assertIn(":where(.trendDelta){display:grid", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_presentation_labels_each_metric(self):
-        match = re.search(
-            r"function efficiencyChartMetricPresentation\(.*?\n\}", self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(
-            match, "Efficiency charts need metric-specific visible labels",
-        )
-        script = r"""
-function compactNumber(value){return value>=1000?(value/1000).toFixed(1).replace(/\.0$/,'')+'K':String(value);}
-function pct(value){return (value*100).toFixed(1)+'%';}
-function efficiencyDecimal(value){return String(value)+'x';}
-""" + match.group(0) + r"""
-console.log(JSON.stringify({
-  dollar:efficiencyChartMetricPresentation(5200,'output_per_dollar'),
-  reasoning:efficiencyChartMetricPresentation(.34,'reasoning_ratio'),
-  context:efficiencyChartMetricPresentation(256,'context_load'),
-  cache:efficiencyChartMetricPresentation(.87,'cache_hit_ratio'),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "dollar": {"axis": "5.2K", "detail": "5,200 output tokens / $"},
-            "reasoning": {"axis": "34.0%", "detail": "34.0% reasoning"},
-            "context": {"axis": "256x", "detail": "256x context / output"},
-            "cache": {"axis": "87.0%", "detail": "87.0% input from cache"},
-        })
-
-    def test_efficiency_support_cards_include_compact_daily_charts(self):
-        efficiency = self.page.split("<div class=view id=view-efficiency>", 1)[1].split(
-            "<div class=view id=view-learn>", 1,
-        )[0]
-        for metric, label in (
-            ("context-load", "Daily context load"),
-            ("cache-hit", "Daily cache hit ratio"),
-        ):
-            self.assertIn(
-                f'id=e-{metric}-chart viewBox="0 0 520 96" preserveAspectRatio=none role=img tabindex=0 aria-label="{label}"',
-                efficiency,
-            )
-        self.assertIn(".efficiencySupportItem .efficiencyChart{height:56px}", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_project_filter_groups_non_folder_labels(self):
-        match = re.search(r"function projectFilterValue\(.*?\n\}", self.page, re.DOTALL)
-        self.assertIsNotNone(match, "Project filters need folder-only values")
-        script = "const OTHER_LOCAL_SESSIONS_PROJECT='__other_local_sessions__';\n" + match.group(0) + r"""
-console.log(JSON.stringify([
-  projectFilterValue('~/Documents/github/token-meter'),
-  projectFilterValue('/repo/a'), projectFilterValue('CLI'),
-  projectFilterValue('No project'), projectFilterValue('/private/tmp/run'),
-  projectFilterValue('~/Documents/Codex/2026-08-31/task'),
-]));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), [
-            "~/Documents/github/token-meter", "/repo/a",
-            "__other_local_sessions__", "__other_local_sessions__",
-            "__other_local_sessions__",
-            "__other_local_sessions__",
-        ])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_saved_non_folder_project_filters_migrate_to_other_local_sessions(self):
-        value_match = re.search(r"function projectFilterValue\(.*?\n\}", self.page, re.DOTALL)
-        filter_match = re.search(r"function storedModelFilterId\(.*?\n\}", self.page, re.DOTALL)
-        migration_match = re.search(r"function migrateStoredProjectFilters\(.*?\n\}", self.page, re.DOTALL)
-        self.assertIsNotNone(value_match, "Project filters need folder-only values")
-        self.assertIsNotNone(filter_match, "Stored project filter values need a safe aggregate-ID boundary")
-        self.assertIsNotNone(migration_match, "Stored project filters need a grouping migration")
-        script = "const OTHER_LOCAL_SESSIONS_PROJECT='__other_local_sessions__';\n" + value_match.group(0) + "\n" + filter_match.group(0) + "\n" + migration_match.group(0) + r"""
-const storage=new Map([
- ['tm_model_project','CLI'],
- ['tm_efficiency_project','No project'],
- ['tm_global_project','~/Documents/Codex/2026-08-31/task'],
- ['tm_model_project_filters',JSON.stringify({CLI:['gpt::Codex','gpt-5.6::Codex::xhigh','/Users/alice/private-project','gpt::Codex\t','gpt::Codex\u0000']})],
- ['tm_efficiency_project_filters',JSON.stringify({'No project':['gpt::Codex']})],
-]);
-globalThis.localStorage={getItem:key=>storage.get(key)??null,setItem:(key,value)=>storage.set(key,String(value)),removeItem:key=>storage.delete(key)};
-['tm_model_project','tm_efficiency_project','tm_global_project'].forEach(key=>migrateStoredProjectFilters(key));
-migrateStoredProjectFilters('tm_model_project_filters',true);
-migrateStoredProjectFilters('tm_efficiency_project_filters',true);
-console.log(JSON.stringify(Object.fromEntries(storage)));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        stored = json.loads(result.stdout)
-        other = "__other_local_sessions__"
-        self.assertEqual(stored["tm_model_project"], other)
-        self.assertEqual(stored["tm_efficiency_project"], other)
-        self.assertEqual(stored["tm_global_project"], other)
-        self.assertEqual(json.loads(stored["tm_model_project_filters"]), {other: ["gpt::Codex", "gpt-5.6::Codex::xhigh"]})
-        self.assertEqual(json.loads(stored["tm_efficiency_project_filters"]), {other: ["gpt::Codex"]})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_range_aggregation_keeps_only_efforts_in_range(self):
-        match = re.search(
-            r"function aggregateModelDays\(rows\)\{.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match, "Efficiency needs range-scoped model aggregation")
-        script = r"""
-const MODEL_COUNTER_KEYS=[],MODEL_ARRAY_KEYS=[];
-const metricAvailable=()=>false,metricPartial=()=>false,hasLocalEstimate=()=>false;
-const usageBasis=()=> 'reported',modelWaitDistribution=()=>({median_wait_s:0,p95_wait_s:0});
-const modelMedian=()=>0;
-""" + match.group(0) + r"""
-console.log(JSON.stringify(aggregateModelDays([
-  {reasoning_efforts:['high']}, {reasoning_efforts:['xhigh', 'high']},
-]).reasoning_efforts));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), ["high", "xhigh"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_inspection_reports_exact_values_and_missing_days(self):
-        index_match = re.search(
-            r"function efficiencyChartPointerIndex\(.*?\n\}", self.page, re.DOTALL,
-        )
-        detail_match = re.search(
-            r"function efficiencyChartInspection\(.*?\n\}", self.page, re.DOTALL,
-        )
-        presentation_match = re.search(
-            r"function efficiencyChartMetricPresentation\(.*?\n\}", self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(index_match)
-        self.assertIsNotNone(detail_match)
-        self.assertIsNotNone(presentation_match)
-        script = "\n".join((
-            "function compactNumber(value){return String(Math.round(value));}",
-            "function pct(value){return (value*100).toFixed(1)+'%';}",
-            "function efficiencyDecimal(value){return String(value)+'x';}",
-            index_match.group(0), presentation_match.group(0), detail_match.group(0), r"""
-const samples=[
-  {day:'2026-08-25',index:0,value:5143.4},
-  {day:'2026-08-26',index:1,value:null},
-  {day:'2026-08-27',index:2,value:.3421},
-];
-const rect={left:100,width:520};
-console.log(JSON.stringify({
-  first:efficiencyChartPointerIndex(109,rect,3),
-  middle:efficiencyChartPointerIndex(360,rect,3),
-  last:efficiencyChartPointerIndex(611,rect,3),
-  output:efficiencyChartInspection(samples[0],'output_per_dollar'),
-  missing:efficiencyChartInspection(samples[1],'output_per_dollar'),
-  reasoning:efficiencyChartInspection(samples[2],'reasoning_ratio'),
-}));
-""",
-        ))
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "first": 0,
-            "middle": 1,
-            "last": 2,
-            "output": {
-                "date": "Aug 25",
-                "value": "5,143 output tokens / $",
-            },
-            "missing": {"date": "Aug 26", "value": "No data"},
-            "reasoning": {"date": "Aug 27", "value": "34.2% reasoning"},
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_hover_survives_live_refresh(self):
-        names = (
-            "efficiencyChartPointerIndex",
-            "efficiencyChartMetricPresentation",
-            "efficiencyChartInspection",
-            "efficiencyChartAnnouncement",
-            "chartGapRuns",
-            "chartGapBridge",
-            "efficiencyChartSmoothPath",
-            "renderEfficiencyChart",
-        )
-        functions = []
-        for name in names:
-            match = re.search(
-                rf"function {name}\(.*?\n\}}", self.page, re.DOTALL,
-            )
-            self.assertIsNotNone(match)
-            functions.append(match.group(0))
-        script = "\n".join((*functions, r"""
-class AttrNode {
-  constructor(){this.attrs={};}
-  setAttribute(name,value){this.attrs[name]=String(value);}
-}
-class InspectNode extends AttrNode {
-  constructor(){super();this.line=new AttrNode();this.dot=new AttrNode();}
-  querySelector(selector){return selector==='line'?this.line:this.dot;}
-}
-class SvgNode extends AttrNode {
-  constructor(parent){super();this.parentElement=parent;this.dataset={};this.hovered=false;this.inspect=null;}
-  set innerHTML(value){this.html=value;this.inspect=new InspectNode();}
-  get innerHTML(){return this.html;}
-  querySelector(selector){return selector==='.efficiencyChartInspect'?this.inspect:null;}
-  getBoundingClientRect(){return {left:0,width:520};}
-  matches(selector){return selector===':hover'&&this.hovered;}
-}
-const tip={hidden:true,textContent:'',style:{}},status={textContent:''};
-const parent={querySelector(selector){return selector==='.efficiencyChartTip'?tip:status;}};
-const svg=new SvgNode(parent),$=()=>svg,esc=value=>String(value);
-const pct=value=>`${Math.round(value*100)}%`,compactNumber=value=>String(Math.round(value));
-const trend=[
-  {day:'2026-08-25',metrics:{output_per_dollar:5143.4}},
-  {day:'2026-08-26',metrics:{output_per_dollar:7777}},
-  {day:'2026-08-27',metrics:{output_per_dollar:9123}},
-];
-renderEfficiencyChart('chart',trend,'output_per_dollar','Output per covered dollar');
-svg.hovered=true;
-svg.onpointermove({clientX:260});
-const first={hidden:tip.hidden,text:tip.textContent,ratio:svg.dataset.efficiencyHoverRatio};
-renderEfficiencyChart('chart',trend,'output_per_dollar','Output per covered dollar');
-const rerender={hidden:tip.hidden,text:tip.textContent,visibility:svg.inspect.attrs.visibility};
-svg.onpointermove({clientX:510});
-const moved={hidden:tip.hidden,text:tip.textContent};
-svg.hovered=false;
-svg.onpointerleave();
-const left={hidden:tip.hidden,ratio:svg.dataset.efficiencyHoverRatio||null,visibility:svg.inspect.attrs.visibility};
-svg.hovered=true;
-svg.dataset.efficiencyHoverRatio='0.5';
-renderEfficiencyChart('chart',[],'output_per_dollar','Output per covered dollar');
-const empty={hidden:tip.hidden,ratio:svg.dataset.efficiencyHoverRatio||null};
-console.log(JSON.stringify({first,rerender,moved,left,empty}));
-"""))
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "first": {
-                "hidden": False,
-                "text": "Aug 26 · 7,777 output tokens / $",
-                "ratio": "0.5",
-            },
-            "rerender": {
-                "hidden": False,
-                "text": "Aug 26 · 7,777 output tokens / $",
-                "visibility": "visible",
-            },
-            "moved": {
-                "hidden": False,
-                "text": "Aug 27 · 9,123 output tokens / $",
-            },
-            "left": {"hidden": True, "ratio": None, "visibility": "hidden"},
-            "empty": {"hidden": True, "ratio": None},
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_inspection_is_keyboard_accessible(self):
-        match = re.search(
-            r"function efficiencyChartKeyIndex\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match)
-        script = match.group(0) + r"""
-console.log(JSON.stringify({
-  left:efficiencyChartKeyIndex('ArrowLeft',2,5),
-  leftBound:efficiencyChartKeyIndex('ArrowLeft',0,5),
-  right:efficiencyChartKeyIndex('ArrowRight',2,5),
-  rightBound:efficiencyChartKeyIndex('ArrowRight',4,5),
-  home:efficiencyChartKeyIndex('Home',3,5),
-  end:efficiencyChartKeyIndex('End',1,5),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "left": 1,
-            "leftBound": 0,
-            "right": 3,
-            "rightBound": 4,
-            "home": 0,
-            "end": 4,
-        })
-        for marker in (
-            "tabindex=0",
-            "aria-live=polite",
-            "svg.onfocus",
-            "svg.onkeydown",
-            "svg.onblur",
-            "Use Left and Right arrow keys to inspect daily values.",
-        ):
-            self.assertIn(marker, self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_chart_accessibility_uses_one_fresh_announcement_path(self):
-        match = re.search(
-            r"function efficiencyChartAnnouncement\(.*?\n\}", self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(match)
-        script = match.group(0) + r"""
-const detail={date:'Aug 26',value:'No data'};
-console.log(JSON.stringify({
-  keyboard:efficiencyChartAnnouncement(detail,true),
-  pointer:efficiencyChartAnnouncement(detail,false),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "keyboard": "Aug 26 · No data",
-            "pointer": "",
-        })
-        self.assertNotIn("aria-describedby=e-output-dollar-status", self.page)
-        self.assertNotIn("aria-describedby=e-reasoning-status", self.page)
-        self.assertIn(
-            "status.textContent=efficiencyChartAnnouncement(detail,announce)",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_reasoning_cell_falls_back_to_measured_thinking_share(self):
-        match = re.search(
-            r"function efficiencyReasoningPresentation\(.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(match)
-        script = r"""
-const f=value=>Math.round(value||0).toLocaleString('en-US');
-const pct=value=>Math.round((value||0)*100)+'%';
-""" + match.group(0) + r"""
-console.log(JSON.stringify({
-  exact:efficiencyReasoningPresentation(
-    {executions:10,reasoning_executions:8,thinking_executions:8},
-    {reasoning_ratio:.375}
-  ),
-  thinking:efficiencyReasoningPresentation(
-    {executions:960,reasoning_executions:0,thinking_executions:402},
-    {reasoning_ratio:null}
-  ),
-  missing:efficiencyReasoningPresentation(
-    {executions:4,reasoning_executions:0,thinking_executions:0},
-    {reasoning_ratio:null}
-  ),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "exact": {"value": "38%", "note": "8 / 10 exec"},
-            "thinking": {
-                "value": "42% thinking execs",
-                "note": "token ratio unavailable",
-            },
-            "missing": {"value": "--", "note": "unavailable"},
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_efficiency_presentation_preserves_coverage_and_thinking_fallback(self):
-        metric_match = re.search(
-            r"function efficiencyMetrics\(row\)\{.*?\n\}", self.page, re.DOTALL,
-        )
-        reasoning_match = re.search(
-            r"function efficiencyReasoningPresentation\(.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        summary_match = re.search(
-            r"function efficiencySummaryPresentation\(.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(metric_match)
-        self.assertIsNotNone(reasoning_match)
-        self.assertIsNotNone(summary_match)
-        script = r"""
-const f=value=>Math.round(value||0).toLocaleString('en-US');
-const pct=value=>Math.round((value||0)*100)+'%';
-const compactNumber=value=>Math.round(value||0).toLocaleString('en-US');
-const hasLocalEstimate=row=>Boolean(row?.estimated);
-""" + "\n".join((
-            metric_match.group(0), reasoning_match.group(0), summary_match.group(0),
-        )) + r"""
-const exact=efficiencySummaryPresentation({
-  output_tokens:200,cost:2,executions:10,token_covered_executions:10,
-  cost_covered_executions:10,cost_covered_output_tokens:200,cost_covered_cost:2,
-  reasoning_tokens:30,reasoning_output_tokens:80,reasoning_executions:8,
-  thinking_executions:8,availability:{tokens:true,output_tokens:true,cost:true,reasoning_tokens:true},
-  coverage:{cost:{complete:true}},
-});
-const thinking=efficiencySummaryPresentation({
-  output_tokens:100,cost:1,executions:10,token_covered_executions:10,
-  cost_covered_executions:8,cost_covered_output_tokens:80,cost_covered_cost:1,
-  reasoning_executions:0,thinking_executions:4,
-  availability:{tokens:true,output_tokens:true,cost:true,reasoning_tokens:false},
-  coverage:{cost:{complete:false}},estimated:true,
-});
-const missing=efficiencySummaryPresentation({
-  executions:2,availability:{tokens:false,output_tokens:false,cost:false,reasoning_tokens:false},
-});
-console.log(JSON.stringify({exact,thinking,missing}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "exact": {
-                "output": {"value": "100 / $", "note": "covered"},
-                "reasoning": {"value": "38%", "note": "8 / 10 exec"},
-            },
-            "thinking": {
-                "output": {"value": "80 / $", "note": "partial · local est"},
-                "reasoning": {
-                    "value": "40% thinking execs",
-                    "note": "token ratio unavailable · local est",
-                },
-            },
-            "missing": {
-                "output": {"value": "--", "note": "unavailable"},
-                "reasoning": {"value": "--", "note": "unavailable"},
-            },
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_only_marks_thinking_token_splits_unavailable_when_uncovered(self):
-        match = re.search(
-            r"function thinkingUnavailableExecutions\(row\)\{.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(match)
-        script = match.group(0) + r"""
-console.log(JSON.stringify({
-  unavailable:thinkingUnavailableExecutions({thinking_executions:2,thinking_covered_executions:0,reasoning_executions:0}),
-  partial:thinkingUnavailableExecutions({thinking_executions:3,thinking_covered_executions:1,reasoning_executions:1}),
-  exact:thinkingUnavailableExecutions({thinking_executions:1,thinking_covered_executions:1,reasoning_executions:1}),
-  unrelated:thinkingUnavailableExecutions({thinking_executions:1,thinking_covered_executions:0,reasoning_executions:4}),
-  codexOnly:thinkingUnavailableExecutions({thinking_executions:0,thinking_covered_executions:0,reasoning_executions:4}),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "unavailable": 2,
-            "partial": 2,
-            "exact": 0,
-            "unrelated": 1,
-            "codexOnly": 0,
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_efficiency_model_table_defaults_to_spend_descending_and_sorts_nulls_last(self):
-        metric_match = re.search(
-            r"function efficiencyMetrics\(row\)\{.*?\n\}", self.page, re.DOTALL,
-        )
-        value_match = re.search(
-            r"function efficiencySortValue\(row,key\)\{.*?\n\}", self.page, re.DOTALL,
-        )
-        sort_match = re.search(
-            r"function sortEfficiencyRows\(rows,sort=efficiencySort\)\{.*?\n\}",
-            self.page, re.DOTALL,
-        )
-        self.assertIsNotNone(metric_match)
-        self.assertIsNotNone(value_match)
-        self.assertIsNotNone(sort_match)
-        script = "\n".join((
-            metric_match.group(0),
-            "const modelRuntimeLabel=row=>`${row.model} · ${row.runtime}`;",
-            "const efficiencySort={key:'cost',direction:'desc'};",
-            value_match.group(0), sort_match.group(0),
-            r"""
-const rows=[
-  {model:'low',runtime:'Claude Code',window:{cost:1,availability:{cost:true}}},
-  {model:'missing',runtime:'Claude Code',window:{cost:0,availability:{cost:false}}},
-  {model:'high',runtime:'Codex',window:{cost:4,availability:{cost:true}}},
-];
-console.log(JSON.stringify({
-  spend:sortEfficiencyRows(rows).map(row=>row.model),
-  efficiency:sortEfficiencyRows(rows,{key:'output_per_dollar',direction:'desc'}).map(row=>row.model),
-}));
-""",
-        ))
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["spend"], ["high", "low", "missing"])
-        self.assertEqual(payload["efficiency"][-1], "missing")
-
-    def test_model_day_merge_preserves_partial_source_coverage(self):
-        merge_match = re.search(
-            r"function mergeModelDays\(models,window\)\{.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        aggregate_match = re.search(
-            r"function aggregateModelDays\(rows\)\{.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(merge_match, "dashboard needs the shared day merge")
-        self.assertIsNotNone(aggregate_match, "dashboard needs the shared day aggregate")
-        script = r"""
-const MODEL_COUNTER_KEYS=['cost','input_tokens','output_tokens','executions'];
-const MODEL_ARRAY_KEYS=[];
-const modelDayInRange=()=>true;
-const metricAvailable=(row,key)=>row.availability?.[key]===true;
-const metricPartial=(row,key)=>row.coverage?.[key]?.complete===false;
-const hasLocalEstimate=()=>false;
-const usageBasis=()=> 'reported';
-const modelWaitDistribution=()=>({median_wait_s:0,p95_wait_s:0});
-const modelMedian=()=>0;
-""" + aggregate_match.group(0) + "\n" + merge_match.group(0) + r"""
-const rows=mergeModelDays([{daily:[{
-  day:'2026-08-27',cost:1,input_tokens:10,output_tokens:2,executions:2,
-  availability:{tokens:true,input_tokens:true,output_tokens:false,cost:true,cache:true},
-  coverage:{
-    tokens:{complete:false},cost:{complete:false},cache:{complete:false},
-  },
-}]}],{});
-const selectedSession=aggregateModelDays([{
-  cost:1,input_tokens:10,output_tokens:4,executions:2,
-  cost_covered_executions:1,cost_covered_output_tokens:2,cost_covered_cost:.5,
-  availability:{tokens:true,input_tokens:true,output_tokens:true,cost:true,cache:false},
-}]);
-console.log(JSON.stringify({merged:rows[0],total:aggregateModelDays(rows),selectedSession}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        coverage = payload["merged"]["coverage"]
-        self.assertFalse(coverage["tokens"]["complete"])
-        self.assertFalse(coverage["cost"]["complete"])
-        self.assertFalse(coverage["cache"]["complete"])
-        self.assertTrue(payload["merged"]["availability"]["input_tokens"])
-        self.assertFalse(payload["merged"]["availability"]["output_tokens"])
-        self.assertTrue(payload["total"]["availability"]["input_tokens"])
-        self.assertFalse(payload["total"]["availability"]["output_tokens"])
-        self.assertFalse(payload["selectedSession"]["coverage"]["cost"]["complete"])
-
-    def test_model_stats_supports_multi_model_comparison(self):
-        for marker in (
-            "id=m-model-picker", "id=m-model-options", "id=m-model-summary",
-            "tm_model_filters", "MODEL_COLORS", "buildModelTrend",
-            "bars show output", "observed tok/s",
-            "modelTipMetrics",
-            "Typical wait", "median wait", "human pause excluded",
-            "modelWaitDistribution", "wait_durations_s", "p95_wait_s",
-            "Matched pace", "renderMatchedPace", "modelRuntimeLabel",
-            "migrateModelRuntimeFilters", "Typical workload (approximate shape, not semantic difficulty)", "median_peak_input_tokens",
-            "95% CI", "Select 2 models", "TTFT unavailable",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn('id=m-model aria-label="Models filter"', self.page)
-        self.assertNotIn("Speed change", self.page)
-
-    def test_model_colors_encode_runtime_family_and_keep_volume_neutral(self):
-        """Flattening runtime families or recoloring volume bars breaks chart meaning."""
-        start = self.page.find("// model-color-logic-start")
-        end = self.page.find("// model-color-logic-end")
-        logic = self.page[start:end] if start >= 0 and end > start else ""
-        script = logic + """
-const names = [
-  'gpt-5.6-sol::Codex',
-  'gpt-5.6-terra::Codex',
-  'codex-auto-review::Codex',
-  'gpt-5.6-luna::Codex',
-  'claude-opus-4-8::Claude Code',
-  'claude-sonnet-5::Claude Code',
-  'claude-haiku-4-5::Claude-3P',
-  'claude-opus-4-8::Claude-3P',
-  'claude-sonnet-5::Claude-3P',
-  'composer-2.5::Cursor',
-  'claude-sonnet-4-6::Kiro',
-  'qwen3::OpenCode',
-  'other::Unknown',
-];
-console.log(JSON.stringify({
-  codex: [modelColor(names[2], names), modelColor(names[3], names), modelColor(names[0], names), modelColor(names[1], names)],
-  claude: [modelColor(names[4], names), modelColor(names[5], names)],
-  thirdParty: [modelColor(names[6], names), modelColor(names[7], names), modelColor(names[8], names)],
-  cursor: modelColor(names[9], names),
-  kiro: modelColor(names[10], names),
-  openCode: modelColor(names[11], names),
-  fallback: modelColor(names[12], names),
-  stable: modelColor(names[0], names) === modelColor(names[0], [...names].reverse()),
-  paint: modelTrendPaint('#FFAA64'),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), {
-            "codex": ["#6F9CFF", "#8EC5FF", "#4C86F0", "#B6CFFF"],
-            "claude": ["#E3825C", "#F4A26E"],
-            "thirdParty": ["#A46AF4", "#AD88F0", "#7459F0"],
-            "cursor": "#3CC6C0",
-            "kiro": "#E3CC5C",
-            "openCode": "#FF8FB8",
-            "fallback": "#A9B8C7",
-            "stable": True,
-            "paint": {
-                "barFill": "#536879",
-                "barStroke": "#7890A3",
-                "line": "#FFAA64",
-            },
-        })
-
-    def test_ranked_model_groups_get_distinct_family_shades(self):
-        """Top-ranked groups of one runtime must not share a color in Models charts."""
-        start = self.page.find("// model-color-logic-start")
-        end = self.page.find("// model-color-logic-end")
-        logic = self.page[start:end] if start >= 0 and end > start else ""
-        script = logic + """
-const groups = [
-  {key: 'a', ids: ['gpt-5.6-sol::Codex']},
-  {key: 'b', ids: ['claude-opus-4-8::Claude Code']},
-  {key: 'c', ids: ['gpt-5.6-terra::Codex']},
-  {key: 'd', ids: ['gpt-5.6-luna::Codex']},
-  {key: 'e', ids: ['gpt-6-sol::Codex']},
-];
-const colors = modelRankedColors(groups);
-console.log(JSON.stringify(groups.map(group => colors.get(group.key))));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        colors = json.loads(result.stdout)
-        self.assertEqual(colors, ["#6F9CFF", "#E3825C", "#8EC5FF", "#4C86F0", "#B6CFFF"])
-        self.assertEqual(len(set(colors)), 5)
-        single_runtime = logic + """
-const groups = ['a', 'b', 'c', 'd', 'e'].map(key => ({key, ids: [`model-${key}::Claude Code`]}));
-const colors = modelRankedColors(groups);
-console.log(JSON.stringify(groups.map(group => colors.get(group.key))));
-"""
-        result = subprocess.run(["node", "-e", single_runtime], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        colors = json.loads(result.stdout)
-        self.assertEqual(colors[0], "#E3825C")
-        self.assertEqual(len(set(colors)), 5)
-
-    def test_model_trend_omits_legend_and_limits_hover_to_relevant_metrics(self):
-        self.assertNotIn("id=m-legend", self.page)
-        self.assertNotIn("$('m-legend')", self.page)
-        for marker in (
-            "function modelTrendRowHasUsage(row)",
-            "Number(row?.input_tokens||0)>0",
-            "Number(row?.output_tokens||0)>0",
-            "Number(row?.executions||0)>0",
-            ".filter(item=>modelTrendRowHasUsage(item.row))",
-            "(rows.length?'':'<div class=r><span>No data</span></div>')",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn(
-            '<div class=modelTipName title="${esc(item.model)}"><i class=modelSwatch '
-            'style="background:${item.color}"></i>${esc(item.model)}</div>',
-            self.page,
-        )
-        model_trend = self.page.split("function drawModelTrend(chart){", 1)[1].split(
-            "function renderMatchedPace", 1
-        )[0]
-        for marker in (
-            "const outputAvailable=metricAvailable(item.row,'tokens')",
-            "const selectedAvailable=metric.available(item.row)",
-            "<small>output</small>", "<small>${esc(metric.note)}</small>",
-            "${outputAvailable?compactNumber(item.row.output_tokens||0):'--'}",
-            "${selectedAvailable?metric.format(metric.value(item.row)):'--'}",
-        ):
-            self.assertIn(marker, model_trend)
-        for marker in (
-            "<small>input</small>", "<small>executions</small>",
-            "<small>avg input</small>", "<small>avg output</small>",
-            "<small>tok/s</small>", "<small>typical wait</small>",
-        ):
-            self.assertNotIn(marker, model_trend)
-
-    def test_model_stats_supports_project_scoped_average_io_trends(self):
-        for marker in (
-            "id=m-project", "tm_model_project", "tm_model_project_filters",
-            "/model-stats?project=", "renderActiveModelStats",
-            "modelProjectRequest", "modelProjectLoadingKey",
-            "data-model-metric=avg_input", "data-model-metric=avg_output",
-            "MODEL_TREND_METRICS", "modelTokensPerExecution",
-            "Model trends", "avg input / execution", "avg output / execution",
-            "input / exec", "output / exec",
-            "Daily model ${metric.note} and output token volume",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("modelProjectCache.set(key,payload.model_stats)", self.page)
-        self.assertIn("request!==modelProjectRequest||project!==modelProject", self.page)
-        self.assertNotIn(
-            "$('m-trend-title').textContent=modelTrendMetric==='wait'",
-            self.page,
-        )
-
-    def test_model_filter_menus_stay_stable_during_live_refreshes(self):
-        for marker in (
-            "setLogSelectOptions(projectSelect,projectOptions,modelProject)",
-            "setLogHtml($('m-model-options'),modelPickerOptions)",
-            "function positionModelPickerMenu()",
-            "picker.classList.toggle('opensUp',opensUp)",
-            "$('m-model-picker').addEventListener('toggle',()=>requestAnimationFrame(positionModelPickerMenu))",
-            ":is(.modelHead,.efficiencyHead).spectrumPageHead{overflow:hidden;z-index:2}",
-            ".spectrumPageHeadFrame:has(.modelControls){z-index:10}",
-            ".modelPicker.opensUp .modelPickerMenu{top:auto;bottom:calc(100% + 6px)}",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_efficiency_model_filter_stacks_above_its_chart(self):
-        self.assertIn(
-            ".spectrumPageHeadFrame:has(.modelControls){z-index:10}",
-            self.page,
-        )
-
-    def test_model_project_background_refresh_does_not_shift_the_page(self):
-        for marker in (
-            "function setModelProjectLoading(loading)",
-            "projectSelect.setAttribute('aria-busy','true')",
-            "setModelProjectLoading(false);",
-            "$('m-project-status').textContent='';",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("Loading ${project}", self.page)
-
-    def test_session_card_hover_preserves_the_live_card_node(self):
-        for marker in (
-            "currentGrid=$('current-session-grid'),interactingCurrentSessionCard=currentGrid.querySelector('.currentSessionSlot:hover,.currentSessionCard:focus,.currentSessionDesktop:focus');",
-            "const mountedCurrentSessionIds=[...currentGrid.querySelectorAll('.currentSessionCard[data-current-session-id]')].map(card=>card.dataset.currentSessionId);",
-            "if(currentSessionDragId||(interactingCurrentSessionCard&&currentSessionIdsMatch(mountedCurrentSessionIds,rows))){syncCurrentSessionActivity(currentGrid,rows);return;}",
-            "card.classList.remove('activity-working','activity-waiting','activity-recent');",
-            "body.spectrumApp.sessionRoute #view-session .currentSessionCard:hover{transform:none}",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_model_trend_hover_panel_is_scrollable_and_pointer_stable(self):
-        model_trend = self.page.split("function drawModelTrend(chart){", 1)[1].split(
-            "function renderMatchedPace", 1
-        )[0]
-        for marker in (
-            '#m-chart-tip{pointer-events:auto;overscroll-behavior:contain;',
-            "scrollbar-gutter:stable",
-            '#m-chart-tip .h{position:sticky;top:0',
-            'id=m-chart-tip tabindex=0 aria-label="Model details for hovered day"',
-            "const scheduleTipHide=()=>",
-            "setTimeout(hideTip,180)",
-            "hit.onpointerleave=scheduleTipHide",
-            "tip.onpointerenter=cancelTipHide",
-            "tip.onpointerleave=scheduleTipHide",
-            "rightX+tip.offsetWidth<=rect.width-8",
-            "if(dayChanged)tip.scrollTop=0",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("hit.onpointerleave=()=>tip.style.display='none'", model_trend)
-
-    def test_wait_time_is_first_class_across_current_logs_and_models(self):
-        for marker in (
-            "data-chart=wait", "drawWaitChart", "data-gsort=wait",
-            "id=lf-wait", "id=m-wait", "id=m-metric", "data-model-metric=wait",
-            "Prompt-to-completed-response", "lower is better",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("wait_time?.total_s", self.page)
-        self.assertIn("CURRENT?.wait_time?.samples", self.page)
-
-    def test_session_chart_only_offers_linear_and_cumulative_scales(self):
-        scale_controls = self.page.split('<div class=seg id=scale>', 1)[1].split(
-            "</div>", 1
-        )[0]
-        self.assertIn("data-scale=linear", scale_controls)
-        self.assertIn("data-scale=cumulative", scale_controls)
-        self.assertNotIn("data-scale=sqrt", scale_controls)
-        self.assertNotIn("data-scale=log", scale_controls)
-        self.assertIn("const CHART_SCALES=['linear','cumulative'];", self.page)
-        self.assertIn("if(!CHART_SCALES.includes(chartScale))", self.page)
-        self.assertIn("localStorage.setItem('tm_chart_scale',chartScale);", self.page)
-        self.assertNotIn("if(scale==='sqrt')", self.page)
-        self.assertNotIn("if(scale==='log')", self.page)
-
-    def test_models_history_supports_exact_local_days(self):
-        history = self.page.split(
-            'id=m-range aria-label="Models history range"', 1
-        )[1].split("</select>", 1)[0]
-        expected = (
-            '<option value=today>Today</option>',
-            '<option value=yesterday>Yesterday</option>',
-            '<option value=7>7 days</option>',
-            '<option value=30 selected>30 days</option>',
-            '<option value=90>90 days</option>',
-            '<option value=month>Month</option>',
-            '<option value=last_month>Last month</option>',
-            '<option value=all>All history</option>',
-        )
-        for option in expected:
-            self.assertIn(option, history)
-        self.assertEqual([history.index(option) for option in expected], sorted(
-            history.index(option) for option in expected
-        ))
-        for marker in (
-            "const MODEL_RANGES=['today','yesterday','7','30','90','month','last_month','all'];",
-            "const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all'];",
-            "const DELIVERY_RANGES=['today','yesterday','7','30','90','month','last_month'];",
-            "let deliveryRange=localStorage.getItem('tm_delivery_range')||'30';",
-            "if(!DELIVERY_RANGES.includes(deliveryRange)){deliveryRange='30';localStorage.setItem('tm_delivery_range',deliveryRange);}",
-            "if(!MODEL_RANGES.includes(modelRange))",
-            "function modelRangeWindow(range,now=new Date())",
-            "if(range==='today'||range==='yesterday')",
-            "function modelDayInRange(day,window)",
-            "mergeModelDays(selected,rangeWindow)",
-            "buildModelTrend(selected,rangeWindow,names)",
-            ".filter(day=>modelDayInRange(day.day,rangeWindow))",
-            "modelRangeLabel(modelRange)",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_session_chart_supports_cumulative_cost_and_token_views(self):
-        for marker in (
-            "data-scale=cumulative",
-            "Show running estimated cost or token totals through each execution.",
-            "const CHART_SCALES=['linear','cumulative'];",
-            "if(!CHART_SCALES.includes(chartScale))",
-            "b.setAttribute('aria-pressed',selected?'true':'false');",
-            "function cumulativeChartParts(parts,mode)",
-            "const keys=mode==='cost'?['cost']:['fresh','read','write','cache','total','out'];",
-            "keys.forEach(key=>{sums[key]+=Math.max(0,Number(part[key]||0));});",
-            "const cumulativeTokens=mode==='tokens'&&chartScale==='cumulative';",
-            "const cumulativeCost=mode==='cost'&&chartScale==='cumulative';",
-            "const cumulativeValues=cumulativeTokens||cumulativeCost;",
-            "parts=cumulativeValues?cumulativeChartParts(rawParts,mode):rawParts",
-            "running estimated cost through each execution",
-            "running token totals through each execution",
-            "cumulative cost",
-            "cumulative usd",
-            "cumulative tokens",
-            "const tokenPrefix=cumulativeTokens?'cumulative ':'';",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("rawParts.map(p=>p.tools)", self.page)
-        self.assertIn("rawParts.map(p=>p.reason)", self.page)
-
-    def test_model_pricing_is_editable_and_supports_new_models_in_settings(self):
-        for marker in (
-            "id=model-pricing-settings", "id=model-pricing-rows",
-            "id=model-price-scope", "id=model-price-scope-from-now",
-            "id=model-price-scope-from-date", "id=model-price-scope-all-history",
-            "value=from_now", "value=from_date", "value=all_history",
-            "id=model-price-effective-from", "id=model-price-scope-note",
-            "id=model-pricing-reviewed", "id=model-pricing-sources",
-            "id=model-price-add-form", "id=model-price-provider",
-            "id=model-price-model", "id=model-price-input",
-            "id=model-price-output", "id=model-price-cache-write",
-            "id=model-price-cache-read", "id=model-price-save-changes",
-            "id=model-price-save-changes type=button disabled",
-            "data-model-price-select", "data-model-price-lifecycle",
-            "function renderModelPricing",
-            "function modelPriceEffectiveFrom", "function updateModelPriceScope",
-            "function confirmModelPriceHistory",
-            "function saveModelPriceChanges", "/settings/model-pricing",
-            "apply_to_all_history", "From now", "From date", "All history",
-            "Save models", "Restore built-in price", "Remove custom model",
-            "changes",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("USD per 1 million tokens", self.page)
-        self.assertIn("By default, a change starts now and older sessions retain their earlier prices.", self.page)
-        self.assertIn("<span id=model-price-scope-note></span>", self.page)
-        self.assertIn("Choose the date", self.page)
-        self.assertIn("older session estimates", self.page)
-        self.assertIn(".modelPriceScope.history", self.page)
-        self.assertIn("badge.hidden=!hasCustomPricing", self.page)
-        self.assertIn("source==='built-in'?'':source", self.page)
-        self.assertIn("sourceLabel?`<span class=modelPriceSource>", self.page)
-        self.assertIn("row.overridden", self.page)
-        self.assertIn("pricing.sources", self.page)
-        self.assertIn("pricing.reviewed_on", self.page)
-        self.assertIn("modelPriceSelectionState(modelPricingSelected.size)", self.page)
-        self.assertIn("@media(max-width:700px){.modelPriceTableWrap{overflow:visible", self.page)
-        self.assertIn(".modelPriceTable{display:block;min-width:0", self.page)
-        self.assertIn("data-label=", self.page)
-        self.assertNotIn("data-model-price-save", self.page)
-        self.assertNotIn("Built-in defaults", self.page)
-        self.assertLess(
-            self.page.index("id=model-pricing-settings"),
-            self.page.index("id=delivery-settings"),
-        )
-        self.assertNotIn("id=cursor-source-status", self.page)
-        self.assertNotIn("Local trace source", self.page)
-        self.assertNotIn("function renderCursorSourceStatus", self.page)
-        self.assertIn("h==='settings-budgets'||h==='budgets'", self.page)
-        self.assertIn("'model-pricing':'model-pricing-settings'", self.page)
-        self.assertIn("if(card)scrollToSettingsCard(card);", self.page)
-
-    def test_model_pricing_groups_rows_by_provider_tabs_in_a_bounded_scroll(self):
-        pricing = self.page.split("id=model-pricing-settings", 1)[1].split(
-            "id=delivery-settings", 1,
-        )[0]
-        self.assertIn('id=model-price-tabs role=tablist', pricing)
-        self.assertIn('id=model-price-table-wrap', pricing)
-        self.assertLess(
-            pricing.index("id=model-price-tabs"),
-            pricing.index("id=model-pricing-rows"),
-        )
-        for marker in (
-            "function renderModelPriceTabs",
-            "function applyModelPriceTab",
-            "function selectModelPriceTab",
-            'data-model-price-provider="${esc(row.provider)}"',
-            "root.dataset.modelPriceProvider!==modelPricingTab",
-            "modelPricingSelected.has(modelPriceKey(row.provider,row.model))",
-            "event.key==='ArrowRight'",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertRegex(
-            self.page,
-            r"\.modelPriceTableWrap\{overflow:auto;max-height:min\(460px,58vh\)",
-        )
-        self.assertIn(".modelPriceTable tr[hidden]{display:none!important}", self.page)
-
-    def test_model_pricing_uses_explicit_row_selection_without_an_actions_column(self):
-        pricing = self.page.split("id=model-pricing-settings", 1)[1].split(
-            "id=delivery-settings", 1,
-        )[0]
-        for marker in (
-            "Apply to selected models",
-            "id=model-price-selection-count",
-            "No models selected",
-        ):
-            self.assertIn(marker, pricing)
-        for marker in (
-            "data-model-price-select",
-            "data-model-price-lifecycle",
-            "function setModelPriceSelected",
-            "function updateModelPriceSelectionState",
-            "modelPricingSelected",
-            "setModelPriceSelected(root,true,false)",
-            "keys=[...modelPricingSelected]",
-            "Restore built-in price",
-            "Remove custom model",
-            "Select ${row.model} for price update",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("<th class=num>Actions</th>", pricing)
-        self.assertNotIn('data-label="Action"', pricing)
-        self.assertNotIn("class=modelPriceActions", self.page)
-        self.assertIn(
-            ".modelPriceTable tr{display:grid;grid-template-columns:repeat(2,minmax(0,1fr))",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_model_price_selection_copy_tracks_the_selected_count(self):
-        match = re.search(
-            r"function modelPriceSelectionState\(count\)\{.*?\n\}",
-            self.page,
-            re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs one selection-copy helper")
-        script = match.group(0) + """
-console.log(JSON.stringify([
-  modelPriceSelectionState(0),
-  modelPriceSelectionState(1),
-  modelPriceSelectionState(3),
-]));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), [
-            {"summary": "No models selected", "button": "Save models", "disabled": True},
-            {"summary": "1 model selected", "button": "Save 1 model", "disabled": False},
-            {"summary": "3 models selected", "button": "Save 3 models", "disabled": False},
-        ])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_restore_built_in_price_follows_scope_and_stays_reachable(self):
-        functions = []
-        for name in (
-            "modelPriceScopePayload", "requestModelPrice", "updateModelPriceScope",
-            "modelPriceLifecycle", "applyModelPriceLifecycle",
-        ):
-            match = re.search(
-                rf"^(?:async )?function {name}\(.*?^\}}\n", self.page,
-                re.MULTILINE | re.DOTALL,
-            )
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        script = """
-const sent=[],confirms=[],scoped=[],toasts=[],statuses=[],notes={};let row,scope='from_now';
-const modelPricingSelected=new Set(),LATEST=null,els={};
-const $=id=>els[id]||(els[id]={id,textContent:'',className:'',disabled:false,classList:{toggle(){}}});
-const modelPriceKey=(p,m)=>p+'/'+m,agentActionToken=()=>'t';
-const modelPriceScope=()=>scope,modelPriceEffectiveFrom=()=>null;
-const modelPriceRowFor=()=>row,renderModelPricing=()=>{},refreshLiveState=async()=>{};
-const showAppToast=toast=>toasts.push(toast.title+': '+toast.body);
-const confirm=text=>{confirms.push(text);return true;};
-const confirmModelPriceHistory=(action)=>{scoped.push(action);return true;};
-const fetch=async(url,options)=>{const body=JSON.parse(options.body);sent.push(body);return {ok:true,json:async()=>({ok:true,effective_scope:body.apply_to_all_history?'all_history':'now',model_pricing:{}})};};
-""" + "".join(functions) + """
-(async()=>{
- const button={textContent:'',disabled:false};
- const rows={
-  overridden:{provider:'codex',model:'gpt-5.6',builtin:true,custom:false,active:true,overridden:true,periods:1},
-  leftover:{provider:'codex',model:'gpt-5.6',builtin:true,custom:false,active:true,overridden:false,periods:2},
-  plain:{provider:'codex',model:'gpt-5.6',builtin:true,custom:false,active:true,overridden:false,periods:0},
-  custom:{provider:'codex',model:'mine',builtin:false,custom:true,active:true,overridden:false,periods:1},
-  retired:{provider:'codex',model:'mine',builtin:false,custom:true,active:false,overridden:false,periods:2},
- };
- const lifecycles=Object.fromEntries(Object.entries(rows).map(([k,v])=>[k,modelPriceLifecycle(v)]));
- const run=async(key,selected)=>{scope=selected;row=rows[key];const before=sent.length;await applyModelPriceLifecycle(button);statuses.push([key,selected,sent.length-before,$('model-pricing-status').textContent]);};
- await run('overridden','from_now');
- await run('leftover','from_now');
- await run('leftover','all_history');
- await run('custom','from_now');
- await run('retired','from_now');
- for(scope of ['from_now','from_date','all_history']){updateModelPriceScope();notes[scope]=$('model-price-scope-note').textContent;}
- console.log(JSON.stringify({lifecycles,sent,confirms,scoped,toasts,statuses,notes}));
-})();
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        out = json.loads(result.stdout)
-        restore = {"label": "Restore built-in price", "scope": None}
-        self.assertEqual(out["lifecycles"], {
-            "overridden": restore,
-            "leftover": restore,
-            "plain": None,
-            "custom": {"label": "Remove custom model", "scope": None},
-            "retired": {"label": "Remove custom model", "scope": "all_history"},
-        })
-        # Restore follows the selected scope, so a From-now restore keeps older dated prices.
-        self.assertEqual(out["sent"], [
-            {"provider": "codex", "model": "gpt-5.6", "remove": True,
-             "apply_to_all_history": False},
-            {"provider": "codex", "model": "gpt-5.6", "remove": True,
-             "apply_to_all_history": True},
-            {"provider": "codex", "model": "mine", "remove": True,
-             "apply_to_all_history": False},
-            {"provider": "codex", "model": "mine", "remove": True,
-             "apply_to_all_history": True},
-        ])
-        self.assertEqual(out["scoped"], [
-            "Restore built-in pricing", "Restore built-in pricing", "Retire this custom price",
-        ])
-        self.assertEqual(out["confirms"], ["Delete mine from all saved pricing history?"])
-        # A row already built-in from now explains how to clear its saved periods instead of no-op saving.
-        self.assertEqual(out["statuses"][1][:3], ["leftover", "from_now", 0])
-        self.assertIn("Choose All history, then restore", out["statuses"][1][3])
-        self.assertNotIn("From date", out["statuses"][1][3])
-        self.assertEqual(out["toasts"][1], "Already on built-in prices: " + out["statuses"][1][3])
-        self.assertIn("id=model-pricing-status role=status aria-live=polite", self.page)
-        self.assertEqual(out["statuses"][2][:3], ["leftover", "all_history", 1])
-        self.assertEqual(out["toasts"][2],
-                         "Default price restored: gpt-5.6 uses built-in prices across all history.")
-        self.assertEqual(out["notes"]["from_now"],
-                         "Changes start when you save; older session estimates keep their prior prices.")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_settings_polling_pauses_while_the_user_is_selecting_or_editing(self):
-        functions = []
-        for name in ("settingsInteractionActive", "budgetInteractionActive"):
-            match = re.search(rf"^function {name}\(\)\{{[^\n]*\}}\n", self.page, re.MULTILINE)
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        for name in ("viewInteractionActive", "renderSettings", "renderSpendView"):
-            match = re.search(
-                rf"^function {name}\(.*?^\}}\n",
-                self.page,
-                re.MULTILINE | re.DOTALL,
-            )
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        script = """
-let settingsPointerActive=false;
-let region='settings';
-const view={contains:node=>Boolean(node?.inside===region&&region==='settings')};
-const budgetView={contains:node=>Boolean(node?.inside===region&&region==='budgets')};
-const field={get inside(){return region;},matches:selector=>selector.includes('input')};
-const outside={inside:null,matches:()=>false};
-let activeElement=outside;
-let selection={isCollapsed:true,rangeCount:0,anchorNode:null,focusNode:null};
-const document={get activeElement(){return activeElement;}};
-const window={getSelection:()=>selection};
-const $=id=>id==='view-settings'?view:id==='spend-budgets'?budgetView:null;
-let calls=[];
-const renderBudgets=()=>calls.push('budgets');
-const renderModelPricing=()=>calls.push('pricing');
-const renderSpend=()=>calls.push('spend');
-function render(){renderSettings(xs);renderSpendView(xs);}
-""" + "\n".join(functions) + """
-const xs={model_pricing:{}};
-const out={};
-for(const where of ['settings','budgets']){
- region=where;
- activeElement=field;
- calls=[];render();out[where+'Focused']=[...calls];
- activeElement=outside;
- selection={isCollapsed:false,rangeCount:1,anchorNode:{inside:where},focusNode:{inside:where}};
- calls=[];render();out[where+'Selected']=[...calls];
- selection={isCollapsed:true,rangeCount:0,anchorNode:null,focusNode:null};
- settingsPointerActive=true;
- calls=[];render();out[where+'Dragging']=[...calls];
- settingsPointerActive=false;
-}
-calls=[];render();out.idle=[...calls];
-console.log(JSON.stringify(out));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "settingsFocused": ["spend", "budgets"],
-            "settingsSelected": ["spend", "budgets"],
-            "settingsDragging": ["spend"],
-            "budgetsFocused": ["pricing", "spend"],
-            "budgetsSelected": ["pricing", "spend"],
-            "budgetsDragging": ["spend"],
-            "idle": ["pricing", "spend", "budgets"],
-        })
-
-    def test_execution_overview_separates_activity_from_removable_optimization(self):
-        for marker in ("id=ov-activity-tools", "id=ov-optional-use", "id=ov-unused-packs"):
-            self.assertIn(marker, self.page)
-        self.assertIn("renderCurrentOptimization(s)", self.page)
-        self.assertIn("function setCapabilityStatBar(id,value)", self.page)
-        self.assertLess(
-            self.page.index("function setCapabilityStatBar(id,value)"),
-            self.page.index("setCapabilityStatBar('ov-optional-bar'"),
-        )
-        self.assertIn("if(!bar)return;", self.page)
-        self.assertIn("bar.setAttribute('aria-valuetext',label);", self.page)
-        self.assertNotIn("renderCapabilityUsage('ov-cap'", self.page)
-        self.assertIn("Default tools and MCP servers are read-only evidence", self.page)
-
-    def test_tools_leads_with_stats_review_queue_and_visible_inventory(self):
-        self.assertRegex(self.page, r"id=tab-capabilities[^>]*>.*?<span class=tabLabel>Tools</span>")
-        tools = self.page.split("id=view-capabilities", 1)[1].split(
-            "id=view-settings", 1
-        )[0]
-        for marker in (
-            'aria-label="Capability overview"', "id=c-stat-tools",
-            "id=c-stat-mcps", "id=c-stat-skills", "data-cap-jump=tool",
-            "id=c-review-queue", "id=c-review-list",
-            "id=c-selection-bar", "id=c-disable-selected",
-            "id=c-inventory", "id=c-clear-filters", "id=c-active-filters",
-            'aria-label="Prompt-load evidence"',
-        ):
-            self.assertIn(marker, tools)
-        self.assertLess(tools.index('aria-label="Capability overview"'), tools.index("id=c-review-queue"))
-        self.assertLess(tools.index("id=c-review-queue"), tools.index("id=c-inventory"))
-        self.assertRegex(tools, r"<section class=\"card capInventory\" id=c-inventory")
-        self.assertNotIn('class="card capInventory" id=c-inventory-details', tools)
-        self.assertNotIn("id=c-catalog-details", tools)
-        self.assertIn('class="capPageHead spectrumPageHead"', tools)
-        self.assertIn("class=spectrumPageHeadCopy", tools)
-        tools_head = tools.split('<section class="card capStats"', 1)[0]
-        for removed in (
-            "hasPageActions", "spectrumPageActions", "capFreshness",
-            "c-evidence-status", "c-evidence-updated",
-        ):
-            self.assertNotIn(removed, tools_head)
-        self.assertNotIn("c-evidence-status", self.page)
-        self.assertNotIn("c-evidence-updated", self.page)
-        for removed in (
-            "id=c-decision-panel", "id=c-opt-enabled", "id=c-opt-used",
-            "id=c-opt-review", "id=c-mcp-observed",
-            'aria-label="Capability evidence summary"', "id=c-review-filter",
-            "id=c-browse-all",
-        ):
-            self.assertNotIn(removed, tools)
-        self.assertIn('aria-label="Capability type"', self.page)
-        self.assertIn('aria-label="Evidence and configuration"', self.page)
-        self.assertIn('aria-label="Search installed capabilities"', self.page)
-        self.assertIn("button.setAttribute('aria-pressed'", self.page)
-        self.assertIn("function renderCapabilityReviewQueue(cap", self.page)
-        self.assertIn("function unusedReviewGroups(cap)", self.page)
-        self.assertIn("if(!cap)return;", self.page)
-        self.assertIn("fetch('/capabilities/inventory'", self.page)
-        self.assertIn("CAPABILITY_PAGE_SIZE=100", self.page)
-        self.assertIn("id=c-mobile-sort", self.page)
-        self.assertIn("function openCapabilityInventory(type='all')", self.page)
-        self.assertIn("button.onclick=()=>openCapabilityInventory(button.dataset.capJump)", self.page)
-        self.assertIn("function clearCapabilityFilter(key)", self.page)
-        self.assertIn("row.measurement==='instruction'?'Instruction-only':'Evidence unavailable'", self.page)
-        self.assertIn("return row.enabled===true?'Enabled':row.enabled===false?'Disabled':'Unknown'", self.page)
-        self.assertIn("const selectedCapabilityIds=new Set()", self.page)
-        self.assertIn("openSelectedDisableDialog", self.page)
-        self.assertIn("capabilityRuntime='all'", self.page)
-        self.assertIn("lastCapabilityReviewRevision", self.page)
-        self.assertIn("cap.review_revision", self.page)
-        self.assertIn("cap.inventory_revision", self.page)
-        self.assertIn("setCapabilityAvailability('stale'", self.page)
-        self.assertIn("data-label=\"Configuration\"", self.page)
-        self.assertIn("data-label=\"Evidence\"", self.page)
-        self.assertNotIn("Loaded ·", self.page)
-        self.assertNotIn("Disable all unused", self.page)
-        self.assertNotIn("if(row.unmeasurable) return '<span class=subline>not measurable</span>'", self.page)
-
-    def test_fieldtips_are_portaled_and_viewport_bound(self):
-        for marker in (
-            "#fieldtip-popup{position:fixed",
-            "function initFieldTipPopup()",
-            "popup.setAttribute('role','tooltip')",
-            "const maxLeft=Math.max(margin,window.innerWidth-margin-width)",
-            "below+height<=window.innerHeight-margin||above<margin?below:above",
-            "document.addEventListener('pointerover'",
-            "window.addEventListener('scroll',scheduleFieldTipPosition,true)",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("content:attr(data-tip)", self.page)
-
-    def test_skill_pack_changes_confirm_exact_control_and_use_verified_state(self):
-        self.assertIn("id=cap-dialog", self.page)
-        self.assertIn("control_id:controlId", self.page)
-        self.assertIn("result.capabilities||cap", self.page)
-        self.assertIn("Setting verified.", self.page)
-        self.assertIn("row.reviewable!==false", self.page)
-        self.assertNotIn("...group,id:group.item_id", self.page)
-
-    def test_sessions_all_spend_learn_and_settings_are_first_class_routes(self):
-        for marker in (
-            "id=session-scope-tabs", "id=session-scope-current", "id=session-scope-all",
-            "id=tab-subagents", "id=view-subagents", "id=all-session-history",
-            "id=subagent-explorer", "id=tab-daily", "id=view-daily",
-            "id=tab-learn", "id=view-learn", "id=tab-settings", "id=view-settings",
-        ):
-            self.assertIn(marker, self.page)
-        for removed in (
-            "id=tab-global", "id=view-global", "data-global-panel",
-            "id=tab-budgets", "id=view-budgets", "id=tab-logs", "id=view-logs",
-        ):
-            self.assertNotIn(removed, self.page)
-        self.assertIn("const legacyGlobal=h==='global'||h==='global-logs'", self.page)
-        self.assertIn("if(h==='logs'||legacyGlobal)", self.page)
-        self.assertIn("'/#sessions-all'", self.page)
-        self.assertIn("function openSessionScope(scope", self.page)
-        self.assertIn("function setSessionScope(scope)", self.page)
-        self.assertIn('class="tabs sessionScopeTabs"', self.page)
-        self.assertIn('<span class=tabLabel>Current sessions</span>', self.page)
-        self.assertIn('<span class=tabLabel>All sessions</span>', self.page)
-        self.assertIn('<span class=tabLabel>Subagents</span>', self.page)
-        self.assertIn("h==='sessions-subagents'", self.page)
-        self.assertIn("live · updated ${new Date(generatedAt*1000).toLocaleTimeString", self.page)
-        self.assertLess(self.page.index("id=tab-session"), self.page.index("id=tab-daily"))
-        self.assertIn("id=s-range", self.page)
-        self.assertNotIn("id=learn-glossary", self.page)
-        self.assertIn("Compare: change one thing, run again.", self.page)
-        self.assertIn("if(h==='daily')setHashRoute('spend',{replace:true,apply:false})", self.page)
-        self.assertIn("if(h==='spend'||h==='daily'||h==='spend-budgets'||h==='spend-discounts'||h==='settings-budgets'||h==='budgets')", self.page)
-        self.assertIn("if(h==='learn'||h==='learn-agent-access')", self.page)
-        self.assertIn("if(h==='settings-budgets'||h==='budgets')setHashRoute('spend-budgets',{replace:true,apply:false})", self.page)
-        self.assertNotIn("setHashRoute('settings-budgets'", self.page)
-        self.assertIn("activeTop.scrollIntoView({block:'nearest',inline:'center'})", self.page)
-
-    def test_spend_route_and_shell_replace_daily_brief(self):
-        for marker in (
-            "data-label=Spend aria-label=Spend",
-            "<span class=tabLabel>Spend</span>",
-            "<h1>Spend</h1>",
-            "id=s-range", "<option value=today>Today</option>", "<option value=7>7 days</option>",
-            "<option value=month>Month</option>", "<option value=custom>Custom</option>",
-            "id=s-from", "id=s-to", "id=s-total", "id=s-average",
-            "id=s-top-runtime", "id=s-highest-day", "id=s-chart",
-            "id=s-chart-tip", "id=s-legend", "id=s-platforms",
-            "if(h==='daily')setHashRoute('spend',{replace:true,apply:false})",
-            "if(h==='spend'||h==='daily'||h==='spend-budgets'",
-            "openTopLevelRoute('spend')",
-            "{id:'spend',label:'Spend'",
-            "{label:'Open Spend',route:'spend-budgets'}",
-            "function renderSpend(xs)",
-        ):
-            self.assertIn(marker, self.page)
-        for removed in (
-            "<h1>Daily brief</h1>", "id=d-day-select", "id=d-trend-mode",
-            "data-daily-trend=wait", "id=d-sessions", "id=d-providers",
-            "renderDaily(",
-        ):
-            self.assertNotIn(removed, self.page)
-
-    def test_spend_fits_chart_and_restores_range_logs(self):
-        for marker in (
-            "class=spendEvidenceGrid",
-            "Highest-cost logs",
-            "id=s-log-day",
-            "id=s-log-count",
-            "id=s-logs",
-            "function spendAxisLabel(",
-            "function renderSpendLogs(payload,window)",
-            "function loadSpendLogs(window,generatedAt)",
-            "fetch(`/spend/logs?from=${encodeURIComponent(window.start)}&to=${encodeURIComponent(window.end)}`",
-            "data-spend-session=",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn(
-            ".spendChart{min-height:270px;margin-top:12px;overflow:hidden",
-            self.page,
-        )
-
-    def test_spend_evidence_cards_share_one_fixed_height(self):
-        """Removing either card from the shared height contract breaks alignment."""
-        for marker in (
-            ".spendEvidenceGrid{display:grid;grid-template-columns:minmax(0,1.3fr) minmax(300px,.7fr);align-items:stretch",
-            ".spendLogsCard,.spendPlatformCard{height:360px;display:flex;min-height:0;flex-direction:column",
-            "class=spendPlatformBody id=s-platforms",
-            ".spendPlatformBody{min-height:0;flex:1;overflow-y:auto;overflow-x:hidden;scrollbar-gutter:stable",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_spend_platform_split_keeps_amounts_inside_narrow_cards(self):
-        """Restoring the old wide column minimums clips amounts at laptop width."""
-        self.assertIn(
-            ".spendPlatformRow{display:grid;grid-template-columns:minmax(78px,.48fr) minmax(72px,1fr) minmax(82px,auto);align-items:center;gap:10px",
-            self.page,
-        )
-        self.assertIn(".spendPlatformValue{min-width:82px", self.page)
-
-    def test_spend_hover_detail_is_transient_and_bars_stay_mounted(self):
-        for marker in (
-            "class=\"spendChartTip chartTip\"",
-            ":where(.chartTip){position:absolute;pointer-events:none",
-            ".spendDay:hover .spendBarValue{opacity:1}",
-            "function hideSpendTip()",
-            "$('s-chart-inner').addEventListener('pointerleave',hideSpendTip)",
-            "if(!same){",
-            "updateSpendBar(button,rows[index],index,rows.length,axisMax,chartWidth,{peak:index===peakIndex,spansYears})",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn(
-            ".spendDay:hover .spendBarValue,.spendDay:focus-visible .spendBarValue,.spendDay.selected .spendBarValue",
-            self.page,
-        )
-        select_day = self.page.split("function selectSpendDay(day", 1)[1].split(
-            "function renderSpend(xs)", 1,
-        )[0]
-        self.assertNotIn("showSpendTip", select_day)
-        render_spend = self.page.split("function renderSpend(xs)", 1)[1].split(
-            "function validateSpendCustomDraft", 1,
-        )[0]
-        self.assertIn(
-            "const hovered=$('s-chart-inner').querySelector('.spendDay:hover');",
-            render_spend,
-        )
-        self.assertIn(
-            "if(hovered)showSpendTip(hovered.dataset.spendDay,hovered);else hideSpendTip();",
-            render_spend,
-        )
-
-    def test_spend_chart_uses_roving_focus_without_persistent_day_selection(self):
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1
-        )[0]
-        script = logic + """
-const rows = [{day:'2026-08-10'}, {day:'2026-08-11'}, {day:'2026-08-12'}];
-console.log(JSON.stringify({
-  initial: spendDayNavigation(rows, ''),
-  moved: spendDayNavigation(rows, '2026-08-11'),
-  empty: spendDayNavigation([], ''),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "initial": {
-                "focusDay": "2026-08-12",
-                "buttons": [
-                    {"day": "2026-08-10", "tabIndex": -1, "selected": False},
-                    {"day": "2026-08-11", "tabIndex": -1, "selected": False},
-                    {"day": "2026-08-12", "tabIndex": 0, "selected": False},
-                ],
-            },
-            "moved": {
-                "focusDay": "2026-08-11",
-                "buttons": [
-                    {"day": "2026-08-10", "tabIndex": -1, "selected": False},
-                    {"day": "2026-08-11", "tabIndex": 0, "selected": False},
-                    {"day": "2026-08-12", "tabIndex": -1, "selected": False},
-                ],
-            },
-            "empty": {"focusDay": "", "buttons": []},
-        })
-
-    def test_spend_y_axis_and_range_logs_are_bounded(self):
-        for marker in (
-            "id=s-y-axis",
-            "function spendNiceMax(value)",
-            "function renderSpendAxis(axisMax)",
-            ".spendLogsCard,.spendPlatformCard{height:360px",
-            "overflow-y:auto",
-            "scrollbar-gutter:stable",
-            ".spendLogRow{height:68px",
-            ".spendLogValue{grid-column:2/4;grid-row:2",
-            ".spendLogRow .tbtn{grid-column:3;grid-row:1",
-            "$('s-log-count').textContent=`${f(rows.length)} logs`",
-        ):
-            self.assertIn(marker, self.page)
-        render_logs = self.page.split("function renderSpendLogs(payload,window)", 1)[1].split(
-            "function loadSpendLogs", 1,
-        )[0]
-        self.assertNotIn(".slice(", render_logs)
-
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1,
-        )[0]
-        result = subprocess.run(
-            [
-                "node", "-e",
-                logic + "\nconsole.log(JSON.stringify([0,.7,18,189,200.00222974000008,458.253518,1000].map(spendNiceMax)));",
-            ],
-            capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), [1, 1, 20, 200, 240, 500, 1200])
-        self.assertIn("flex:1 1 0;min-width:0", self.page)
-        self.assertIn(
-            ".spendDayLabel{position:absolute;bottom:0;left:50%;width:max-content",
-            self.page,
-        )
-        self.assertIn(
-            ".spendDay[data-axis-edge=last] .spendDayLabel{right:0;left:auto;transform:none}",
-            self.page,
-        )
-        self.assertNotIn("inner.style.width=`max(100%", self.page)
-        self.assertNotIn(
-            ".spendChart{min-height:270px;margin-top:12px;overflow-x:auto",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_spend_last_month_is_previous_full_calendar_month(self):
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1,
-        )[0]
-        script = logic + """
-console.log(JSON.stringify([
-  spendRangeWindow('last_month','','',new Date(2026,2,15,9,0,0)),
-  spendRangeWindow('last_month','','',new Date(2026,0,1,0,5,0)),
-  normalizeSpendRangeChoice('last_month'),
-]));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), [
-            {"valid": True, "start": "2026-02-01", "end": "2026-02-28", "dayCount": 28, "error": ""},
-            {"valid": True, "start": "2025-12-01", "end": "2025-12-31", "dayCount": 31, "error": ""},
-            "last_month",
-        ])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_spend_trend_groups_by_monday_week_and_calendar_month(self):
-        """Clipped edge buckets and the bucket holding today must not count as full periods."""
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1,
-        )[0]
-        script = logic + """
-const now = new Date(2026, 9, 16, 12, 0, 0);
-const window = spendRangeWindow('custom', '2026-09-24', '2026-10-16', now);
-const rows = spendCalendarRows([
-  {day:'2026-09-24', cost:2, providers:[{provider:'claude', cost:2}]},
-  {day:'2026-09-30', cost:3, providers:[{provider:'codex', cost:3}], usage_basis:'local_estimate'},
-  {day:'2026-10-05', cost:5, providers:[{provider:'claude', cost:5}], coverage:{cost:{complete:false}}},
-  {day:'2026-10-16', cost:1, providers:[{provider:'claude', cost:1}]},
-], window);
-const pick = bucket => ({day:bucket.day, start:bucket.bucketStart, end:bucket.end, days:bucket.days, fullDays:bucket.fullDays, cost:bucket.cost, clipped:bucket.clipped, inProgress:bucket.inProgress, estimated:spendIsEstimated(bucket), complete:bucket.coverage.cost.complete});
-const weeks = spendBucketRows(rows, 'week', '2026-10-16');
-const days = spendBucketRows(rows, 'day', '2026-10-16');
-console.log(JSON.stringify({
-  weeks: weeks.map(pick),
-  months: spendBucketRows(rows, 'month', '2026-10-16').map(pick),
-  dayCount: days.length,
-  todayIncomplete: days.filter(row => row.incomplete).map(row => row.day),
-  weekAverageBasis: spendAverageBasis(weeks).map(row => row.day),
-  dayAverageBasis: spendAverageBasis(days).length,
-  sevenDays: spendGranularityOptions(spendCalendarRows([], spendRangeWindow('7', '', '', now))),
-  thirtyDays: spendGranularityOptions(spendCalendarRows([], spendRangeWindow('30', '', '', now))),
-  ninetyDays: spendGranularityOptions(spendCalendarRows([], spendRangeWindow('90', '', '', now))),
-  normalized: ['day', 'week', 'month', 'year', null].map(normalizeSpendGranularity),
-  auto: [1, 7, 30, 35, 36, 90, 186, 187, 400].map(spendAutoGranularity),
-  resolved: [
-    spendResolveGranularity('auto', spendCalendarRows([], spendRangeWindow('90', '', '', now))).granularity,
-    spendResolveGranularity('day', spendCalendarRows([], spendRangeWindow('90', '', '', now))).granularity,
-    spendResolveGranularity('month', spendCalendarRows([], spendRangeWindow('30', '', '', now))).granularity,
-    spendResolveGranularity('week', spendCalendarRows([], spendRangeWindow('7', '', '', now))).granularity,
-    spendResolveGranularity('auto', spendCalendarRows([], spendRangeWindow('30', '', '', now))).granularity,
-  ],
-}));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["weeks"], [
-            {"day": "2026-09-24", "start": "2026-09-21", "end": "2026-09-27", "days": 4, "fullDays": 7, "cost": 2, "clipped": True, "inProgress": False, "estimated": False, "complete": True},
-            {"day": "2026-09-28", "start": "2026-09-28", "end": "2026-10-04", "days": 7, "fullDays": 7, "cost": 3, "clipped": False, "inProgress": False, "estimated": True, "complete": True},
-            {"day": "2026-10-05", "start": "2026-10-05", "end": "2026-10-11", "days": 7, "fullDays": 7, "cost": 5, "clipped": False, "inProgress": False, "estimated": False, "complete": False},
-            {"day": "2026-10-12", "start": "2026-10-12", "end": "2026-10-16", "days": 5, "fullDays": 7, "cost": 1, "clipped": True, "inProgress": True, "estimated": False, "complete": True},
-        ])
-        self.assertEqual(payload["months"], [
-            {"day": "2026-09-24", "start": "2026-09-01", "end": "2026-09-30", "days": 7, "fullDays": 30, "cost": 5, "clipped": True, "inProgress": False, "estimated": True, "complete": True},
-            {"day": "2026-10-01", "start": "2026-10-01", "end": "2026-10-16", "days": 16, "fullDays": 31, "cost": 6, "clipped": True, "inProgress": True, "estimated": False, "complete": False},
-        ])
-        self.assertEqual(payload["dayCount"], 23)
-        self.assertEqual(payload["todayIncomplete"], ["2026-10-16"])
-        self.assertEqual(payload["weekAverageBasis"], ["2026-09-28", "2026-10-05"])
-        self.assertEqual(payload["dayAverageBasis"], 23)
-        self.assertEqual(payload["sevenDays"], {"day": True, "week": False, "month": False})
-        self.assertEqual(payload["thirtyDays"], {"day": True, "week": True, "month": False})
-        self.assertEqual(payload["ninetyDays"], {"day": True, "week": True, "month": True})
-        self.assertEqual(payload["normalized"], ["day", "week", "month", "day", "day"])
-        self.assertEqual(payload["auto"], ["day", "day", "day", "day", "week", "week", "week", "month", "month"])
-        self.assertEqual(payload["resolved"], ["week", "day", "week", "day", "day"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_spend_trend_options_ticks_and_in_progress_week(self):
-        """A week still in progress is no basis for an average, so it cannot make Week selectable."""
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1,
-        )[0]
-        script = logic + """
-const now = new Date(2026, 9, 11, 12, 0, 0);
-const rows = spendCalendarRows([], spendRangeWindow('custom', '2026-09-30', '2026-10-11', now));
-const yearRows = spendCalendarRows([], spendRangeWindow('custom', '2025-12-29', '2026-01-11', new Date(2026, 0, 11, 12)));
-console.log(JSON.stringify({
-  withToday: spendGranularityOptions(rows, '2026-10-11'),
-  withoutToday: spendGranularityOptions(rows),
-  fellBack: spendResolveGranularity('week', rows, '2026-10-11').granularity,
-  year: spendBucketRows(yearRows, 'month').map(row => [row.bucketStart, row.days, row.fullDays]),
-  yearWeeks: spendBucketRows(yearRows, 'week').map(row => row.bucketStart),
-  ticks: [3.95, 5, 40, 95, 3000].map(spendNiceMax),
-}));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["withToday"], {"day": True, "week": False, "month": False})
-        self.assertEqual(payload["withoutToday"], {"day": True, "week": True, "month": False})
-        self.assertEqual(payload["fellBack"], "day")
-        self.assertEqual(payload["year"], [["2025-12-01", 3, 31], ["2026-01-01", 11, 31]])
-        self.assertEqual(payload["yearWeeks"], ["2025-12-29", "2026-01-05"])
-        self.assertEqual(payload["ticks"], [6, 6, 50, 100, 3200])
-
-    def test_spend_trend_override_resets_whenever_the_range_changes(self):
-        """A manual Day on 30 days must not follow the user onto All history."""
-        for handler in (
-            "spendCustomFrom=from;spendCustomTo=to;spendRangeChoice='custom';spendGranularityChoice='auto';",
-            "spendRangeChoice=range;spendGranularityChoice='auto';persistSpendRange()",
-            "if(savedCustomInvalid){spendRangeChoice='30';spendGranularityChoice='auto';",
-            "spendRangeChoice='month';spendGranularityChoice='auto';persistSpendRange()",
-        ):
-            self.assertIn(handler, self.page)
-        self.assertIn("aria-disabled", self.page.split("function renderSpend(xs)", 1)[1])
-        self.assertNotIn("button.disabled=!granularityOptions", self.page)
-
-    def test_spend_trend_granularity_control_drives_chart(self):
-        for marker in (
-            '<div class=seg id=s-granularity role=group aria-label="Group spend by">',
-            "data-spend-granularity=day>Day</button>",
-            "data-spend-granularity=week>Week</button>",
-            "data-spend-granularity=month>Month</button>",
-            "let spendGranularityChoice='auto',spendChartRows=[];",
-            "spendChartRows=spendBucketRows(rows,granularity,today);",
-            "reconcileSpendBars(spendChartRows);",
-            "<div class=spendGrid aria-hidden=true></div>",
-            "button.setAttribute('aria-disabled',String(!granularityOptions[value]));",
-        ):
-            self.assertIn(marker, self.page)
-        render_spend = self.page.split("function renderSpend(xs)", 1)[1].split(
-            "function validateSpendCustomDraft", 1,
-        )[0]
-        self.assertIn("spendResolveGranularity(spendGranularityChoice,rows,today)", render_spend)
-        self.assertNotIn("SPEND_GRANULARITY_KEY", self.page)
-        self.assertIn(".spendChartInner[data-granularity] .spendStackSegment{opacity:.82", self.page)
-        self.assertIn(".spendChartInner[data-granularity] .spendStackSegment+.spendStackSegment{border-bottom:1px solid", self.page)
-        self.assertIn("<span class=spendDayStack style=\"--spend-height:${height}%\">${segments}</span>", self.page)
-        self.assertNotIn("spendTotalKey", self.page)
-        grid_rule = self.page.split("\n.spendGrid{", 1)[1].split("}", 1)[0]
-        self.assertIn("height:calc(var(--spend-chart-h) - var(--spend-day-head) - var(--spend-day-foot) - 2*var(--spend-day-gap))", grid_rule)
-        self.assertNotIn("inset:", grid_rule)
-        self.assertIn("--spend-chart-h:260px", self.page)
-        self.assertEqual(self.page.count("height:var(--spend-chart-h)"), 2)
-        self.assertIn("(index%step===0&&count-1-index>=step)", self.page)
-        self.assertIn("[data-peak=true][data-peak-edge=first] .spendBarValue{align-self:flex-start}", self.page)
-        show_tip = self.page.split("function showSpendTip(", 1)[1].split("function selectSpendDay", 1)[0]
-        self.assertIn("details.runtimes.filter(runtime=>runtime.cost>0||runtime.unavailable)", show_tip)
-        self.assertIn("Math.min(cardRect.height-tip.offsetHeight-8", show_tip)
-        day_rule = self.page.split("\n.spendDay{", 1)[1].split("}", 1)[0]
-        self.assertIn("grid-template-columns:minmax(0,1fr)", day_rule)
-        self.assertIn(".spendChartInner[data-dense=true]{--spend-bar-share:52%}", self.page)
-        self.assertIn("inner.dataset.dense=String(rows.length>45);", self.page)
-        stack_rule = self.page.split(".spendDayStack{", 1)[1].split("}", 1)[0]
-        self.assertNotIn("border-radius", stack_rule)
-        self.assertIn("width:min(var(--spend-bar-max,24px),var(--spend-bar-share,64%))", stack_rule)
-        self.assertNotIn("transparent 0 44px", self.page.split("\n.spendDayTrack{", 1)[1].split("}", 1)[0])
-
-    def test_spend_average_reference_uses_every_calendar_day(self):
-        """Dropping zero-spend days makes the chart line disagree with the KPI."""
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1,
-        )[0]
-        script = logic + """
-const rows = [
-  {day:'2026-08-01', cost:1},
-  {day:'2026-08-02', cost:2},
-  {day:'2026-08-03', cost:0},
-  {day:'2026-08-04', cost:1},
-];
-console.log(JSON.stringify({
-  reference: spendAverageReference(rows, 4),
-  empty: spendAverageReference([], 4),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), {
-            "reference": {"value": 1, "ratio": 0.25},
-            "empty": {"value": 0, "ratio": 0},
-        })
-
-    def test_spend_uses_exact_calendar_ranges_and_stacked_runtime_bars(self):
-        for marker in (
-            "// spend-range-logic-start",
-            "const SPEND_RUNTIME_COLORS={claude:'var(--provider-claude)',codex:'var(--provider-codex)',cursor:'var(--provider-cursor)',opencode:'var(--provider-opencode)',kiro:'var(--provider-kiro)',unknown:'var(--provider-other)'};",
-            "function spendRangeWindow(range,from='',to='',now=new Date(),earliest='')",
-            "<select class=filterSelect id=s-range aria-label=\"Spend history range\"><option value=today>Today</option><option value=yesterday>Yesterday</option><option value=7>7 days</option><option value=30 selected>30 days</option><option value=90>90 days</option><option value=month>Month</option><option value=last_month>Last month</option><option value=all>All history</option><option value=custom>Custom</option></select>",
-            "$('s-range').value=spendRangeChoice;",
-            "$('s-range').onchange=event=>{",
-            "function normalizeSpendRangeChoice(value)",
-            "function spendCalendarRows(days,window)",
-            "function spendRuntimeKey(provider)",
-            "function spendRuntimeTotals(rows)",
-            "class=spendStackSegment",
-            "data-spend-day=",
-            "function spendDayNavigation(rows,focusDay='')",
-            "function showSpendTip(",
-            "addEventListener('pointerover',handleSpendInspect)",
-            "xs?.spend?.days||xs?.daily||[]",
-        ):
-            self.assertIn(marker, self.page)
-
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1
-        )[0]
-        script = logic + """
-const now = new Date(2026, 7, 12, 12, 0, 0);
-const today = spendRangeWindow('today', '', '', now);
-const seven = spendRangeWindow('7', '', '', now);
-const thirty = spendRangeWindow('30', '', '', now);
-const month = spendRangeWindow('month', '', '', now);
-const monthFirst = spendRangeWindow('month', '', '', new Date(2026, 8, 1, 12, 0, 0));
-const january = spendRangeWindow('month', '', '', new Date(2027, 0, 9, 12, 0, 0));
-const custom = spendRangeWindow('custom', '2026-08-01', '2026-08-03', now);
-const yesterday = spendRangeWindow('yesterday', '', '', now);
-const ninety = spendRangeWindow('90', '', '', now);
-const allHistory = spendRangeWindow('all', '', '', now, '2026-05-01');
-const allEmpty = spendRangeWindow('all', '', '', now, '');
-const invalid = spendRangeWindow('custom', '2026-08-04', '2026-08-03', now);
-const rows = spendCalendarRows([
-  {day:'2026-08-03',cost:3,providers:[{provider:'claude',cost:3}]},
-  {day:'2026-08-01',cost:2,providers:[{provider:'codex',cost:2}]},
-], custom);
-console.log(JSON.stringify({
-  today, seven, thirty, month, monthFirst, january, custom, invalid, yesterday, ninety, allHistory, allEmpty,
-  savedRanges: ['today','yesterday','7','30','90','month','last_month','all','custom','unexpected'].map(normalizeSpendRangeChoice),
-  rowDays: rows.map(row=>row.day),
-  rowCosts: rows.map(row=>row.cost),
-  keys: ['Claude Code','codex','Cursor IDE','OpenCode','Kiro CLI','other'].map(spendRuntimeKey),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["today"]["start"], "2026-08-12")
-        self.assertEqual(payload["today"]["end"], "2026-08-12")
-        self.assertEqual(payload["seven"]["start"], "2026-08-06")
-        self.assertEqual(payload["seven"]["end"], "2026-08-12")
-        self.assertEqual(payload["seven"]["dayCount"], 7)
-        self.assertEqual(payload["thirty"]["start"], "2026-07-14")
-        self.assertEqual(payload["thirty"]["dayCount"], 30)
-        self.assertEqual(payload["month"], {
-            "valid": True, "start": "2026-08-01", "end": "2026-08-12",
-            "dayCount": 12, "error": "",
-        })
-        self.assertEqual(payload["monthFirst"], {
-            "valid": True, "start": "2026-09-01", "end": "2026-09-01",
-            "dayCount": 1, "error": "",
-        })
-        self.assertEqual(payload["january"], {
-            "valid": True, "start": "2027-01-01", "end": "2027-01-09",
-            "dayCount": 9, "error": "",
-        })
-        self.assertEqual(
-            payload["savedRanges"],
-            ["today", "yesterday", "7", "30", "90", "month", "last_month", "all", "custom", "30"],
-        )
-        self.assertEqual(payload["yesterday"], {
-            "valid": True, "start": "2026-08-11", "end": "2026-08-11",
-            "dayCount": 1, "error": "",
-        })
-        self.assertEqual(payload["ninety"]["start"], "2026-05-15")
-        self.assertEqual(payload["ninety"]["dayCount"], 90)
-        self.assertEqual(payload["allHistory"], {
-            "valid": True, "start": "2026-05-01", "end": "2026-08-12",
-            "dayCount": 104, "error": "",
-        })
-        self.assertEqual(payload["allEmpty"]["start"], "2026-08-12")
-        self.assertEqual(payload["allEmpty"]["dayCount"], 1)
-        self.assertEqual(payload["custom"]["dayCount"], 3)
-        self.assertFalse(payload["invalid"]["valid"])
-        self.assertEqual(payload["rowDays"], [
-            "2026-08-01", "2026-08-02", "2026-08-03",
-        ])
-        self.assertEqual(payload["rowCosts"], [2, 0, 3])
-        self.assertEqual(payload["keys"], [
-            "claude", "codex", "cursor", "opencode", "kiro", "unknown",
-        ])
-
-    def test_spend_session_analytics_excludes_unavailable_evidence(self):
-        logic = self.page.split("// spend-range-logic-start", 1)[1].split(
-            "// spend-range-logic-end", 1
-        )[0]
-        script = logic + """
-const rows = [
-  {id:'a', cost:40, input_tokens:1000, turns:1, duration_s:10,
-   duration_available:true, availability:{cost:true,input_tokens:true}},
-  {id:'b', cost:30, input_tokens:2000, turns:2, duration_s:20,
-   duration_available:true, availability:{cost:true,input_tokens:true}},
-  {id:'c', cost:20, input_tokens:3000, turns:3, duration_s:30,
-   duration_available:true, availability:{cost:true,input_tokens:true}},
-  {id:'d', cost:10, input_tokens:4000, turns:4, duration_s:999,
-   duration_available:false, availability:{cost:true,input_tokens:true}},
-  {id:'e', cost:99, input_tokens:5000, turns:5, duration_s:50,
-   duration_available:true, availability:{cost:false,input_tokens:true}},
-];
-const analytics = spendSessionAnalytics(rows);
-console.log(JSON.stringify({
-  concentration: analytics.concentration,
-  cost: analytics.distributions.cost,
-  input: analytics.distributions.input,
-  executions: analytics.distributions.executions,
-  active: analytics.distributions.active,
-  spendPoints: spendScatterRows(rows, 'cost').map(row => row.id),
-  inputPoints: spendScatterRows(rows, 'input').map(row => row.id),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        payload = json.loads(result.stdout)
-        self.assertEqual(payload["concentration"], {
-            "covered": 4, "total": 100, "top_count": 1,
-            "top_cost": 40, "top_share": 0.4,
-        })
-        self.assertEqual(payload["cost"], {
-            "count": 4, "p10": 13, "p25": 17.5, "median": 25,
-            "mean": 25, "p75": 32.5, "p90": 37,
-        })
-        self.assertEqual(payload["input"], {
-            "count": 5, "p10": 1400, "p25": 2000, "median": 3000,
-            "mean": 3000, "p75": 4000, "p90": 4600,
-        })
-        self.assertEqual(payload["executions"], {
-            "count": 5, "p10": 1.4, "p25": 2, "median": 3,
-            "mean": 3, "p75": 4, "p90": 4.6,
-        })
-        self.assertEqual(payload["active"], {
-            "count": 4, "p10": 13, "p25": 17.5, "median": 25,
-            "mean": 27.5, "p75": 35, "p90": 44,
-        })
-        self.assertEqual(payload["spendPoints"], ["a", "b", "c"])
-        self.assertEqual(payload["inputPoints"], ["a", "b", "c", "e"])
-
-    def test_spend_route_exposes_concentration_shape_and_openable_outliers(self):
-        spend = self.page.split("id=view-daily", 1)[1].split("id=view-learn", 1)[0]
-        for marker in (
-            "id=s-concentration", "id=s-concentration-bar", "id=s-shape",
-            "id=s-scatter", "id=s-scatter-svg", "data-scatter-metric=cost",
-            "data-scatter-metric=input", "data-spend-insight-session=",
-        ):
-            self.assertIn(marker, spend if marker.startswith("id=s-") or marker.startswith("data-scatter") else self.page)
-        self.assertIn("function renderSpendSessionInsights(payload,window)", self.page)
-        self.assertIn("selectSession(button.dataset.spendInsightSession)", self.page)
-
-    def test_non_current_views_keep_visible_copy_terse(self):
-        expected_subtitles = {
-            "models": [],
-            "capabilities": ["Tools, MCP servers, and skills."],
-            "settings": ["Connections, pricing, and updates."],
-        }
-        boundaries = (
-            ("models", "daily"),
-            ("capabilities", "settings"),
-            ("settings", None),
-        )
-        for view, next_view in boundaries:
-            section = self.page.split(f"id=view-{view}", 1)[1]
-            section = section.split(
-                f"id=view-{next_view}" if next_view else "<dialog class=welcome",
-                1,
-            )[0]
-            paragraphs = [
-                re.sub(r"<[^>]+>", "", value).strip()
-                for value in re.findall(r"<p(?:\s[^>]*)?>(.*?)</p>", section, re.S)
-            ]
-            self.assertEqual(
-                [value for value in paragraphs if value],
-                expected_subtitles[view],
-                f"{view} should carry only its concise page subtitle",
-            )
-            self.assertNotIn("class=foot", section)
-
-        spend = self.page.split("id=view-daily", 1)[1].split("id=view-learn", 1)[0]
-        self.assertNotIn("Estimated agent spend over time.", spend)
-        total_note = self.page.split("$('s-total-note').textContent=", 1)[1].split(";\n", 1)[0]
-        self.assertIn("'API-equivalent estimate'", total_note)
-        self.assertIn("Estimate after discounts", total_note)
-        self.assertIn("<p id=s-chart-note>Line = average</p>", spend)
-        self.assertNotIn("class=foot", spend)
-
-        for marker in (
-            'aria-description="Observed model output divided by attributable timing.',
-            'aria-description="Set a budget for each runtime',
-            'aria-description="Give Codex and Claude read-only, on-demand access',
-            "#fieldtip-popup{position:fixed",
-            "No use observed",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_models_and_git_keep_secondary_copy_in_accessible_help(self):
-        models = self.page.split("id=view-models", 1)[1].split("id=view-daily", 1)[0]
-        for marker in (
-            "id=m-change-label", "id=m-wait-label",
-            "function setModelKpiHelp(labelId,detail)",
-            "setModelKpiHelp('m-speed-label',speedDetail)",
-            "setModelKpiHelp('m-wait-label',waitDetail)",
-            ".modelCellTip.fieldtip{display:table-cell}",
-            "class=\"fieldtip modelCellTip modelNameCell\" tabindex=0 data-tip=\"${esc(tip)}\" aria-description=\"${esc(tip)}\"",
-        ):
-            self.assertIn(marker, self.page)
-
-        git = self.page.split("id=view-git", 1)[1].split("id=view-learn", 1)[0]
-        hover_copy = (
-            "Period-specific spend and Git coverage; unavailable is not zero.",
-            "Added + deleted text lines per day. Select a day for spend.",
-            "Conversion, typical days, and outliers. Statistics only · no quality judgment.",
-            "Local Git only: hashed keys and line counts, never filenames or messages. Spend is estimated. Few lines make ratios noisy. Not a quality score.",
-            "Ranked local Git and covered-spend observations.",
-            "Median, range, and high day · ratios require 50+ pushed lines.",
-        )
-        for copy in hover_copy:
-            self.assertIn(f'aria-description="{copy}"', git)
-            self.assertIn(f'data-tip="{copy}"', git)
-            self.assertNotIn(f"<p>{copy}</p>", git)
-        # The local-only, privacy, estimate, and noise caveats live once in header help.
-        self.assertNotIn("class=deliveryFoot", git)
-        self.assertIn('class="fieldtip" id=d-evidence-ratio tabindex=0', git)
-        self.assertIn("function setDeliveryEvidenceRatio(text,detail)", self.page)
-        self.assertIn(
-            "setDeliveryEvidenceRatio(selected?`${comparable} / ${selected} comparable`",
-            self.page,
-        )
-        self.assertIn("ratio.dataset.tip=detail", self.page)
-
-    def test_spend_monthly_budget_derives_total_from_runtime_budgets(self):
-        for marker in (
-            "id=spend-budgets", "class=spendBudgetSection", "class=spendBudgetEditor",
-            "id=budget-spend", "id=budget-total", "id=budget-remaining",
-            "id=budget-projected", "id=budget-runtimes",
-            "id=budget-progress-markers", "id=budget-allocation-note",
-            "id=budget-plan-jump",
-            "class=budgetDashboard", "class=budgetLeadHeadActions",
-            "class=\"card budgetLead\"",
-            "class=\"card pad budgetRuntimeCard budgetConfig\"",
-            "class=budgetLeadBody",
-            "class=budgetLeadTop", "class=budgetFigureLine",
-            "id=budget-spend-qualifier hidden>At least</span>",
-            "class=budgetStats", "class=budgetMeterFoot", "id=budget-month",
-            "$('budget-spend-qualifier').hidden=!status.lower_bound",
-            "$('budget-spend').textContent=wholeMoney(status.spend||0)",
-            "const wholeMoney=n=>",
-            "function budgetMonthLabel(month)",
-            "class=budgetRuntimeValue",
-            "class=budgetRuntimeTrack",
-            "class=budgetFormGroup", "class=budgetAlertInline",
-            "class=\"budgetForm budgetInlineForm\"",
-            "class=budgetRuntimeHead", "class=budgetRuntimeInput",
-            "id=budget-input-claude", "id=budget-input-codex",
-            "id=budget-input-cursor", "id=budget-input-opencode",
-            "id=budget-input-threshold-early",
-            "id=budget-runtime-spend-claude",
-            "id=budget-runtime-spend-codex",
-            "id=budget-runtime-spend-cursor",
-            "id=budget-runtime-spend-opencode",
-            "id=budget-runtime-track-claude",
-            "id=budget-runtime-track-opencode",
-            "/settings/budgets", "tm_monthly_budget_alerts",
-            "Partial cost coverage: recorded spend is a lower bound.",
-            "The sum of the registered runtime budgets.",
-            "Runtime budgets are added to calculate the monthly total.",
-            "function ensureBudgetRuntimeRows()",
-            "planJump.textContent=open?'Close editor':budgetConfigured?'Edit budgets':'Set budgets'",
-            "planJump.setAttribute('aria-expanded',String(open))",
-            "aria-expanded=false aria-controls=budget-config>Set budgets</button>",
-            "$('budget-plan-jump').onclick=()=>setBudgetEditorOpen($('budget-config').hidden,true)",
-            "config.scrollIntoView({behavior:",
-            "const input=config.querySelector('.budgetRuntimeInput input')",
-            "input.focus({preventScroll:true})",
-            ".budgetConfig[hidden]{display:none}",
-            ".spendBudgetSection .budgetRuntimeFields{grid-column:2;grid-row:2}",
-            "function budgetAllocationsFromInputs()",
-            "function previewCalculatedBudget()",
-            "const payload={currency:'USD',default_session_budget:",
-            "per session by default · ${money(total)} per month.",
-            "Save budgets",
-            "Set budgets</h2>",
-            "Spent this month</span><span>Budget (USD)",
-            "DEFAULT_RUNTIME_BUDGET=0",
-            "value=0",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("class=budgetHero", self.page)
-        self.assertNotIn("class=budgetGrid", self.page)
-        self.assertNotIn("budgetConfigInitialized", self.page)
-        self.assertNotIn("<details class=\"card budgetConfig\"", self.page)
-        self.assertNotIn("<h2>Budget plan</h2>", self.page)
-        self.assertNotIn("<span class=budgetRuntimeName>Unallocated</span>", self.page)
-        self.assertNotIn("$('budget-runtimes').innerHTML", self.page)
-        self.assertNotIn("id=tab-budgets", self.page)
-        self.assertNotIn("id=view-budgets", self.page)
-        self.assertNotIn("no runtime allocation", self.page)
-        self.assertNotIn("id=budget-input-total", self.page)
-        self.assertNotIn("Monthly total (USD)", self.page)
-        self.assertNotIn("Runtime allocations cannot exceed", self.page)
-        self.assertNotIn("budget-runtime-meta-", self.page)
-        self.assertNotIn("const meta=allocated?", self.page)
-        self.assertEqual(self.page.count(" id=budget-config hidden>"), 1)
-        for removed in ("class=budgetSpendSummary", "class=budgetSpendLimit", "class=budgetReadouts>"):
-            self.assertNotIn(removed, self.page)
-        for removed in (
-            "id=budget-bars", "id=budget-history-note", ">Monthly spend</h2>",
-            "class=budgetDetailGrid", "budgetHistory", "budgetChartInner",
-            "data-settings-target=budget-settings",
-        ):
-            self.assertNotIn(removed, self.page)
-        self.assertNotRegex(self.page, r"id=budget-settings[\s>]")
-        spend = self.page.split("id=view-daily", 1)[1].split("id=view-efficiency", 1)[0]
-        self.assertLess(spend.index("<h1>Spend</h1>"), spend.index("id=spend-budgets"))
-        self.assertLess(spend.index("id=spend-budgets"), spend.index("class=spendKpis"))
-        self.assertLess(spend.index("class=\"card budgetLead\""), spend.index("id=budget-config"))
-        settings = self.page.split("id=view-settings", 1)[1]
-        self.assertNotIn("id=budget-form", settings)
-
-    def test_software_updates_keep_checks_and_install_preferences_independent(self):
-        for marker in (
-            "data-settings-target=update-settings",
-            "settings-updates",
-            "id=update-settings",
-            "id=update-enabled",
-            "id=update-enabled type=checkbox checked",
-            "id=update-auto-install type=checkbox checked",
-            "Check for updates every 10 minutes",
-            "Automatically install available updates",
-            "Enabled by default",
-            "checks once at startup, then every 10 minutes while it is running",
-            "id=update-check",
-            "id=update-notice",
-            "New update available",
-            "/settings/updates",
-            "/updates/status",
-            "/updates/check",
-            "/updates/install",
-            "setInterval(refreshSoftwareUpdateStatus,60000)",
-            "status.available&&status.can_update",
-            "softwareUpdateTarget=SOFTWARE_UPDATE.latest_revision",
-            "softwareUpdateTarget&&state==='attention'",
-            "setTimeout(()=>location.reload(),350)",
-            "Checks fetch revision metadata only",
-            "const autoInstall=enabled&&$('update-auto-install').checked",
-            "{enabled,auto_install:autoInstall}",
-            "$('update-auto-install').disabled=!enabled",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn(".updateNotice{position:fixed;right:18px;bottom:18px", self.page)
-        self.assertIn(".softwareUpdates{display:grid;gap:8px;padding:12px 16px!important}", self.page)
-        self.assertIn(
-            ".softwareUpdateActions{display:grid;grid-template-columns:auto minmax(0,1fr) auto",
-            self.page,
-        )
-        self.assertIn(
-            "<span class=softwareUpdateMeta id=update-settings-meta></span>",
-            self.page,
-        )
-        self.assertIn(".softwareUpdateActions .tbtn:disabled{opacity:.45;cursor:not-allowed}", self.page)
-        self.assertIn("body.classList.toggle('updateReady',showNotice)", self.page)
-        self.assertNotIn("setInterval(()=>postSoftwareUpdate('/updates/install'", self.page)
-        self.assertIn("'settings-updates':'update-settings'", self.page)
-        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
-            "</div>\n</div>\n<dialog class=commandPalette", 1
-        )[0]
-        self.assertLess(
-            settings.index("data-settings-target=model-pricing-settings"),
-            settings.index("data-settings-target=update-settings"),
-        )
-        self.assertLess(
-            settings.index("id=model-pricing-settings"),
-            settings.index("id=update-settings"),
-        )
-
-    def test_settings_sections_use_matching_titles_and_compact_supporting_copy(self):
-        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
-            "</div>\n</div>\n<dialog class=commandPalette", 1
-        )[0]
-        for title, target in (
-            ("Agent connection", "agent-access"),
-            ("Model pricing", "model-pricing-settings"),
-            ("Software updates", "update-settings"),
-        ):
-            self.assertIn(
-                f"data-settings-target={target}><b>{title}</b>", settings,
-            )
-            self.assertIn(f">{title}</h2>", settings)
-        self.assertNotIn(">Monthly budget</", settings)
-        for removed in (
-            "id=agent-access-badge", "class=mcpMark", "class=agentPromise",
-            "class=agentTools", "class=agentPrivacy", "id=frustration-term-count",
-            "<div class=softwareUpdatePromise",
-        ):
-            self.assertNotIn(removed, settings)
-        self.assertNotIn('href="#learn-agent-access"', settings)
-        self.assertIn("frame:{kind:'agent',anchor:'agent-access'", self.page)
-        self.assertIn("Connections stay local and read-only.", settings)
-        self.assertNotIn("Language signals", settings)
-        self.assertIn(
-            ".settingsMap:before,.agentAccess:before,.budgetLead:before{display:none}",
-            self.page,
-        )
-
-    def test_current_surfaces_runtime_budget_overruns(self):
-        for marker in (
-            "id=current-budget-warning",
-            "id=current-budget-warning-msg",
-            "id=current-budget-settings",
-            "Open monthly budget",
-            "$('current-budget-settings').onclick=()=>setHashRoute('spend-budgets')",
-            "function renderCurrentBudgetWarning(status)",
-            "status?.exceeded_runtimes||[]",
-            "renderCurrentBudgetWarning(s.xsession?.budget||LATEST?.xsession?.budget)",
-            "runtimeAttention?`${runtimeExceeded.map(row=>row.label).join(', ')} over budget`",
-            "row.exceeded===true",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_primary_navigation_and_command_palette_share_the_same_workflow_order(self):
-        tab_ids = [
-            "tab-session", "tab-daily", "tab-models", "tab-subagents",
-            "tab-efficiency", "tab-work", "tab-git", "tab-performance", "tab-learn",
-            "tab-capabilities", "tab-settings",
-        ]
-        positions = [self.page.index(f"id={tab_id}") for tab_id in tab_ids]
-        self.assertEqual(positions, sorted(positions))
-        for marker in (
-            "id=command-palette", "id=command-search",
-            "const NAV_COMMANDS=[",
-            "key==='k'", "event.key==='Escape'", "event.key==='ArrowDown'",
-            "event.key==='Enter'",
-            "class=tabs aria-label=\"Primary navigation\"",
-            "button.setAttribute('aria-current','page')",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("if(command.latest)goToLatestSession()", self.page)
-        self.assertIn("action:'selected-session'", self.page)
-        self.assertIn("function openSelectedSessionRoute(route='summary')", self.page)
-        self.assertIn("history.pushState({sessionScope:sessionReturnScope},'',sessionRoute(pinned))", self.page)
-        self.assertIn("if(command.action==='selected-session'){openSelectedSessionRoute(command.route);return;}", self.page)
-        self.assertIn("else openTopLevelRoute(command.route)", self.page)
-        self.assertNotIn("shortcut:'⌥", self.page)
-        self.assertNotIn("id=command-trigger", self.page)
-        self.assertNotIn("Local evidence", self.page)
-        self.assertNotIn("class=pulse", self.page)
-        self.assertNotIn("@keyframes p{", self.page)
-        self.assertNotIn("id=live", self.page)
-        self.assertNotIn("id=livetxt", self.page)
-        self.assertNotIn("$('live')", self.page)
-        self.assertNotIn("$('livetxt')", self.page)
-        self.assertNotIn("id=command-alt-key", self.page)
-        self.assertNotIn("class=commandShortcut", self.page)
-
-    def test_top_level_pages_have_no_numbered_shortcuts(self):
-        for tab_id in (
-            "session", "daily", "models", "subagents", "efficiency",
-            "work", "git", "learn", "capabilities", "settings",
-        ):
-            match = re.search(rf'<button[^>]+id=tab-{tab_id}[^>]*>.*?</button>', self.page)
-            self.assertIsNotNone(match, tab_id)
-            button = match.group(0)
-            self.assertNotIn("aria-keyshortcuts", button)
-            self.assertNotIn("Shortcut", button)
-            self.assertNotIn("tabShortcut", button)
-        for marker in ("directKey", "tabShortcut", "Shortcut: Option+", "event.code"):
-            self.assertNotIn(marker, self.page)
-        perf = Path(__file__).resolve().parents[1].joinpath("performance.html").read_text(encoding="utf-8")
-        for marker in ("aria-keyshortcuts", "data-shortcut-digit", "railShortcut", "Shortcut: Option+", "event.code"):
-            self.assertNotIn(marker, perf)
-
-    def test_tools_is_in_the_secondary_rail_above_settings(self):
-        secondary = self.page.split("<div class=navSecondary>", 1)[1].split(
-            "</div>", 1
-        )[0]
-        self.assertIn("id=tab-capabilities", secondary)
-        self.assertLess(secondary.index("id=tab-learn"), secondary.index("id=tab-capabilities"))
-        self.assertLess(secondary.index("id=tab-capabilities"), secondary.index("id=tab-settings"))
-
-    def test_read_action_opens_tokenomics_before_learn_without_becoming_a_route(self):
-        secondary = self.page.split("<div class=navSecondary>", 1)[1].split(
-            "</div>", 1
-        )[0]
-        self.assertIn("id=tab-read", secondary)
-        self.assertLess(secondary.index("id=tab-read"), secondary.index("id=tab-learn"))
-        self.assertIn(
-            "$('tab-read').onclick=()=>window.open(TOKENOMICS_SEARCH_URL,'_blank','noopener')",
-            self.page,
-        )
-        commands = self.page.split("const NAV_COMMANDS=[", 1)[1].split("];", 1)[0]
-        self.assertNotIn("id:'read'", commands)
-        self.assertNotIn("route:'read'", self.page)
-
-    def test_onboarding_checklist_and_lesson_dialog_are_retired(self):
-        current = self.page.split('<div class="view on" id=view-session>', 1)[1].split(
-            '<div class=view id=view-models>', 1
-        )[0]
-        for retired in (
-            "id=onboarding-card", "id=onboarding-toggle", "id=onboarding-progress",
-            "id=onboarding-next", "id=onboarding-checklist", "id=onboarding-dialog",
-            "id=learn-onboarding-status", "id=learn-onboarding-action",
-            "First five minutes", "Closing this lesson marks the step complete",
-        ):
-            self.assertNotIn(retired, self.page)
-        self.assertNotIn(">Collapse<", current)
-        for retired in (
-            "ONBOARDING_STEPS", "function renderOnboarding(", "function commitOnboardingSteps(",
-            "function openOnboardingLesson(", "function resumeOrRestartOnboarding(",
-            "onboardingCard", "onboardingDialog", "learnOnboarding", "action:'onboarding'",
-        ):
-            self.assertNotIn(retired, self.page)
-
-    def _tour_script(self, body):
-        """Runs the tour's DOM-free block (storage, slide copy, frame markup) in Node with the page's own formatters."""
-        page_path = json.dumps(str(Path(DASHBOARD_PAGE)))
-        return f"""
-const fs=require('fs');
-const page=fs.readFileSync({page_path},'utf8');
-const helpers=page.match(/^const (f|compactNumber|money|wholeMoney|pct|countWord|esc)=.*$/gm).join('\\n').replace(/^const /gm,'var ');
-eval(helpers);
-var LATEST=null;Object.defineProperty(globalThis,'navigator',{{value:{{platform:'',userAgent:''}},configurable:true,writable:true}});
-var providerColor=id=>`var(--provider-${{id}})`,runtimeMarkSvg=()=>'<svg class=runtimeMark></svg>',compareColor=i=>['var(--c-a)','var(--c-b)'][i%2];
-var modelRankedColors=groups=>new Map(groups.map((group,index)=>[group.key,`shade-${{index}}`]));
-var stored=new Map(),blocked={{read:false,write:false}};
-var localStorage={{getItem:key=>{{if(blocked.read)throw Error('blocked');return stored.get(key)??null;}},setItem:(key,value)=>{{if(blocked.write)throw Error('quota');stored.set(key,String(value));}}}};
-const start=page.indexOf('// deck-pure-start'),end=page.indexOf('// deck-pure-end');
-if(start<0||end<0)throw Error('missing deck-pure block');
-eval(page.slice(start,end).replace(/^const /gm,'var '));
-const richState={{
- total_tokens:82702828,total_cost:38.59,turns:703,provider:'claude',primary_model:'claude-opus-5-5',
- context:{{latest:112214,peak:325998,window:200000,latest_pct:.56}},
- xsession:{{
-  total_sessions:2179,model_mix:[{{model:'gpt-5.6-sol',runtime:'Codex',providers:['codex'],cost:4278}}],
-  capabilities:{{summary:{{definitions:{{definition_tokens:120000,unused_eager_definition_tokens:83907}}}}}},
-  agent_usage:{{totals:{{agents:646,cost_covered_agents:640,known_cost:1001.45}}}},
-  budget:{{month:'2026-10',configured:true,budget:8940,spend:1792.7,percent:.2,projection_ready:true,projected_spend:3704.9,state:'on_track'}},
- }},
-}};
-const frameSlides=DECK_SLIDES.map((slide,index)=>({{slide,index}})).filter(row=>row.slide.frame);
-{body}
-"""
-
-    def _run_tour(self, body):
-        completed = subprocess.run(
-            ["node", "-e", self._tour_script(body)], capture_output=True, text=True,
-        )
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        return json.loads(completed.stdout)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_registry_has_twelve_page_named_slides_in_four_chapters(self):
-        payload = self._run_tour("""
-process.stdout.write(JSON.stringify({
- chapters:DECK_CHAPTERS.map(c=>c.title),
- slides:DECK_SLIDES.map(s=>[s.chapter,s.id]),
- complete:DECK_SLIDES.every(s=>['rail','kicker','title'].every(k=>typeof s[k]==='string'&&s[k].trim())&&(s.body===undefined||typeof s.body==='string'&&s.body.trim())&&(!!s.frame!==(typeof s.visual==='function'))),
- frames:DECK_SLIDES.filter(s=>s.frame).every(s=>typeof s.frame.html==='function'&&s.frame.html.length===0&&s.frame.label&&s.frame.alt&&Array.isArray(s.frame.legend)),
- time:[deckTimeLeft(0),deckTimeLeft(6),deckTimeLeft(10),deckTimeLeft(11)],
-}));
-""")
-        self.assertEqual(payload["chapters"], ["The basics", "While you work", "Review and find waste", "Do better"])
-        self.assertEqual(payload["slides"], [
-            ["basics", "tokens"], ["basics", "prices"],
-            ["work", "context"], ["work", "glance"], ["work", "compare"],
-            ["review", "month"], ["review", "models"], ["review", "efficiency"], ["review", "tools"], ["review", "helpers"],
-            ["better", "agent"], ["better", "start"],
-        ])
-        self.assertTrue(payload["complete"], "each slide has copy and exactly one visual: a frame or a list")
-        self.assertTrue(payload["frames"], "frame markup takes no arguments, so no live value can reach it")
-        self.assertEqual(payload["time"], ["about 4 min", "about 2 min left", "under a minute left", "under a minute left"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_copy_stays_within_slide_word_budgets(self):
-        # Less text, more explaining: the frame and its numbered legend carry the idea. Node reports
-        # no known platform here, so the longest companion wording is counted.
-        payload = self._run_tour("""
-const words=text=>String(text||'').split(/\\s+/).filter(word=>/[A-Za-z0-9$]/.test(word)).length;
-const sentences=text=>String(text||'').split(/[.!?](?:\\s|$)/).filter(part=>part.trim()).length;
-process.stdout.write(JSON.stringify(DECK_SLIDES.map(s=>({id:s.id,title:words(s.title),body:words(s.body),
- bodySentences:sentences(s.body),legend:(s.frame?.legend||[]).map(words),links:(s.links||[]).length,frame:!!s.frame}))));
-""")
-        self.assertEqual(len(payload), 12)
-        for row in payload:
-            with self.subTest(slide=row["id"]):
-                self.assertLessEqual(row["title"], 8, "headline")
-                self.assertLessEqual(row["body"], 14, "body")
-                self.assertLessEqual(row["bodySentences"], 1, "body is one sentence or none")
-                self.assertLessEqual(row["links"], 1, "at most one action link")
-                if row["frame"]:
-                    self.assertGreaterEqual(len(row["legend"]), 1)
-                    self.assertLessEqual(len(row["legend"]), 3, "at most three legend lines")
-                    for count in row["legend"]:
-                        self.assertLessEqual(count, 12, "legend line")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_frames_are_labeled_examples_with_matching_callouts(self):
-        payload = self._run_tour("""
-process.stdout.write(JSON.stringify(frameSlides.map(({slide,index})=>{
- const html=deckVisualHtml(index,'learn');
- const stage=html.split('<div class=conceptFrameStage role=img aria-label="')[1]?.split('<figcaption>')[0]||'';
- const legend=html.split('<figcaption>')[1]||'';
- const markers=[...stage.matchAll(/<mark class=frameCallout(?: data-at=\\w+)? aria-hidden=true>(\\d)<\\/mark>/g)].map(m=>Number(m[1]));
- const keys=[...legend.matchAll(/<li><mark class=frameCallout aria-hidden=true>(\\d)<\\/mark><span>/g)].map(m=>Number(m[1]));
- return {id:slide.id,figure:html.startsWith('<figure class=conceptFrame')&&html.endsWith('</figure>'),
-  example:(html.match(/<span class=chip>Example<\\/span>/g)||[]).length,
-  head:html.includes('<div class=conceptFrameHead><span>'),alt:/^[^"<>]{12,}"/.test(stage),
-  markers:markers.sort(),keys,orderedList:legend.startsWith('<ol class=frameLegend role=list>'),
-  allMarkersHidden:(html.match(/class=frameCallout/g)||[]).length===(html.match(/class=frameCallout(?: data-at=\\w+)? aria-hidden=true>/g)||[]).length};
-})));
-""")
-        self.assertEqual(len(payload), 11)
-        for row in payload:
-            with self.subTest(frame=row["id"]):
-                self.assertTrue(row["figure"])
-                self.assertEqual(row["example"], 1, "one Example chip per frame, so nobody mistakes it for their numbers")
-                self.assertTrue(row["head"])
-                self.assertTrue(row["alt"], "the frame is one described image for screen readers")
-                self.assertTrue(row["orderedList"], "the legend is an ordered list")
-                self.assertTrue(row["allMarkersHidden"], "markers are visual; the legend carries the words")
-                count = len(row["keys"])
-                self.assertGreaterEqual(count, 1)
-                self.assertLessEqual(count, 3)
-                self.assertEqual(row["keys"], list(range(1, count + 1)))
-                self.assertEqual(row["markers"], list(range(1, count + 1)), "each legend number appears once on the frame")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_frames_never_show_live_numbers_or_talk_comparisons(self):
-        payload = self._run_tour("""
-const facts=[deckFacts({}),deckFacts(richState),deckFacts(null),deckFacts({xsession:{budget:{configured:true,budget:0}}})];
-const all=DECK_SLIDES.map((slide,i)=>facts.map(state=>deckCopyHtml(i,state,'learn')+deckVisualHtml(i,'learn')).join('')).join('');
-process.stdout.write(JSON.stringify({
- facts,
- visualsStable:DECK_SLIDES.every((slide,i)=>deckVisualHtml(i,'learn')===deckVisualHtml(i,'learn')),
- copyStable:DECK_SLIDES.map((slide,i)=>new Set(facts.map(state=>deckCopyHtml(i,state,'learn'))).size),
- personal:['2,179','2179','1,792','1792','8,940','8940','83,907','83907','38.59','claude-opus-5-5','gpt-5.6-sol'].filter(value=>all.includes(value)),
- talk:['Yours','From the talk','talkChip','yoursChip','engineer’s laptop','$31.14','6% → 55%','83,907','5.1×'].filter(value=>all.includes(value)),
-}));
-""")
-        self.assertEqual(payload["facts"], [
-            {"budgetConfigured": False}, {"budgetConfigured": True},
-            {"budgetConfigured": False}, {"budgetConfigured": False},
-        ])
-        self.assertTrue(payload["visualsStable"])
-        self.assertEqual(payload["copyStable"], [1] * 11 + [2], "only the last slide's call to action reads live state")
-        self.assertEqual(payload["personal"], [], "frames carry sample values, never the user's numbers")
-        self.assertEqual(payload["talk"], [], "the deck explains concepts; no Yours or From the talk comparisons")
-        for retired in (
-            "learnEvidence", "learnOutputTrend", "figureHtml", "evidenceFigure", "TALK_CHIP", "YOURS_CHIP",
-            "TALK_NOTE", "TALK_OUTPUT_MONTHS", "talkChip", "yoursChip", "leverValue", "miniPreview",
-            "class=takeaway", "WELCOME_HOST", "deckPreviewHtml",
-        ):
-            self.assertNotIn(retired, self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_both_tour_hosts_render_the_same_slides(self):
-        payload = self._run_tour("""
-const facts=[deckFacts({}),deckFacts(richState)];
-const same=DECK_SLIDES.map((slide,i)=>facts.every(state=>
- deckCopyHtml(i,state,'welcome').replaceAll('welcome-','HOST-')===deckCopyHtml(i,state,'learn').replaceAll('learn-','HOST-')&&
- deckVisualHtml(i,'welcome').replaceAll('welcome-','HOST-')===deckVisualHtml(i,'learn').replaceAll('learn-','HOST-')));
-const agent=DECK_SLIDES.findIndex(slide=>slide.id==='agent'),last=DECK_SLIDES.length-1;
-process.stdout.write(JSON.stringify({same,agentAnchor:deckVisualHtml(agent,'learn').includes(' id=learn-agent-access>'),
- cta:[deckCopyHtml(last,facts[0],'welcome').includes('>Set a monthly budget<'),deckCopyHtml(last,facts[1],'welcome').includes('>Review your budget<')]}));
-""")
-        self.assertEqual(payload["same"], [True] * 12)
-        self.assertTrue(payload["agentAnchor"])
-        self.assertEqual(payload["cta"], [True, True])
-        dialog = self.page.split("<dialog class=welcome id=welcome-dialog", 1)[1].split("</dialog>", 1)[0]
-        learn = self.page.split("<div class=view id=view-learn>", 1)[1].split("<div class=view id=view-capabilities>", 1)[0]
-        self.assertIn('<div class=deck id=welcome-deck data-deck-host=welcome></div>', dialog)
-        self.assertIn('<div class="deck deckInline" id=learn-deck data-deck-host=learn></div>', learn)
-        for host in (dialog, learn):
-            self.assertNotIn("<h2", host, "slide copy lives in DECK_SLIDES, not in host markup")
-            self.assertNotIn("conceptFrame", host)
-        self.assertIn("function renderWelcome(state=LATEST){paintDeck('welcome',state);}", self.page)
-        self.assertIn("if(ensureDeck('learn'))paintDeck('learn',state);", self.page)
-        self.assertIn("paintPreview(`${host}-deck-visual`,deckVisualHtml(current.index,host));", self.page)
-        for retired in ("WELCOME_PANELS", "data-welcome-panel", "learnQuestion", "learnBlock", "learn-replay-welcome", "welcomeDot"):
-            self.assertNotIn(retired, self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_keeps_privacy_estimate_and_agent_caveats(self):
-        payload = self._run_tour("""
-const legend=id=>DECK_SLIDES.find(slide=>slide.id===id).frame.legend.join(' ');
-process.stdout.write(JSON.stringify({tokens:legend('tokens'),privacy:DECK_SLIDES.find(slide=>slide.id==='tokens').body,agent:legend('agent'),
- agentBody:DECK_SLIDES.find(slide=>slide.id==='agent').body,glance:DECK_SLIDES.find(slide=>slide.id==='glance').body,
- places:['mac','windows','linux','other'].map(id=>({mac:'menu bar',windows:'notification area',linux:'tray'}[id]||'menu bar or tray'))}));
-""")
-        self.assertIn("estimate", payload["tokens"])
-        self.assertIn("not your bill", payload["tokens"])
-        self.assertIn("on your computer", payload["privacy"])
-        self.assertIn("never uploaded", payload["privacy"])
-        self.assertIn("numbers only, never your prompts or code", payload["agent"])
-        self.assertIn("session-budget changes need your OK", payload["agent"])
-        self.assertIn("AI provider sees those numbers", payload["agent"])
-        self.assertIn("(MCP)", payload["agentBody"])
-        self.assertEqual(payload["glance"], "It sits in your menu bar or tray, always on.")
-        self.assertIn("const COMPANION_PLACE={mac:'menu bar',windows:'notification area',linux:'tray'}[DECK_PLATFORM]||'menu bar or tray';", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_escapes_every_interpolated_label(self):
-        payload = self._run_tour("""
-const bad='<img src=x onerror=alert(1)>';
-const frame=conceptFrameHtml({kind:'x',label:bad,alt:`"${bad}`,legend:[bad,bad],html:()=>''},'learn');
-const habits=HABITS.map(habit=>({...habit}));HABITS.length=0;HABITS.push({icon:'model',title:bad,page:bad,route:'models'});
-const list=habitsListHtml();HABITS.length=0;habits.forEach(habit=>HABITS.push(habit));
-const copy=DECK_SLIDES.map((slide,i)=>deckCopyHtml(i,deckFacts(richState),'learn')+deckVisualHtml(i,'learn')+deckResumeHtml(i,'learn')).join('');
-process.stdout.write(JSON.stringify({frame:frame.includes('<img'),quote:frame.includes('aria-label=""'),list:list.includes('<img'),copy:copy.includes('<img')}));
-""")
-        self.assertEqual(payload, {"frame": False, "quote": False, "list": False, "copy": False})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_rail_states_and_skip_chapter_targets(self):
-        payload = self._run_tour("""
-const rail=deckRailHtml(6);
-process.stdout.write(JSON.stringify({
- skip:DECK_SLIDES.map((_,i)=>deckChapterSkipTarget(i)),
- steps:[...rail.matchAll(/data-deck-go=(\\d+) data-state=(\\w+)/g)].map(m=>m[2]),
- chapters:[...rail.matchAll(/class=deckChapter data-state=(\\w+)/g)].map(m=>m[1]),
- current:(rail.match(/aria-current=step/g)||[]).length,
- glyphs:[rail.includes('aria-hidden=true>✓</i>'),rail.includes('aria-hidden=true>●</i>'),rail.includes('aria-hidden=true>○</i>')],
-}));
-""")
-        self.assertEqual(payload["skip"], [2, 2, 5, 5, 5, 10, 10, 10, 10, 10, -1, -1])
-        self.assertEqual(payload["steps"], ["done"] * 6 + ["current"] + ["upcoming"] * 5)
-        self.assertEqual(payload["chapters"], ["done", "done", "current", "upcoming"])
-        self.assertEqual(payload["current"], 1)
-        self.assertEqual(payload["glyphs"], [True, True, True])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_welcome_resume_and_auto_show_matrix(self):
-        payload = self._run_tour("""
-function run(entries,{read=false,write=false,requested=null,act=null}={}){
- stored=new Map(entries);blocked={read,write};
- const auto=welcomeShouldAutoShow(),start=welcomeStartSlide(requested);
- if(act)act();
- let saved=null;try{saved=JSON.parse(stored.get(WELCOME_KEY));}catch(error){}
- const legacyKept=stored.has(LEGACY_ONBOARDING_KEY);
- let after=null;if(!read&&!write){markWelcomeSeen(0);after=welcomeShouldAutoShow();}
- return {auto,start,saved:saved&&{seen:saved.seen,stamped:Number(saved.dismissed_at)>0,last_slide:saved.last_slide},legacyKept,after};
-}
-const welcome=value=>[[WELCOME_KEY,typeof value==='string'?value:JSON.stringify(value)]];
-const legacy=value=>[[LEGACY_ONBOARDING_KEY,JSON.stringify(value)]];
-process.stdout.write(JSON.stringify({
- fresh:run([],{act:()=>markWelcomeSeen(0)}),
- progressing:run([],{act:()=>recordWelcomeSlide(4)}),
- resume:run(welcome({seen:true,dismissed_at:1,last_slide:6})),
- midTourReload:run(welcome({seen:false,last_slide:3})),
- explicit:run(welcome({seen:true,dismissed_at:1,last_slide:6}),{requested:2}),
- finished:run(welcome({seen:true,dismissed_at:1,last_slide:0})),
- outOfRange:run(welcome({seen:true,dismissed_at:1,last_slide:99})),
- negative:run(welcome({seen:true,dismissed_at:1,last_slide:-2})),
- fractional:run(welcome({seen:true,dismissed_at:1,last_slide:2.5})),
- corrupt:run(welcome('{nope')),
- seenKeepsSeen:run(welcome({seen:true,dismissed_at:5,last_slide:1}),{act:()=>recordWelcomeSlide(8)}),
- closeAt:run([],{act:()=>markWelcomeSeen(7)}),
- legacyStep:run(legacy({completed:['current'],collapsed:false,completed_at:0})),
- legacyCollapsed:run(legacy({completed:[],collapsed:true,completed_at:0})),
- legacyFinished:run(legacy({completed:[],collapsed:false,completed_at:1700000000000})),
- legacyUntouched:run(legacy({completed:[],collapsed:false,completed_at:0})),
- readBlocked:run([],{read:true,act:()=>{recordWelcomeSlide(3);markWelcomeSeen(3);}}),
- writeBlocked:run([],{write:true,act:()=>{recordWelcomeSlide(3);markWelcomeSeen(3);saveLearnSlide(3);}}),
- learn:(()=>{stored=new Map([[LEARN_SLIDE_KEY,'9']]);blocked={read:false,write:false};const a=readLearnSlide();stored.set(LEARN_SLIDE_KEY,'x');const b=readLearnSlide();blocked.read=true;const c=readLearnSlide();return [a,b,c];})(),
-}));
-""")
-        start = lambda index, offer: {"index": index, "offer": offer}
-        self.assertEqual(payload["fresh"]["saved"], {"seen": True, "stamped": True, "last_slide": 0})
-        self.assertTrue(payload["fresh"]["auto"])
-        self.assertEqual(payload["fresh"]["start"], start(0, False))
-        for case in ("fresh", "legacyStep", "legacyUntouched", "corrupt", "resume"):
-            with self.subTest(after=case):
-                self.assertFalse(payload[case]["after"], "a seen tour never auto-shows again")
-        for case in ("legacyStep", "legacyCollapsed", "legacyFinished", "legacyUntouched"):
-            with self.subTest(legacy=case):
-                self.assertTrue(payload[case]["legacyKept"], "the legacy onboarding key stays readable")
-        self.assertEqual(payload["progressing"]["saved"], {"seen": False, "stamped": False, "last_slide": 4})
-        self.assertEqual(payload["resume"]["start"], start(6, True))
-        self.assertFalse(payload["resume"]["auto"])
-        self.assertTrue(payload["midTourReload"]["auto"], "a tour never closed reopens on the next launch")
-        self.assertEqual(payload["midTourReload"]["start"], start(3, True))
-        self.assertEqual(payload["explicit"]["start"], start(2, False))
-        for case in ("finished", "outOfRange", "negative", "fractional", "corrupt"):
-            with self.subTest(case=case):
-                self.assertEqual(payload[case]["start"], start(0, False))
-        self.assertTrue(payload["corrupt"]["auto"])
-        self.assertEqual(payload["seenKeepsSeen"]["saved"], {"seen": True, "stamped": True, "last_slide": 8})
-        self.assertEqual(payload["closeAt"]["saved"], {"seen": True, "stamped": True, "last_slide": 7})
-        for case in ("legacyStep", "legacyCollapsed", "legacyFinished"):
-            with self.subTest(case=case):
-                self.assertFalse(payload[case]["auto"])
-        self.assertTrue(payload["legacyUntouched"]["auto"])
-        self.assertEqual(payload["readBlocked"]["auto"], False)
-        self.assertEqual(payload["readBlocked"]["start"], start(0, False))
-        self.assertEqual(payload["writeBlocked"]["auto"], True)
-        self.assertEqual(payload["writeBlocked"]["start"], start(0, False))
-        self.assertIsNone(payload["writeBlocked"]["saved"])
-        self.assertEqual(payload["learn"], [9, 0, 0])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_tour_controls_page_skip_chapters_and_close_the_overlay(self):
-        payload = self._run_tour(f"""
-function extract(name){{let s=page.indexOf(`function ${{name}}(`);if(s<0)throw Error(`missing ${{name}}`);let i=page.indexOf('){{',s)+1,d=0;for(;i<page.length;i++){{if(page[i]==='{{')d++;else if(page[i]==='}}'&&--d===0)return page.slice(s,i+1);}}}}
-const els={{}};
-var document={{activeElement:null,querySelector:()=>null}};
-var $=id=>els[id]||(els[id]={{id,dataset:{{}},innerHTML:'',textContent:'',hidden:false,disabled:false,className:'',scrollTop:0,open:false,contains:()=>false,querySelector:()=>null,focus(){{}},scrollIntoView(){{}},close(){{this.open=false;closed.push(this.id);}}}});
-var requestAnimationFrame=fn=>fn(),deliveryPayload=null,closed=[],routes=[];
-var openTopLevelRoute=route=>routes.push(route),location={{hash:'#sessions'}},tourReturn=null;
-eval(['paintPreview','deckShellHtml','ensureDeck','paintDeck','showDeckSlide','openDeckRoute','deckAction','closeWelcome','showTourReturn','deckKey'].map(extract).join('\\n'));
-eval(page.slice(page.indexOf('const deckHosts='),page.indexOf(';',page.indexOf('const deckHosts='))+1).replace(/^const /,'var '));
-const log=[];
-showDeckSlide('welcome',0);log.push(deckHosts.welcome.index);
-deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
-deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
-deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
-const skipDisabled=$('welcome-deck-skip-chapter').disabled;
-deckAction('welcome','skip-chapter');log.push(deckHosts.welcome.index);
-deckAction('welcome','back');log.push(deckHosts.welcome.index);
-const recorded=JSON.parse(stored.get(WELCOME_KEY)).last_slide;
-const arrows=[];const key=k=>({{key:k,preventDefault(){{}},target:null}});
-deckKey('welcome',key('ArrowRight'));arrows.push(deckHosts.welcome.index);deckKey('welcome',key('ArrowLeft'));arrows.push(deckHosts.welcome.index);
-showDeckSlide('welcome',13);const doneLabel=[$('welcome-deck-next').textContent,$('welcome-deck-next').className];
-$('welcome-dialog').open=true;deckAction('welcome','next');
-showDeckSlide('learn',13);const learnLast=$('learn-deck-next').textContent;deckAction('learn','next');
-showDeckSlide('welcome',5,{{offer:true}});const offerFoot=$('welcome-deck-foot').hidden,offerStage=$('welcome-deck-stage').innerHTML;
-deckAction('welcome','restart');
-$('welcome-dialog').open=true;closeWelcome({{route:'settings',target:'agent-access'}});
-process.stdout.write(JSON.stringify({{log,skipDisabled,recorded,arrows,doneLabel,closed,learnAfterLast:deckHosts.learn.index,learnLast,offerFoot,offerResume:offerStage.includes('data-deck-action=resume')&&offerStage.includes('data-deck-action=restart'),afterRestart:[deckHosts.welcome.index,deckHosts.welcome.offer],routes,counter:$('welcome-deck-count').textContent}}));
-""")
-        self.assertEqual(payload["log"], [0, 2, 5, 10, 10, 9])
-        self.assertTrue(payload["skipDisabled"])
-        self.assertEqual(payload["recorded"], 9)
-        self.assertEqual(payload["arrows"], [10, 9])
-        self.assertEqual(payload["doneLabel"], ["Done", "tbtn"])
-        self.assertEqual(payload["closed"], ["welcome-dialog", "welcome-dialog"])
-        self.assertEqual(payload["learnLast"], "Back to start")
-        self.assertEqual(payload["learnAfterLast"], 0)
-        self.assertTrue(payload["offerFoot"])
-        self.assertTrue(payload["offerResume"])
-        self.assertEqual(payload["afterRestart"], [0, False])
-        self.assertEqual(payload["routes"], ["settings"])
-        self.assertEqual(payload["counter"], "1 / 12 · about 4 min")
-
-    def test_welcome_overlay_and_learn_deck_shells(self):
-        dialog = self.page.split("<dialog class=welcome id=welcome-dialog", 1)[1].split("</dialog>", 1)[0]
-        self.assertIn("aria-modal=true", dialog)
-        self.assertIn("aria-labelledby=welcome-label", dialog)
-        self.assertIn('<button class=welcomeClose id=welcome-close type=button aria-label="Close welcome"', dialog)
-        self.assertIn("aria-hidden=true>&#10005;</span>", dialog)
-        self.assertIn("id=welcome-skip type=button>Skip tour</button>", dialog)
-        for marker in (
-            "$('welcome-close').onclick=()=>closeWelcome();",
-            "$('welcome-skip').onclick=()=>closeWelcome();",
-            "$('welcome-dialog').addEventListener('cancel',event=>{event.preventDefault();closeWelcome();});",
-            "markWelcomeSeen(index>=DECK_SLIDES.length-1?0:index);",
-            "if($('welcome-dialog').open){handleWelcomeKey(event);return;}",
-            "handleLearnDeckKey(event);",
-            "if(welcomeShouldAutoShow())openWelcome(null,{auto:true});",
-            "data-deck-action=skip-chapter>Skip chapter</button>",
-            "{id:'welcome',label:'Open welcome tour'",
-            "if(command.action==='welcome'){const returnFocus=commandReturnFocus;commandReturnFocus=null;openWelcome(null,{returnFocus});return;}",
-            "$('learn-play').onclick=()=>openWelcome(deckHosts.learn.index,{fromLearn:true});",
-            "if(h==='learn-agent-access')showDeckSlide('learn',DECK_SLIDES.findIndex(slide=>slide.id==='agent'),{animate:false});",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("maybeAutoShowWelcome();", self.page.split("function applyLiveState(state){", 1)[1].split("\n}", 1)[0])
-        learn = self.page.split("<div class=view id=view-learn>", 1)[1].split("<div class=view id=view-capabilities>", 1)[0]
-        self.assertIn("<h1>Learn</h1>", learn)
-        self.assertIn("<p class=spectrumPageSubtitle>Spend tokens like money. Measure what you get back.</p>", learn)
-        self.assertIn("id=learn-play type=button>Play as full screen</button>", learn)
-        self.assertNotIn("learnSection", learn)
-        css = self.page[self.page.index("<style>"):self.page.index("</style>")]
-        self.assertIn(".welcome{", css)
-        self.assertRegex(css, r"@media\(prefers-reduced-motion:reduce\)\{[^\n]*\.deckEnter")
-        self.assertIn(".deck{display:grid;grid-template-columns:212px minmax(0,1fr)", css)
-        self.assertIn("const TOKENOMICS_URL='https://www.splunk.com/en_us/products/tokenomics.html';", self.page)
-        self.assertIn('target=_blank rel="noopener noreferrer">Read about Tokenomics', self.page)
-
-    def test_all_sessions_supports_app_project_and_time_range_filters(self):
-        for marker in ("id=g-app", "id=g-project", "id=g-time", "App filter",
-                       "Projects filter", "Time range filter", "class=logsToolbarStatus", "id=g-active-filters",
-                       "id=g-clear", "id=lf-cost", "id=lf-input", "id=lf-output", "id=lf-models"):
-            self.assertIn(marker, self.page)
-        clear_wrapper = re.search(r"<div class=filterClear>(.*?)</div>", self.page)
-        self.assertIsNotNone(clear_wrapper)
-        self.assertIn("id=g-clear", clear_wrapper.group(1))
-        self.assertNotIn("id=g-count", clear_wrapper.group(1))
-        self.assertLess(self.page.index("id=g-clear"), self.page.index("id=g-sort"))
-        for value in ("value=today", "value=yesterday", "value=7d", "value=30d", "value=90d", "value=month", "value=last_month"):
-            self.assertIn(value, self.page)
-        self.assertIn("allSessionsView(workRows,{showChildren:globalShowChildren,app:globalApp,project:globalProject,rangeStart,rangeEnd,query:q})", self.page)
-        self.assertIn("if(app&&appFilterGroup(s)!==app)return false;", self.page)
-        self.assertIn("const appFilterGroup=session=>runtimeId(session)", self.page)
-        self.assertIn("const appFilterLabel=session=>runtimeMeta(session).label", self.page)
-        self.assertIn("['claude_code','claude_desktop'].includes(globalApp)", self.page)
-        self.assertIn("if(project&&projectFilterValue(s.project)!==project)return false;", self.page)
-        self.assertIn("Other local sessions", self.page)
-        self.assertIn("const {start:rangeStart,end:rangeEnd}=timeFilterBounds(globalTime);", self.page)
-        self.assertIn("tm_global_app", self.page)
-        self.assertIn("tm_global_project", self.page)
-        self.assertIn("tm_global_time", self.page)
-        self.assertIn("renderAllSessionStats(view.statsRows)", self.page)
-        self.assertIn("session.model_stats", self.page)
-        self.assertIn("let globalTime=localStorage.getItem('tm_global_time')||DEFAULT_TIME_FILTER_WINDOW;", self.page)
-        self.assertIn("globalSearch='';globalApp='';globalProject='';globalTime=DEFAULT_TIME_FILTER_WINDOW", self.page)
-        self.assertIn("if(key==='time'){globalTime=DEFAULT_TIME_FILTER_WINDOW;", self.page)
-        self.assertIn("globalTime!==DEFAULT_TIME_FILTER_WINDOW&&['time',", self.page)
-        self.assertIn("['tm_global_search','tm_global_app','tm_global_project','tm_global_time']", self.page)
-        self.assertIn("fetch('/logs',{cache:'no-store'})", self.page)
-        self.assertIn("allSessionInventory?mergeAllSessionInventory(allSessionInventory,xs.sessions)", self.page)
-
-    def test_all_sessions_live_updates_preserve_mounted_rows(self):
-        for marker in (
-            "const logHtmlCache=new WeakMap()",
-            "function setLogText(element,value)",
-            "function setLogAttribute(element,name,value)",
-            "function setLogHtml(element,html)",
-            "function logRowRenderKey(s,active)",
-            "function reconcileLogRows(sessions,maxCost,liveSessionIds=new Set())",
-            "const interactingLogRow=forceAllSessionRowRefresh?null:root.querySelector('.srow:hover,.srow:focus-within');",
-            "if(interactingLogRow)return;",
-            "function mergeAllSessionInventory(inventory,liveSessions)",
-            "const key=row=>row?.key?compareKeyFor(row):sessionRowKey(row);",
-            "(liveSessions||[]).forEach(row=>rows.set(key(row),row))",
-            "const liveSessionIds=new Set((xs.current_sessions||[]).map(sessionRowKey));",
-            "const live=liveSessionIds.has(key)",
-            "const hasChildren=childAgentsFor(s).length>0;",
-            "const compareIndex=compareIds.indexOf(rowKey);",
-            "className=`srow${active?' active':''}${live?' live':''}${hasChildren?' hasChildren':''}${compareIndex>=0?' compareSelected':''}`",
-            ".srow.active,.srow.live{border-color:rgb(var(--signal-rgb)/.62)",
-            "const existing=new Map([...root.children]",
-            "if(row.className!==className)row.className=className",
-            "if(row.getAttribute('aria-label')!==ariaLabel)",
-            "if(row._logRenderKey!==renderKey)",
-            "else root.insertBefore(row,cursor)",
-            "reconcileLogRows(sessions,maxCost,liveSessionIds)",
-            "$('slist').onclick=event=>",
-            "$('slist').onkeydown=event=>",
-            "const inventoryStale=!allSessionInventory",
-            "if(inventoryStale)loadAllSessions()",
-            "else renderAllSessions(LATEST.xsession)",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn(
-            "body.spectrumApp.sessionRoute #view-session .srow:hover{transform:none}",
-            self.page,
-        )
-        self.assertNotIn("$('slist').innerHTML=sessions.length?sessions.map", self.page)
-
-    @staticmethod
-    def page_function(page, name):
-        start = page.index("function {}(".format(name))
-        depth = 0
-        for index in range(start, len(page)):
-            if page[index] == "{":
-                depth += 1
-            elif page[index] == "}":
-                depth -= 1
-                if depth == 0:
-                    return page[start:index + 1]
-        raise AssertionError(name)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_all_sessions_keep_one_row_per_trace_file(self):
-        script = "\n".join(
-            self.page_function(self.page, name)
-            for name in ("sessionRowKey", "compareKeyFor", "mergeAllSessionInventory")
-        ) + """
-const inventory=[
- {id:'task-1',session:'rollout-a.jsonl',cost:0.91},
- {id:'task-1',session:'rollout-b.jsonl',cost:111.57},
- {id:'task-1',session:'rollout-c.jsonl',cost:0.16},
- {id:'legacy'},
-];
-const live=[{id:'task-1',session:'rollout-b.jsonl',cost:112.0}];
-const merged=mergeAllSessionInventory(inventory,live);
-console.log(JSON.stringify({
- keys:merged.map(sessionRowKey),
- cost:merged.reduce((sum,row)=>sum+(row.cost||0),0),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        merged = json.loads(result.stdout)
-        self.assertEqual(merged["keys"], [
-            "rollout-a.jsonl", "rollout-b.jsonl", "rollout-c.jsonl", "legacy",
-        ])
-        self.assertAlmostEqual(merged["cost"], 0.91 + 112.0 + 0.16)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_header_names_the_opened_trace_not_a_sibling(self):
-        script = "let allSessionInventory=null;\n" + "\n".join(
-            self.page_function(self.page, name)
-            for name in ("stateSessionId", "stateSessionKey", "sessionStartMessage", "sessionDisplayName")
-        ) + """
-const state={session:'rollout-child.jsonl',source:{id:'task-1'},xsession:{current_sessions:[],sessions:[
- {id:'task-1',session:'rollout-root.jsonl',title:'Root title'},
- {id:'task-1',session:'rollout-child.jsonl',title:'Child title'}]}};
-const sibling={...state,session:'rollout-other.jsonl'};
-// Older traces fall outside the recent rows but are in the All sessions inventory the user opened them from.
-allSessionInventory=[{id:'task-1',session:'rollout-old.jsonl',title:'Old title'}];
-const older={...state,session:'rollout-old.jsonl'};
-console.log(JSON.stringify([sessionDisplayName(state),sessionDisplayName(sibling),sessionDisplayName(older)]));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        self.assertEqual(json.loads(result.stdout), ["Child title", "Session", "Old title"])
-
-    def test_all_sessions_inventory_is_declared_before_the_first_header_render(self):
-        declaration = self.page.index("let allSessionInventory=null")
-        self.assertLess(declaration, self.page.index("function showCurrentPanel("))
-        self.assertLess(declaration, self.page.index("function applyHashRoute(){"))
-
-    def test_every_session_entry_point_addresses_one_trace_file(self):
-        for marker in (
-            "function sessionRowKey(row){return String(row?.session||row?.id||'');}",
-            "function stateSessionKey(state){return String(state?.session||stateSessionId(state)||'');}",
-            "renderedAllSessions=new Map(all.map(row=>[sessionRowKey(row),row]));",
-            "const pinnedKey=pinned?(renderedAllSessions.has(pinned)?pinned:(stateSessionId(CURRENT)===pinned?stateSessionKey(CURRENT):'')):'';",
-            "const key=sessionRowKey(s),rowKey=compareKeyFor(s),active=pinned?key===pinnedKey:Boolean(LATEST&&key===stateSessionKey(LATEST));",
-            "row.dataset.id=key;",
-            "data-delete-session=\"${esc(sessionRowKey(s))}\"",
-            "body:JSON.stringify({session_id:target.id,trace:target.session||''})",
-            "const workRows=workSessionFilter?all.filter(s=>workSessionFilter.keys.has(sessionRowKey(s))):all;",
-            "keys:new Set(payload.keys.map(String))",
-            "data-spend-session=\"${esc(sessionRowKey(row))}\"",
-            "data-spend-insight-session=\"${esc(sessionRowKey(row))}\"",
-            "href=\"${esc(sessionRoute(sessionRowKey(row)))}\"",
-            "<span class=\"badge subagentTag\">Subagent</span>",
-                ".srow .subagentTag{",
-                "sessionDeleteAvailable(s,renderedAllSessionActions),s.subagent,s.client,",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("workSessionFilter.ids.has(String(s.id))", self.page)
-        self.assertNotIn("rows.set(String(row.id),row)", self.page)
-        self.assertNotIn("renderedAllSessions=new Map(all.map(row=>[String(row.id),row]));", self.page)
-
-    def test_current_and_all_sessions_share_the_defined_app_badge_helper(self):
-        self.assertIn("const appBadgeClass=session=>", self.page)
-        self.assertIn("'badge app '+appBadgeClass(s)", self.page)
-        self.assertIn("${appBadgeClass(s)}", self.page)
-        self.assertNotIn("providerBadgeClass", self.page)
-
-    def test_current_sessions_keep_opencode_identity(self):
-        self.assertIn(
-            "const provider=runtimeId(row)",
-            self.page,
-        )
-        self.assertIn('class="card currentSessionCard provider-${esc(provider)}', self.page)
-        self.assertIn("Object.entries(RUNTIME_CATALOG).filter(([id])=>id!=='unknown-runtime')", self.page)
-
-    def test_sessions_show_skill_and_mcp_capability_counts(self):
-        self.assertIn("return `${f(counts.used)}/${counts.loaded==null?'—':f(counts.loaded)}${counts.basis==='configured'?'*':''}`;", self.page)
-        self.assertIn('</div>${identityAction}</div>\n  <div class=sactions>${sessionDeleteAvailable(s,renderedAllSessionActions)?', self.page)
-        self.assertNotIn('<div class="badge tok">', self.page)
-        self.assertIn('class="sessionDelete sessionDeleteIcon" data-delete-session="${esc(sessionRowKey(s))}" type=button aria-label="Delete session" title="Delete session"><svg', self.page)
-        self.assertIn('<span class="currentSessionCaps mono" title="${esc(CAPABILITY_SUMMARY_TIP)}">${esc(capabilitySummaryText(row.capabilities))}</span>', self.page)
-        self.assertIn('<div class=meta title="${esc(`${waitText} · ${avg}/exec${speed} · ${CAPABILITY_SUMMARY_TIP}`)}">${esc(s.project||\'local\')} · ${esc(s.last||s.start||\'\')} · ${esc(capabilitySummaryText(s.capabilities))}</div>', self.page)
-        self.assertIn("s.throughput,s.cost_approx,s.capabilities,childAgentsFor(s)", self.page)
-        self.assertIn("<div class=sbar><i></i></div>${childAgentSubsection(s)}</div>", self.page)
-        self.assertIn('id=ov-skills>--</div>', self.page)
-        self.assertIn('id=ov-mcp>--</div>', self.page)
-        self.assertIn("counts.loaded==null?'loaded list not recorded'", self.page)
-        self.assertIn("* means configured now, not recorded by this session.", self.page)
-
-    def test_session_delete_actions_require_confirmation_and_use_trash_endpoint(self):
-        for marker in ("id=session-delete", "data-delete-session", "id=session-delete-dialog",
-                       "id=session-delete-confirm", "Move to Trash", "/session/delete"):
-            self.assertIn(marker, self.page)
-        self.assertIn("openSessionDeleteDialog", self.page)
-        self.assertIn("event.stopPropagation()", self.page)
-        self.assertIn("X-Token-Meter-Action", self.page)
-        self.assertIn("Provider metadata and configuration are not changed", self.page)
-        self.assertIn("function sessionDeleteAvailable(target,actions)", self.page)
-        self.assertIn("actions?.read_only_providers", self.page)
-        self.assertIn("status.alert_percent??status.percent", self.page)
-        self.assertIn("don't trigger budget notifications", self.page)
-        self.assertIn("!sessionDeleteAvailable(target,actions)", self.page)
-
-    def test_selected_candidate_action_has_confirmation_and_exact_control_ids(self):
-        self.assertIn("id=c-disable-selected", self.page)
-        self.assertIn("id=bulk-dialog", self.page)
-        self.assertIn("/capability/disable-unused", self.page)
-        self.assertIn('data-cap-select="${esc(row.id)}"', self.page)
-        self.assertIn("selectedCapabilityIds.add(input.dataset.capSelect)", self.page)
-        self.assertIn("unusedReviewGroups(cap).filter(row=>selectedCapabilityIds.has(row.id))", self.page)
-        self.assertIn("pendingBulkDisable={controlIds,fingerprints:", self.page)
-        self.assertIn("capabilityGroupFingerprint(row)", self.page)
-        self.assertIn("$('bulk-dialog-controls').textContent=controlIds.join('\\n')", self.page)
-        self.assertIn("control_ids:controlIds", self.page)
-        self.assertIn("Review evidence changed", self.page)
-        self.assertIn('aria-label="Select ${esc(name)}"', self.page)
-        self.assertIn("MCP servers, runtime packs, built-ins, standalone skills, and used groups are excluded.", self.page)
-        self.assertIn("Disable selected", self.page)
-        self.assertNotIn("id=c-disable-unused", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_capability_review_queue_renders_one_expandable_row_per_pack(self):
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const f=n=>Math.round(n||0).toLocaleString('en-US');
-const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
-const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({{'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}}[c]));
-const compactNumber=n=>String(n);
-const els={{}};
-const el=id=>els[id]||(els[id]={{id,textContent:'',innerHTML:'',hidden:false,disabled:false,title:'',classList:{{toggle(){{}}}},matches:()=>false,contains:()=>false,querySelectorAll:()=>[],querySelector:()=>null}});
-const $=el;
-const document={{activeElement:null}};
-const selectedCapabilityIds=new Set(['codex:aws']);
-const openCapabilityReviewIds=new Set();
-let capabilityEvidenceState='current',lastCapabilityReviewRevision='',pendingCapabilityReview=null;
-const openCapabilityInventory=()=>{{}};
-eval(['capabilityPackName','capabilityGroupFingerprint','updateCapabilitySelection','unusedReviewGroups'].map(extract).join('\\n'));
-eval(page.slice(page.indexOf('function renderCapabilityReviewQueue('),page.indexOf('function renderCapabilityTable(')));
-const group=(id,plugin,runtime,extra={{}})=>({{id,plugin_id:plugin,runtime,mutable:true,enabled:true,used:false,unmeasurable:false,scanned_sessions:142,members:['a','b','c','d','e','f'],setting_path:'~/.codex/config.toml',...extra}});
-const render=groups=>{{
- lastCapabilityReviewRevision='';
- renderCapabilityReviewQueue({{review_revision:String(Math.random()),summary:{{optional:{{review_candidates:groups.map(g=>g.id)}}}},control_groups:groups}},{{force:true}});
- return {{html:el('c-review-list').innerHTML,caveat:el('c-review-detail').textContent}};
-}};
-const same=render([group('codex:aws','aws-skills@market','Codex'),group('codex:gcp','gcp-skills','Codex',{{unused_eager_definition_tokens:12345,members:['solo']}})]);
-const mixed=render([group('codex:aws','aws-skills','Codex'),group('claude:k8s','k8s','Claude')]);
-process.stdout.write(JSON.stringify({{same,mixed}}));
-"""
-        payload = json.loads(subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        ).stdout)
-        same = payload["same"]["html"]
-        rows = re.findall(r"<article class=capReviewItem[^>]*>.*?</article>", same, re.S)
-        self.assertEqual(len(rows), 2)
-        self.assertEqual(same.count("class=capReviewHead"), 1)
-        self.assertLess(same.index("class=capReviewHead"), same.index("<article"))
-        first = rows[0]
-        summary = re.search(r"<summary class=capReviewCols[^>]*>(.*?)</summary>", first, re.S)
-        self.assertIsNotNone(summary)
-        summary_html = summary.group(1)
-        self.assertIn("<strong>aws-skills</strong>", summary_html)
-        self.assertIn("Codex · User-installed", summary_html)
-        self.assertIn("0 uses · 142 logs", summary_html)
-        self.assertIn('title="Not measured"', summary_html)
-        self.assertIn(">—<", summary_html)
-        self.assertNotIn(">0<", summary_html)
-        self.assertIn("6 skills", summary_html)
-        self.assertIn('class="stateDot unknown"', summary_html)
-        # The checkbox sits outside the summary so selecting never toggles the row.
-        self.assertNotIn("data-cap-select", summary_html)
-        self.assertNotIn("<input", first.split("</details>", 1)[0])
-        self.assertIn('data-cap-select="codex:aws" aria-label="Select aws-skills" checked', first)
-        detail = first.split("</summary>", 1)[1].split("</details>", 1)[0]
-        for marker in ("class=capReviewFacts", "0 activations · 142 Codex logs",
-                       "Not measured", "Exact control", "codex:aws", "~/.codex/config.toml"):
-            self.assertIn(marker, detail)
-        self.assertIn("12,345", rows[1])
-        self.assertIn("1 skill<", rows[1])
-        self.assertNotIn('aria-label="Select gcp-skills" checked', rows[1])
-        # One runtime: the restart note is shown once in the header, not per row.
-        self.assertNotIn("to apply", same)
-        self.assertIn("Restart Codex to apply", payload["same"]["caveat"])
-        mixed = payload["mixed"]["html"]
-        self.assertEqual(mixed.count("Restart Codex to apply"), 1)
-        self.assertEqual(mixed.count("Restart Claude to apply"), 1)
-        self.assertNotIn("Restart", payload["mixed"]["caveat"])
-
-    def test_capability_polling_uses_stable_revisions_and_lazy_inventory(self):
-        review = self.page.split("function renderCapabilityReviewQueue", 1)[1].split(
-            "function renderCapabilityTable", 1
-        )[0]
-        inventory = self.page.split("function renderCapabilityTable", 1)[1].split(
-            "let pendingCapabilityAction", 1
-        )[0]
-        self.assertIn("revision===lastCapabilityReviewRevision", review)
-        self.assertIn("lastCapabilityReviewRevision=revision", review)
-        self.assertIn("if(!cap)return;", inventory)
-        self.assertNotIn("c-inventory-details", inventory)
-        self.assertNotIn("$('c-inventory-details').addEventListener('toggle'", self.page)
-        self.assertIn("fetch('/capabilities/inventory',{cache:'no-store'})", self.page)
-        self.assertIn("countWord(inventoryCount,'capability','capabilities')", self.page)
-        self.assertIn("capabilityInventorySnapshot.inventory_revision===cap.inventory_revision", self.page)
-        self.assertIn("renderCapabilityTable(merged,{force});", self.page)
-        self.assertIn("if(inventory)renderCapabilityTable(inventory,{force:true});", self.page)
-        self.assertIn("capabilityLastGoodAt=Date.now()", self.page)
-        self.assertIn("setCapabilityAvailability('unavailable'", self.page)
-        self.assertIn("setCapabilityAvailability('stale'", self.page)
-        self.assertIn("capabilityEvidenceState!=='current'", self.page)
-        self.assertIn("Confirmation closed", self.page)
-        self.assertIn("if(capabilitySort==='returned')capabilitySort='use'", self.page)
-
-    def test_agent_access_has_a_dedicated_settings_tab(self):
-        for marker in ("id=agent-discovery", "id=agent-access", "id=agent-clients",
-                       "id=agent-dialog", "/agent-access/status", "/agent-access/toggle",
-                       "class=\"card settingsMap\""):
-            self.assertIn(marker, self.page)
-        self.assertIn("frame:{kind:'agent',anchor:'agent-access'", self.page)
-        self.assertIn("It gets numbers only, never your prompts or code.", self.page)
-        for tool in ("mcp__tokenmeter__check", "mcp__tokenmeter__usage",
-                     "mcp__tokenmeter__capabilities"):
-            self.assertNotIn(tool, self.page)
-        self.assertLess(self.page.index("id=view-capabilities"), self.page.index("id=view-settings"))
-        self.assertLess(self.page.index("id=view-settings"), self.page.index("id=agent-access"))
-        self.assertIn("setHashRoute('settings')", self.page)
-        self.assertIn("tm_agent_discovery_dismissed", self.page)
-        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
-            "</div>\n</div>\n<dialog class=commandPalette", 1
-        )[0]
-        self.assertLess(settings.index("data-settings-target=agent-access"),
-                        settings.index("data-settings-target=model-pricing-settings"))
-        self.assertLess(settings.index("data-settings-target=model-pricing-settings"),
-                        settings.index("data-settings-target=delivery-settings"))
-        self.assertLess(settings.index("id=agent-access"),
-                        settings.index("id=model-pricing-settings"))
-        self.assertLess(settings.index("id=model-pricing-settings"),
-                        settings.index("id=delivery-settings"))
-
-    def test_settings_has_no_agent_defaults_surface_or_loader(self):
-        settings = self.page.split("<div class=view id=view-settings>", 1)[1].split(
-            "</div>\n</div>\n<dialog class=commandPalette", 1
-        )[0]
-        self.assertNotIn("id=agent-default-settings", settings)
-        self.assertNotIn("id=agent-defaults", settings)
-        self.assertNotIn("function renderAgentDefaults", self.page)
-        self.assertNotIn("function loadAgentDefaultSettings", self.page)
-        self.assertNotIn("/settings/agent-defaults", self.page)
-
-    def test_agent_access_status_loads_only_when_settings_is_opened(self):
-        startup = self.page[self.page.rindex(
-            "setInterval(refreshLiveState,LIVE_STATE_POLL_MS);"
-        ):]
-        self.assertNotIn("loadAgentAccess();", startup)
-        settings_route = self.page.split(
-            "if(h==='settings'||h==='model-pricing'", 1
-        )[1].split("if(!h||h==='session')", 1)[0]
-        self.assertIn("loadAgentAccess();", settings_route)
-
-    def test_token_chart_fills_use_the_same_colors_as_legend_and_tooltip(self):
-        self.assertIn("const band=(top,bottom,col,opacity)=>", self.page)
-        self.assertIn(
-            "band(cacheRead,zeros,CHART.cacheRead,.18)+"
-            "band(cacheTop,cacheRead,CHART.cacheWrite,.18)",
-            self.page,
-        )
-        self.assertIn('fill-opacity="${opacity}"', self.page)
-        self.assertNotIn("cacheReadFill", self.page)
-        self.assertNotIn("cacheWriteFill", self.page)
-
-    def test_agent_access_conflict_has_an_explicit_repair_flow(self):
-        for marker in (
-            "row.conflict?'Repair':'Connect'",
-            "const repairing=!!(enabled&&row.conflict)",
-            "Replace only the existing user-level tokenmeter entry",
-            "`${row.disconnect_command}\\n${row.connect_command}`",
-            "repair:repairing",
-            "result.repaired?'Connection repaired'",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("Resolve manually", self.page)
-        self.assertNotIn("||row.conflict", self.page[self.page.index("const disabled="):self.page.index("const detail=", self.page.index("const disabled="))])
-
-    def test_learn_omits_removed_model_and_agent_guidance(self):
-        for marker in (
-            "id=learn-model-guide",
-            "Compare model speed without fooling yourself",
-            "Should I keep this run going?",
-            "Why was the last phase expensive?",
-            "What should I change before the next phase?",
-        ):
-            self.assertNotIn(marker, self.page)
-
-    def test_model_comparison_has_tooltips(self):
-        for marker in (
-            "modelHelp", "id=m-coverage", 'aria-label="Output timing coverage"',
-            "same model can appear more than once",
-            "A ratio above 1 favors the named faster runtime",
-            "The median is primary because the average can be pulled upward",
-            "95% confidence interval", "Matched pace",
-            "model runtime", "Observed output pace", "Typical workload (approximate shape, not semantic difficulty)",
-            "Typical wait", "semantic difficulty",
-            "The 95% confidence interval crosses 1.00",
-            "$('m-coverage').setAttribute('aria-valuenow'",
-            "stripNativeFieldTipTitles", "removeAttribute('title')",
-            "aria-description",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn('<div class=filterControl><span>Models</span>', self.page)
-        self.assertIn('<label class=filterControl><span>History</span>', self.page)
-        self.assertNotIn("Select model-runtime histories, not just model names.", self.page)
-        self.assertNotIn("Limits tokens, executions, workload summaries", self.page)
-
-    def test_custom_fieldtips_remove_delayed_native_tooltips_globally(self):
-        self.assertIn("root.querySelectorAll('.fieldtip[title]')", self.page)
-        self.assertIn("stripNativeFieldTipTitles();", self.page)
-        self.assertIn('return `class=fieldtip tabindex=0 aria-description="${safe}" data-tip="${safe}"`', self.page)
-        self.assertNotIn('return `class=fieldtip tabindex=0 title="${safe}"', self.page)
-
-    def test_spend_uses_session_routing_without_restoring_daily_wait_health(self):
-        self.assertNotIn("Tool-result health", self.page)
-        self.assertNotIn("Tool results need attention", self.page)
-        self.assertNotIn("function openDailySession", self.page)
-        self.assertNotIn("data-daily-session", self.page)
-        self.assertIn("function renderSpend(xs)", self.page)
-        self.assertIn("data-spend-session=", self.page)
-        self.assertIn("if(row)selectSession(row.dataset.id)", self.page)
-
-    def test_selected_session_stays_pinned_while_other_live_state_changes(self):
-        self.assertIn("function followLatestSession", self.page)
-        self.assertIn("function refreshSelectedSession", self.page)
-        self.assertIn(
-            "fetchLiveJson('/session?id='+encodeURIComponent(id)+'&live=1',LIVE_XSESSION.session,'Session')",
-            self.page,
-        )
-        self.assertLess(
-            self.page.index("const LIVE_XSESSION="),
-            self.page.index("applyLocationRoute();"),
-        )
-        self.assertLess(
-            self.page.index("selectedPollId=''"),
-            self.page.index("applyLocationRoute();"),
-        )
-        self.assertIn("const SELECTED_SESSION_POLL_MS=2000", self.page)
-        self.assertIn(
-            "setInterval(()=>refreshSelectedSession({show:true}),SELECTED_SESSION_POLL_MS)",
-            self.page,
-        )
-        self.assertIn("pinned=id;\n if(show)applyHashRoute();\n return refreshSelectedSession", self.page)
-        self.assertIn(
-            "const sessionSurfaceActive=$('view-session').classList.contains('on');\n"
-            " if(!pinned&&sessionSurfaceActive&&currentPanel!=='sessions')renderSession(LATEST);",
-            self.page,
-        )
-        self.assertNotIn("if(LATEST&&id===stateSessionId(LATEST))", self.page)
-        self.assertNotIn("if(pinned&&pinned===stateSessionId(LATEST))", self.page)
-
-    def test_sessions_overview_is_bounded_routed_and_accessible(self):
-        for marker in (
-            "id=preview-surface-sessions",
-            "id=current-session-grid",
-            "function renderCurrentSessions",
-            "function openCurrentSessions",
-            "'/#sessions'",
-            "data-current-session-id",
-            '<h1 id=session-page-title>Sessions</h1>',
-            'class=currentSessionsCount id=current-session-count-label',
-            "filterView.countLabel",
-            "Working",
-            "Waiting",
-            "Recent",
-            "provider-claude",
-            "provider-codex",
-            "provider-cursor",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("const CURRENT_PANEL_KEYS=['sessions','run'];",
-                      self.page)
-        self.assertNotIn("data-current-panel=sessions", self.page)
-        self.assertNotIn('id=current-tabs', self.page)
-        self.assertRegex(self.page, r"id=tab-session[^>]*>.*?<span class=tabLabel>Sessions</span>")
-        self.assertIn("if(h==='sessions'||h==='sessions-all'||h==='sessions-compare'||h==='current-sessions')", self.page)
-        self.assertIn("history.replaceState(null,'','/#sessions')", self.page)
-        self.assertIn("function currentSessionModelName", self.page)
-        self.assertIn("row.session_name||row.project||'Untitled session'", self.page)
-        self.assertIn("`${runtime} / ${model}${effort?` ${effort}`:''}`", self.page)
-        self.assertIn("<span>Speed</span>", self.page)
-        self.assertIn("speedFmt(throughput.output_tps)} tok/s", self.page)
-        self.assertIn("<span>Output / $</span>", self.page)
-        self.assertIn("row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar)", self.page)
-        self.assertIn(
-            "const outputPerDollar=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar);",
-            self.page,
-        )
-        self.assertNotIn(
-            "const outputPerDollar=row.output_per_dollar==null?'--':compactNumber(row.output_per_dollar)+(estimate||row.token_estimate?' est':'');",
-            self.page,
-        )
-        self.assertIn(".currentSessionMetrics{display:grid;grid-template-columns:repeat(3,minmax(0,1fr))", self.page)
-        self.assertIn(
-            "body.sessionRoute #view-session .currentSessionMetrics{grid-template-columns:.9fr 1.2fr 1fr;gap:0;margin-top:14px;padding-top:14px",
-            self.page,
-        )
-        self.assertIn(
-            "body.sessionRoute #view-session .currentSessionMetric{padding:0 14px",
-            self.page,
-        )
-        self.assertNotIn("id=unpin", self.page)
-        self.assertNotIn("Back to current sessions", self.page)
-        self.assertNotIn("Back to all sessions", self.page)
-        self.assertNotIn("$('unpin')", self.page)
-        self.assertNotIn("Reorder: drag or ⌥ + arrows", self.page)
-        self.assertNotIn("currentSessionsMoveHint", self.page)
-        self.assertNotIn("currentSessionOpen", self.page)
-        self.assertNotIn(">Open →</span>", self.page)
-
-    def test_current_session_activity_filters_are_accessible_and_wired(self):
-        for marker in (
-            'id=current-session-activity-filters role=group aria-label="Filter current sessions by activity"',
-            'data-current-activity-filter=all aria-pressed=true>All</button>',
-            'data-current-activity-filter=working aria-pressed=false>Working</button>',
-            'data-current-activity-filter=recent aria-pressed=false>Recent</button>',
-            "let currentSessionRuntimeFilter='all',currentSessionActivityFilter='all';",
-            "function renderCurrentSessionActivityFilters(selection)",
-            "currentSessionFilterView(orderedRows,currentSessionRuntimeFilter,currentSessionActivityFilter)",
-            "renderCurrentSessionActivityFilters(filterView.activitySelection);",
-            "currentSessionActivityFilter=button.dataset.currentActivityFilter||'all';",
-            "currentSessionsFilteredEmptyHtml(filterView.activitySelection)",
-            "function keepCurrentSessionFilterFocusVisible(event)",
-            "button.scrollIntoView({block:'nearest',inline:'nearest'});",
-            "currentSessionRuntimeFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);",
-            "currentSessionActivityFilters.addEventListener('focusin',keepCurrentSessionFilterFocusVisible);",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn(
-            "$('current-session-activity-filters').hidden=true;",
-            self.page,
-        )
-        for marker in (
-            ".currentSessionFilterGroups{display:flex;align-items:center;gap:10px;min-width:0;overflow-x:auto",
-            ".currentSessionFilterGroup[hidden]{display:none}",
-            "body.sessionRoute #view-session .currentSessionRuntimeFilters,body.sessionRoute #view-session .currentSessionActivityFilters{display:flex;min-width:0}",
-            "body.sessionRoute #view-session .currentSessionFilterGroups{display:grid;width:100%;max-width:none;overflow:visible}",
-            "body.sessionRoute #view-session .currentSessionFilterGroup{min-width:0;max-width:100%;overflow-x:auto;overflow-y:hidden;scrollbar-width:thin}",
-        ):
-            self.assertIn(marker, self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_session_runtime_view_discovers_filters_and_preserves_valid_selection(self):
-        match = re.search(
-            r"^function currentSessionRuntimeView\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs currentSessionRuntimeView")
-        rows = [
-            {"id": "claude-code", "provider": "claude"},
-            {"id": "codex", "provider": "codex"},
-            {"id": "claude-desktop", "provider": "claude"},
-        ]
-        script = """
-const appFilterGroup=row=>row.provider;
-const appFilterLabel=row=>({claude:'Claude',codex:'Codex',cursor:'Cursor'})[row.provider];
-""" + match.group(0) + "\nconst rows=" + json.dumps(rows) + ";\n" + """
-const all=currentSessionRuntimeView(rows,'all');
-const claude=currentSessionRuntimeView(rows,'claude');
-rows.push({id:'cursor',provider:'cursor'});
-const emerged=currentSessionRuntimeView(rows,'claude');
-const vanished=currentSessionRuntimeView(rows.filter(row=>row.provider!=='claude'),'claude');
-console.log(JSON.stringify({all,claude,emerged,vanished}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["all"], {
-            "options": [
-                {"id": "claude", "label": "Claude", "count": 2},
-                {"id": "codex", "label": "Codex", "count": 1},
-            ],
-            "selection": "all",
-            "rows": rows[:3],
-            "countLabel": "3 active",
-        })
-        self.assertEqual(
-            [row["id"] for row in rendered["claude"]["rows"]],
-            ["claude-code", "claude-desktop"],
-        )
-        self.assertEqual(rendered["claude"]["countLabel"], "2 of 3 active")
-        self.assertEqual(rendered["emerged"]["selection"], "claude")
-        self.assertEqual(
-            rendered["emerged"]["options"],
-            [
-                {"id": "claude", "label": "Claude", "count": 2},
-                {"id": "codex", "label": "Codex", "count": 1},
-                {"id": "cursor", "label": "Cursor", "count": 1},
-            ],
-        )
-        self.assertEqual(rendered["vanished"]["selection"], "all")
-        self.assertEqual(rendered["vanished"]["countLabel"], "2 active")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_session_filter_view_composes_runtime_and_sticky_activity_selection(self):
-        names = (
-            "currentSessionActivity",
-            "currentSessionRuntimeView",
-            "currentSessionFilterView",
-        )
-        functions = []
-        for name in names:
-            match = re.search(
-                rf"^function {name}\(.*?^\}}\n",
-                self.page,
-                re.MULTILINE | re.DOTALL,
-            )
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        rows = [
-            {"id": "claude-working", "provider": "claude", "activity_state": "working"},
-            {"id": "claude-recent", "provider": "claude", "activity_state": "recent"},
-            {"id": "codex-working", "provider": "codex", "activity_state": "working"},
-            {"id": "codex-waiting", "provider": "codex", "activity_state": "waiting"},
-        ]
-        script = """
-const appFilterGroup=row=>row.provider;
-const appFilterLabel=row=>({claude:'Claude',codex:'Codex'})[row.provider];
-""" + "\n".join(functions) + "\nconst rows=" + json.dumps(rows) + ";\n" + """
-const codexWorking=currentSessionFilterView(rows,'codex','working');
-const claudeRecent=currentSessionFilterView(rows,'claude','recent');
-const zeroWorking=currentSessionFilterView(
- rows.filter(row=>row.activity_state!=='working'),
- 'all',
- 'working',
-);
-const invalidActivity=currentSessionFilterView(rows,'all','waiting');
-console.log(JSON.stringify({codexWorking,claudeRecent,zeroWorking,invalidActivity}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(
-            [row["id"] for row in rendered["codexWorking"]["rows"]],
-            ["codex-working"],
-        )
-        self.assertEqual(rendered["codexWorking"]["selection"], "codex")
-        self.assertEqual(rendered["codexWorking"]["activitySelection"], "working")
-        self.assertEqual(rendered["codexWorking"]["countLabel"], "1 of 4 active")
-        self.assertEqual(
-            [row["id"] for row in rendered["claudeRecent"]["rows"]],
-            ["claude-recent"],
-        )
-        self.assertEqual(rendered["zeroWorking"]["rows"], [])
-        self.assertEqual(rendered["zeroWorking"]["activitySelection"], "working")
-        self.assertEqual(rendered["zeroWorking"]["countLabel"], "0 of 2 active")
-        self.assertEqual(rendered["invalidActivity"]["activitySelection"], "all")
-        self.assertEqual(rendered["invalidActivity"]["countLabel"], "4 active")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_sessions_filtered_empty_copy_describes_the_selected_activity(self):
-        match = re.search(
-            r"^function currentSessionsFilteredEmptyHtml\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs currentSessionsFilteredEmptyHtml")
-        script = match.group(0) + """
-console.log(JSON.stringify({
- working:currentSessionsFilteredEmptyHtml('working'),
- recent:currentSessionsFilteredEmptyHtml('recent'),
-}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertIn("No working sessions right now", rendered["working"])
-        self.assertIn("No recent sessions right now", rendered["recent"])
-        for html in rendered.values():
-            self.assertIn("Filters are still active", html)
-            self.assertNotIn("Your next live session appears here", html)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_session_keyboard_move_reorders_the_visible_runtime_sequence(self):
-        match = re.search(
-            r"^function currentSessionKeyboardMove\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs currentSessionKeyboardMove")
-        script = match.group(0) + """
-const moved=currentSessionKeyboardMove(
- ['claude-1','codex-1','claude-2'],
- ['claude-1','claude-2'],
- 'claude-1',
- 1,
-);
-console.log(JSON.stringify(moved));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "ids": ["codex-1", "claude-2", "claude-1"],
-            "index": 1,
-            "total": 2,
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_session_keyboard_move_uses_the_combined_filter_sequence(self):
-        names = (
-            "currentSessionActivity",
-            "currentSessionKeyboardMove",
-            "currentSessionRuntimeView",
-            "currentSessionFilterView",
-            "moveCurrentSessionCardBy",
-        )
-        functions = []
-        for name in names:
-            match = re.search(
-                rf"^function {name}\(.*?^\}}\n",
-                self.page,
-                re.MULTILINE | re.DOTALL,
-            )
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        script = """
-const appFilterGroup=row=>row.provider;
-const appFilterLabel=row=>({claude:'Claude',codex:'Codex'})[row.provider];
-const LATEST={xsession:{current_sessions:[
- {id:'claude-working',provider:'claude',activity_state:'working'},
- {id:'codex-working',provider:'codex',activity_state:'working'},
- {id:'claude-recent',provider:'claude',activity_state:'recent'},
-]}};
-const currentSessionRuntimeFilter='claude';
-const currentSessionActivityFilter='working';
-const orderedCurrentSessionRows=rows=>rows;
-let saved=null;
-const setCurrentSessionOrder=ids=>{saved=ids};
-""" + "\n".join(functions) + """
-const result=moveCurrentSessionCardBy('claude-working',1);
-console.log(JSON.stringify({result,saved}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {"result": None, "saved": None})
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_session_ids_match_detects_a_stale_filtered_grid(self):
-        match = re.search(
-            r"^function currentSessionIdsMatch\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs currentSessionIdsMatch")
-        script = match.group(0) + """
-const stable=currentSessionIdsMatch(
- ['claude-1','claude-2'],
- [{id:'claude-1'},{id:'claude-2'}],
-);
-const stale=currentSessionIdsMatch(
- ['claude-1','claude-2'],
- [{id:'codex-1'}],
-);
-console.log(JSON.stringify({stable,stale}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertTrue(rendered["stable"])
-        self.assertFalse(rendered["stale"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_current_session_filter_focus_survives_emergence_and_falls_back_on_disappearance(self):
-        match = re.search(
-            r"^function currentSessionFilterFocusTarget\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs currentSessionFilterFocusTarget")
-        script = match.group(0) + """
-const emerged=currentSessionFilterFocusTarget(
- {selection:'claude',options:[{id:'claude'},{id:'codex'},{id:'cursor'}]},
- 'claude',
-);
-const vanished=currentSessionFilterFocusTarget(
- {selection:'all',options:[{id:'codex'}]},
- 'claude',
-);
-console.log(JSON.stringify({emerged,vanished}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["emerged"], "claude")
-        self.assertEqual(rendered["vanished"], "all")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_flow_snapshot_uses_real_activity_and_marks_only_new_arrivals(self):
-        match = re.search(
-            r"^function sessionFlowSnapshot\(.*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs a pure sessionFlowSnapshot")
-        script = match.group(0) + """
-const unavailable=sessionFlowSnapshot(undefined,[],false);
-const first=sessionFlowSnapshot([
- {id:'working',activity_state:'working'},
- {id:'waiting',activity_state:'waiting'},
- {id:'recent',activity_state:'recent'},
-],[],false);
-const next=sessionFlowSnapshot([
- {id:'waiting',activity_state:'waiting'},
- {id:'arriving',activity_state:'working'},
-],first.ids,true);
-const idle=sessionFlowSnapshot([],next.ids,true);
-console.log(JSON.stringify({unavailable,first,next,idle}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["unavailable"], {
-            "evidence": "unavailable", "mode": "idle", "count": 0,
-            "working": 0, "waiting": 0, "recent": 0,
-            "ids": [], "arriving": [],
-        })
-        self.assertEqual(rendered["first"], {
-            "evidence": "available", "mode": "working", "count": 3,
-            "working": 1, "waiting": 1, "recent": 1,
-            "ids": ["working", "waiting", "recent"], "arriving": [],
-        })
-        self.assertEqual(rendered["next"], {
-            "evidence": "available", "mode": "working", "count": 2,
-            "working": 1, "waiting": 1, "recent": 0,
-            "ids": ["waiting", "arriving"], "arriving": ["arriving"],
-        })
-        self.assertEqual(rendered["idle"], {
-            "evidence": "available", "mode": "idle", "count": 0,
-            "working": 0, "waiting": 0, "recent": 0,
-            "ids": [], "arriving": [],
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_page_signal_presentations_share_one_animation_timeline(self):
-        functions = []
-        for name in ("pageSignalTiming", "sessionSignalPresentation", "pageSignalPresentation"):
-            match = re.search(
-                rf"^function {name}\(.*?^\}}\n",
-                self.page,
-                re.MULTILINE | re.DOTALL,
-            )
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        script = """
-let pageSignalClockStartedAt=1000;
-let clockNow=11000;
-const performance={now:()=>clockNow};
-""" + "\n".join(functions) + """
-let latestSessionSignalSnapshot={evidence:'available',mode:'working'};
-const pageSignalReducedMotionQuery={matches:false};
-const signals=['sessions','spend','models','capabilities','efficiency','learn','settings'];
-const routes=Object.fromEntries(signals.map(signal=>[
- signal,pageSignalPresentation({dataset:{pageSignal:signal}}),
-]));
-const states={};
-for(const mode of ['working','waiting','recent','idle']){
- states[mode]=sessionSignalPresentation({evidence:'available',mode},false);
-}
-states.unavailable=sessionSignalPresentation({evidence:'unavailable',mode:'idle'},false);
-latestSessionSignalSnapshot={evidence:'unavailable',mode:'idle'};
-const unavailable=pageSignalPresentation({dataset:{pageSignal:'sessions'}});
-clockNow=17000;
-latestSessionSignalSnapshot={evidence:'available',mode:'working'};
-const continued=Object.fromEntries(signals.map(signal=>[
- signal,pageSignalPresentation({dataset:{pageSignal:signal}}),
-]));
-pageSignalReducedMotionQuery.matches=true;
-const reduced=Object.fromEntries(signals.map(signal=>[
- signal,pageSignalPresentation({dataset:{pageSignal:signal}}),
-]));
-console.log(JSON.stringify({routes,states,unavailable,continued,reduced}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        timing = {
-            "heroSpeed": 0.018,
-            "heroFrame": 180,
-            "borderSpeed": 0.016,
-            "borderFrame": 9160,
-        }
-        for presentation in rendered["routes"].values():
-            self.assertEqual(
-                {key: presentation[key] for key in timing},
-                timing,
-            )
-        states = rendered["states"]
-        for mode in ("working", "waiting", "recent", "idle"):
-            self.assertEqual({key: states[mode][key] for key in timing}, timing)
-        self.assertGreater(states["working"]["heroStrength"], states["idle"]["heroStrength"])
-        self.assertEqual(rendered["unavailable"]["heroSpeed"], 0)
-        self.assertEqual(rendered["unavailable"]["borderSpeed"], 0)
-        self.assertEqual(rendered["unavailable"]["heroFrame"], timing["heroFrame"])
-        self.assertEqual(rendered["unavailable"]["borderFrame"], timing["borderFrame"])
-        continued_timing = {
-            "heroSpeed": 0.018,
-            "heroFrame": 288,
-            "borderSpeed": 0.016,
-            "borderFrame": 9256,
-        }
-        for presentation in rendered["continued"].values():
-            self.assertEqual(
-                {key: presentation[key] for key in continued_timing},
-                continued_timing,
-            )
-        for presentation in rendered["reduced"].values():
-            self.assertEqual(presentation["heroSpeed"], 0)
-            self.assertEqual(presentation["borderSpeed"], 0)
-            self.assertEqual(presentation["heroFrame"], continued_timing["heroFrame"])
-            self.assertEqual(presentation["borderFrame"], continued_timing["borderFrame"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_page_signal_route_change_disposes_a_partially_mounted_effect(self):
-        page_path = Path(DASHBOARD_PAGE)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{
- let start=page.indexOf(`function ${{name}}(`);
- if(start<0)throw new Error(name);
- if(page.slice(start-6,start)==='async ')start-=6;
- let i=page.indexOf('{{',start),depth=0;
- for(;i<page.length;i++){{
-  if(page[i]==='{{')depth++;
-  else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);
- }}
-}}
-class El{{
- constructor(name){{this.name=name;this.dataset={{}};this.children=[];this.isConnected=true;this.className='';}}
- querySelector(selector){{return this.children.find(child=>selector.includes(child.className))||null;}}
- appendChild(child){{this.children.push(child);return child;}}
- append(...children){{this.children.push(...children);}}
- setAttribute(){{}}
- replaceChildren(){{this.children=[];}}
- closest(selector){{return selector.includes('sessionDetail')?null:this;}}
-}}
-let currentHead=null;
-const document={{querySelector(){{return currentHead;}},createElement(){{return new El('created');}}}};
-let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
-let activePageSignalMounting=false,activePageSignalGeneration=0,pageEffectsDisabled=false;
-let live=[];
-const borderResolvers=[];
-function handle(label){{
- live.push(label);
- return {{update(){{}},dispose(){{live=live.filter(value=>value!==label);}}}};
-}}
-let currentMount='A';
-function loadPageEffectsModule(){{
- return Promise.resolve({{
-  mountDitherField(){{return Promise.resolve(handle(`hero:${{currentMount}}`));}},
-  mountPulsingBorder(){{
-   const label=`border:${{currentMount}}`;
-   return new Promise(resolve=>borderResolvers.push(()=>resolve(handle(label))));
-  }},
- }});
-}}
-function pageSignalPresentation(){{return {{}};}}
-eval(extract('ensurePageSignalHosts'));
-eval(extract('disposeActivePageSignalEffects'));
-if(page.includes('function pageSignalHandle('))eval(extract('pageSignalHandle'));
-eval(extract('syncActivePageSignalEffects'));
-(async()=>{{
- const a=new El('A'),b=new El('B');
- a.dataset.pageSignal='models';b.dataset.pageSignal='spend';
- currentHead=a;currentMount='A';
- const mountA=syncActivePageSignalEffects();
- await Promise.resolve();await Promise.resolve();await Promise.resolve();
- const afterAHero=[...live];
- currentHead=b;currentMount='B';
- const mountB=syncActivePageSignalEffects();
- await Promise.resolve();await Promise.resolve();await Promise.resolve();
- const afterRouteChange=[...live];
- borderResolvers.shift()();
- await Promise.resolve();await Promise.resolve();
- const afterStaleBorder=[...live];
- borderResolvers.shift()();
- await Promise.all([mountA,mountB]);
- console.log(JSON.stringify({{afterAHero,afterRouteChange,afterStaleBorder,complete:live}}));
-}})().catch(error=>{{console.error(error);process.exitCode=1;}});
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["afterAHero"], ["hero:A"])
-        self.assertEqual(rendered["afterRouteChange"], ["hero:B"])
-        self.assertEqual(rendered["afterStaleBorder"], ["hero:B"])
-        self.assertEqual(rendered["complete"], ["hero:B", "border:B"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_stale_same_header_mount_cannot_clear_the_new_ready_marker(self):
-        page_path = Path(DASHBOARD_PAGE)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{
- let start=page.indexOf(`function ${{name}}(`);
- if(start<0)throw new Error(name);
- if(page.slice(start-6,start)==='async ')start-=6;
- let i=page.indexOf('{{',start),depth=0;
- for(;i<page.length;i++){{
-  if(page[i]==='{{')depth++;
-  else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);
- }}
-}}
-class El{{
- constructor(name){{this.name=name;this.dataset={{}};this.children=[];this.isConnected=true;this.className='';}}
- querySelector(selector){{
-  const wanted=selector.slice(1);
-  for(const child of this.children){{
-   if(child.className===wanted)return child;
-   const nested=child.querySelector(selector);
-   if(nested)return nested;
-  }}
-  return null;
- }}
- appendChild(child){{this.children.push(child);return child;}}
- append(...children){{this.children.push(...children);}}
- setAttribute(){{}}
- replaceChildren(){{this.children=[];}}
- closest(selector){{return selector.includes('sessionDetail')?null:this;}}
-}}
-let currentHead=null,currentMount='',live=[],borderQueue=[];
-const document={{querySelector(){{return currentHead;}},createElement(){{return new El('created');}}}};
-let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
-let activePageSignalMounting=false,activePageSignalGeneration=0,pageEffectsDisabled=false;
-function handle(label,host){{
- live.push(label);host.dataset.pageEffect='ready';let disposed=false;
- return {{
-  update(){{}},
-  dispose(){{
-   if(!disposed){{disposed=true;live=live.filter(value=>value!==label);}}
-   delete host.dataset.pageEffect;
-  }},
- }};
-}}
-function loadPageEffectsModule(){{
- return Promise.resolve({{
-  mountDitherField(host){{return Promise.resolve(handle(`hero:${{currentMount}}`,host));}},
-  mountPulsingBorder(host){{
-   const label=`border:${{currentMount}}`;
-   return new Promise(resolve=>borderQueue.push({{label,resolve:()=>resolve(handle(label,host))}}));
-  }},
- }});
-}}
-function pageSignalPresentation(){{return {{}};}}
-eval(extract('ensurePageSignalHosts'));
-eval(extract('disposeActivePageSignalEffects'));
-if(page.includes('function pageSignalHandle('))eval(extract('pageSignalHandle'));
-eval(extract('syncActivePageSignalEffects'));
-const ticks=async(count=5)=>{{while(count--)await Promise.resolve();}};
-(async()=>{{
- const a=new El('A'),b=new El('B');
- a.dataset.pageSignal='models';b.dataset.pageSignal='spend';
- currentHead=a;currentMount='A1';const mountA1=syncActivePageSignalEffects();await ticks();
- currentHead=b;currentMount='B';const mountB=syncActivePageSignalEffects();await ticks();
- currentHead=a;currentMount='A2';const mountA2=syncActivePageSignalEffects();await ticks();
- const aHero=a.querySelector('.pageDither');
- const before={{live:[...live],heroState:aHero.dataset.pageEffect||null}};
- borderQueue.find(row=>row.label==='border:A1').resolve();await mountA1;await ticks();
- const afterStale={{live:[...live],heroState:aHero.dataset.pageEffect||null}};
- borderQueue.find(row=>row.label==='border:B').resolve();await mountB;await ticks();
- borderQueue.find(row=>row.label==='border:A2').resolve();await mountA2;
- console.log(JSON.stringify({{before,afterStale,complete:{{live,heroState:aHero.dataset.pageEffect||null}}}}));
-}})().catch(error=>{{console.error(error);process.exitCode=1;}});
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["before"], {
-            "live": ["hero:A2"], "heroState": "ready",
-        })
-        self.assertEqual(rendered["afterStale"], {
-            "live": ["hero:A2"], "heroState": "ready",
-        })
-        self.assertEqual(rendered["complete"], {
-            "live": ["hero:A2", "border:A2"], "heroState": "ready",
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_shared_border_readiness_cancels_stale_mounts_before_construction(self):
-        page_path = Path(DASHBOARD_PAGE)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{
- let start=page.indexOf(`function ${{name}}(`);
- if(start<0)throw new Error(name);
- if(page.slice(start-6,start)==='async ')start-=6;
- let i=page.indexOf('{{',start),depth=0;
- for(;i<page.length;i++){{
-  if(page[i]==='{{')depth++;
-  else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);
- }}
-}}
-class El{{
- constructor(name){{this.name=name;this.dataset={{}};this.children=[];this.isConnected=true;this.className='';}}
- querySelector(selector){{
-  const wanted=selector.slice(1);
-  for(const child of this.children){{
-   if(child.className===wanted)return child;
-   const nested=child.querySelector(selector);
-   if(nested)return nested;
-  }}
-  return null;
- }}
- appendChild(child){{this.children.push(child);return child;}}
- append(...children){{this.children.push(...children);}}
- setAttribute(){{}}
- replaceChildren(){{this.children=[];}}
- closest(selector){{return selector.includes('sessionDetail')?null:this;}}
-}}
-let currentHead=null,currentMount='',live=[];
-let releaseSharedBorder;
-const sharedBorderReady=new Promise(resolve=>{{releaseSharedBorder=resolve;}});
-const document={{querySelector(){{return currentHead;}},createElement(){{return new El('created');}}}};
-let activePageSignalHead=null,activePageHeroHandle=null,activePageBorderHandle=null;
-let activePageSignalMounting=false,activePageSignalGeneration=0,pageEffectsDisabled=false;
-function handle(label,host){{
- live.push(label);host.dataset.pageEffect='ready';host.paperShaderMount=label;let disposed=false;
- return {{
-  update(){{}},
-  dispose(){{
-   if(disposed)throw new Error(`double dispose ${{label}}`);
-   disposed=true;live=live.filter(value=>value!==label);
-   delete host.dataset.pageEffect;delete host.paperShaderMount;
-  }},
- }};
-}}
-function loadPageEffectsModule(){{
- return Promise.resolve({{
-  mountDitherField(host){{return Promise.resolve(handle(`hero:${{currentMount}}`,host));}},
-  async mountPulsingBorder(host,presentation,isCurrent){{
-   const label=`border:${{currentMount}}`;
-   await sharedBorderReady;
-   if(isCurrent&&!isCurrent())return null;
-   return handle(label,host);
-  }},
- }});
-}}
-function pageSignalPresentation(){{return {{}};}}
-eval(extract('ensurePageSignalHosts'));
-eval(extract('disposeActivePageSignalEffects'));
-if(page.includes('function pageSignalHandle('))eval(extract('pageSignalHandle'));
-eval(extract('syncActivePageSignalEffects'));
-const ticks=async(count=8)=>{{while(count--)await Promise.resolve();}};
-(async()=>{{
- const a=new El('A'),b=new El('B');
- a.dataset.pageSignal='models';b.dataset.pageSignal='spend';
- currentHead=a;currentMount='A1';const mountA1=syncActivePageSignalEffects();await ticks();
- currentHead=b;currentMount='B';const mountB=syncActivePageSignalEffects();await ticks();
- currentHead=a;currentMount='A2';const mountA2=syncActivePageSignalEffects();await ticks();
- const aHero=a.querySelector('.pageDither'),aBorder=a.querySelector('.pageHeroBorder');
- releaseSharedBorder();
- await Promise.all([mountA1,mountB,mountA2]);await ticks();
- console.log(JSON.stringify({{
-  live,
-  heroState:aHero.dataset.pageEffect||null,
-  borderState:aBorder.dataset.pageEffect||null,
-  borderOwner:aBorder.paperShaderMount||null,
-  disabled:pageEffectsDisabled,
- }}));
-}})().catch(error=>{{console.error(error);process.exitCode=1;}});
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered, {
-            "live": ["hero:A2", "border:A2"],
-            "heroState": "ready",
-            "borderState": "ready",
-            "borderOwner": "border:A2",
-            "disabled": False,
-        })
-
-    def test_top_level_pages_share_one_dither_header_system(self):
-        for marker in (
-            "data-page-signal=sessions",
-            "data-page-signal=spend",
-            "data-page-signal=models",
-            "data-page-signal=subagents",
-            "data-page-signal=capabilities",
-            "data-page-signal=learn",
-            "data-page-signal=settings",
-            "class=spectrumPageHeadFrame",
-            "class=\"spectrumPageHeadFrame hasPageActions\"",
-            "class=spectrumPageSubtitle",
-            "class=spectrumPageActions",
-            "function ensurePageSignalHosts(head)",
-            "function syncActivePageSignalEffects()",
-            "document.querySelector('.view.on .spectrumPageHead[data-page-signal]')",
-            "activePageHeroHandle?.dispose()",
-            "activePageBorderHandle?.dispose()",
-            "requestAnimationFrame(syncActivePageSignalEffects)",
-            "function syncSessionFlow(snapshot)",
-            "import('/assets/session-effects.js')",
-            "if(label.textContent!==nextLabel)",
-            "data-session-flow",
-            ".currentSessionCard.is-arriving",
-            "@keyframes currentSessionArrive",
-            "@media(prefers-reduced-motion:reduce)",
-        ):
-            self.assertIn(marker, self.page)
-        for rejected_marker in (
-            "sessionFlowField",
-            "sessionFlowLine",
-            "sessionFlowPacket",
-            "currentSessionFlow",
-            "sessionAmbient",
-            "sessionGodRays",
-            "session-god-rays",
-            "sessionPrimaryBorder",
-            "session-primary-border",
-            "syncPrimarySessionBorder",
-            "primaryWorkingSessionId",
-            "neuro-noise",
-            "neuroNoise",
-            "currentSessionStateShift",
-            "<animateMotion",
-            "offset-path:path",
-        ):
-            self.assertNotIn(rejected_marker, self.page)
-
-    def test_top_level_headers_use_fixed_shared_heights_and_concise_subtitles(self):
-        for marker in (
-            ".spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;height:138px",
-            "@media(max-width:900px){.spectrumPageHead{height:126px",
-            "@media(max-width:520px){.spectrumPageHead{height:116px",
-            ".spectrumPageSubtitle{max-width:52ch;margin:6px 0 0;color:var(--dim);font-size:var(--fs-12);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}",
-            ".spectrumPageActions{position:absolute;z-index:5;right:30px;bottom:24px",
-            ".spectrumPageActions{position:static;display:flex;width:100%;max-width:none",
-            "Last 30 minutes",
-            "Track the cost of your custom agents.",
-            "Tools, MCP servers, and skills.",
-            "What the spend went into.",
-            "Pushed code &times; covered spend &middot; <span class=fieldtip id=d-caveat",
-            "Spend tokens like money. Measure what you get back.",
-            "Connections, pricing, and updates.",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertEqual(self.page.count("data-page-signal="), 10)
-        self.assertEqual(self.page.count("class=spectrumPageSubtitle"), 7)
-        for removed in ("Live local traces · last 30 minutes.", "Estimated agent spend over time.", "Cost, speed, and context.", "Local token efficiency."):
-            self.assertNotIn(removed, self.page)
-        self.assertNotIn(".spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;min-height:138px", self.page)
-
-    def test_shared_header_effect_adapter_exposes_generic_mounts(self):
-        for marker in (
-            "orderedDitherRainFragmentShader",
-            "export async function mountDitherField",
-            "export async function mountPulsingBorder(element, presentation, isCurrent = () => true)",
-            "if (!isCurrent()) return null;",
-        ):
-            self.assertIn(marker, self.session_effects)
-        self.assertNotIn("export async function mountSessionHero", self.session_effects)
-        self.assertNotIn("export async function mountSessionBorder", self.session_effects)
-
-    def test_desktop_action_headers_keep_titles_inside_their_text_slot(self):
-        titles = re.findall(
-            r'class="spectrumPageHeadFrame hasPageActions".*?<h1(?:\s[^>]*)?>([^<]+)</h1>',
-            self.page,
-            re.DOTALL,
-        )
-        self.assertEqual(
-            titles, ["Sessions", "Subagents", "Models", "Spend", "Efficiency", "Work", "Git", "Learn"],
-        )
-        self.assertTrue(all(len(title) <= 12 for title in titles))
-
-    def test_mobile_header_action_rows_scroll_instead_of_stacking(self):
-        for marker in (
-            ".spectrumPageActions .modelControls{display:grid;width:100%;grid-template-columns:repeat(3,minmax(0,1fr))",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("data-spend-range", self.page)
-        self.assertNotIn(".spendRangeControls .seg", self.page)
-
-    def test_session_shader_border_tracks_the_hero_edges(self):
-        for marker in (
-            "u_marginLeft: 0.002",
-            "u_marginRight: 0.002",
-            "u_marginTop: 0.002",
-            "u_marginBottom: 0.002",
-        ):
-            self.assertIn(marker, self.session_effects)
-        self.assertNotIn("u_marginLeft: 0.014", self.session_effects)
-        self.assertNotIn("u_marginTop: 0.024", self.session_effects)
-
-    def test_session_dither_uses_downward_ordered_pixel_streams(self):
-        for marker in (
-            "orderedDitherRainFragmentShader",
-            "const int bayer4x4[16]",
-            "float fallingPhase",
-            "cell.y + u_time * speed",
-            "float streamHead",
-        ):
-            self.assertIn(marker, self.session_effects)
-        self.assertNotIn("DitheringShapes.", self.session_effects)
-
-    def test_collapsed_navigation_keeps_session_scope_labels_visible(self):
-        self.assertIn(
-            "body.spectrumApp .top .brandCopy,body.spectrumApp .top .tabLabel{display:none}",
-            self.page,
-        )
-        self.assertIn("body.spectrumApp .top .brandCopy{display:grid}", self.page)
-        self.assertIn("body.spectrumApp .top .tabLabel{display:inline}", self.page)
-        self.assertNotIn(".brandCopy,.tabLabel,.tabShortcut{display:none}", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_model_board_pushback_reads_work_labels_for_the_same_window(self):
-        script = f"""
-const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const constLine=name=>page.slice(page.indexOf(`const ${{name}}=`),page.indexOf(';',page.indexOf(`const ${{name}}=`))+1);
-const esc=s=>String(s),f=v=>String(v),pct=v=>Math.round(v*100)+'%';
-let modelRange='30',modelProject='p1',LATEST=null,rerenders=0,urls=[],payload={{}};
-const rerenderActiveModelStats=()=>{{rerenders++;}};
-const fetch=async url=>{{urls.push(url);const status=globalThis.statusOverride||200;return {{ok:status<400,status,json:async()=>payload}};}};
-eval(constLine('MODEL_PUSHBACK_PERIODS').replace(/^const /,'var '));
-let modelPushback={{key:'',state:'idle',rates:new Map()}},modelPushbackRequest=0;
-eval(['modelPushbackKey','modelPushbackFor','modelPushbackCell','modelBoardValue'].map(extract).join('\\n')+'\\nasync '+extract('loadModelPushback'));
-const group=(model,runtime)=>({{model,runtime,variants:[{{}}],window:{{}}}});
-(async()=>{{
- const out={{}};
- payload={{ok:true,settings:{{enabled:true}},insights:{{rework:{{models:[{{model:'opus',runtime:'Claude Code',rate:.14,samples:409,few_samples:false}},{{model:'mini',runtime:'Codex',rate:.25,samples:8,few_samples:true}}]}}}}}};
- LATEST={{}};await loadModelPushback();
- out.url=urls[0];out.rerenders=rerenders;
- out.ready=modelPushbackCell(group('opus','Claude Code'));
- out.few=modelPushbackCell(group('mini','Codex'));
- out.otherRuntime=modelPushbackCell(group('opus','Codex'));
- out.variant=modelPushbackCell({{model:'opus',runtime:'Claude Code',window:{{}}}});
- out.sortValue=modelBoardValue(group('opus','Claude Code'),'pushback');
- await loadModelPushback();out.cached=urls.length;
- modelRange='yesterday';await loadModelPushback();
- out.unsupported=modelPushbackCell(group('opus','Claude Code'));out.unsupportedFetches=urls.length;
- modelRange='90';payload={{ok:true,settings:{{enabled:false}},insights:{{rework:{{models:[]}}}}}};await loadModelPushback();
- out.url90=urls[urls.length-1];out.off=modelPushbackCell(group('opus','Claude Code'));
- // Turning Work insights on shows up after the cache expires instead of sticking.
- payload={{ok:true,settings:{{enabled:true}},insights:{{rework:{{models:[{{model:'opus',runtime:'Claude Code',rate:.5,samples:40,few_samples:false}}]}}}}}};
- await loadModelPushback();out.beforeExpiry=urls.length;
- modelPushback.at-=MODEL_PUSHBACK_TTL_MS+1;await loadModelPushback();
- out.afterExpiry=urls.length;out.refreshed=modelPushbackCell(group('opus','Claude Code'));
- modelRange='30';modelProject='';modelPushback.key='';
- payload={{ok:false,error:'Work insights are available on macOS only.'}};
- globalThis.statusOverride=404;await loadModelPushback();out.unsupportedHost=modelPushbackCell(group('opus','Claude Code'));
- process.stdout.write(JSON.stringify(out));
-}})();
-"""
-        out = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
-        self.assertEqual(out["url"], "/work?months=30d&project=p1")
-        self.assertEqual(out["rerenders"], 1)
-        self.assertEqual(out["ready"], '<td class="num mono" title="57 of 409 labeled follow-ups pushed back · local model estimate">14%</td>')
-        self.assertIn(">25%*</td>", out["few"])
-        self.assertIn("modelMuted", out["few"])
-        # Models are scoped by runtime: the same name in another client has its own history.
-        self.assertIn(">--</td>", out["otherRuntime"])
-        self.assertEqual(out["variant"], '<td class="num modelMuted"></td>')
-        self.assertEqual(out["sortValue"], 0.14)
-        self.assertEqual(out["cached"], 1)
-        self.assertEqual(out["unsupportedFetches"], 1)
-        self.assertIn("not available for Yesterday or Last month", out["unsupported"])
-        self.assertEqual(out["url90"], "/work?months=90d&project=p1")
-        self.assertIn("Turn on Work insights", out["off"])
-        self.assertEqual(out["afterExpiry"], out["beforeExpiry"] + 1)
-        self.assertIn(">50%</td>", out["refreshed"])
-        self.assertIn("not available on this system", out["unsupportedHost"])
-
-    def test_current_day_summary_compares_partial_days_without_estimate_suffix(self):
-        script = f"""
-const fs=require('fs');const page=fs.readFileSync({json.dumps(str(Path(DASHBOARD_PAGE)))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const nodes={{}};const $=id=>nodes[id]||(nodes[id]={{textContent:'',classList:{{toggle(){{}},add(){{}},remove(){{}}}},setAttribute(){{}},removeAttribute(){{}},dataset:{{}}}});
-const money=v=>'$'+Number(v||0).toFixed(2),f=v=>String(v),countWord=(n,w)=>n===1?w:w+'s';
-const metricAvailable=(row,k)=>row.availability?.[k]!==false,metricPartial=(row,k)=>Boolean(row.partial?.[k]);
-const hasLocalEstimate=row=>row.basis==='mixed',estimateSuffix=row=>row.basis==='mixed'?' incl. est':'';
-const setCostValue=(id,text)=>{{$(id).textContent=text;}};
-eval(['localDayKey','dailyDeltaLabel','renderCurrentDaySummary'].map(extract).join('\\n'));
-const day=offset=>{{const d=new Date();d.setHours(12,0,0,0);d.setDate(d.getDate()-offset);return localDayKey(d);}};
-const out={{}};
-for(const [name,todayPartial,yesterdayPartial] of [['both',true,true],['today',true,false],['yesterday',false,true],['none',false,false]]){{
- renderCurrentDaySummary({{daily:[
-  {{day:day(0),cost:57.25,sessions:4,basis:'mixed',partial:{{cost:todayPartial}}}},
-  {{day:day(1),cost:50,sessions:14,partial:{{cost:yesterdayPartial}}}}]}});
- out[name]={{spend:$('current-day-spend').textContent,spendNote:$('current-day-spend-note').textContent,vs:$('current-day-vs-yesterday').textContent,note:$('current-day-vs-yesterday-note').textContent}};
-}}
-const run=(daily,key)=>{{renderCurrentDaySummary({{daily}});out[key]={{vs:$('current-day-vs-yesterday').textContent,note:$('current-day-vs-yesterday-note').textContent,spendNote:$('current-day-spend-note').textContent}};}};
-run([{{day:day(0),cost:5,sessions:1,partial:{{cost:true}}}}],'noYesterday');
-run([{{day:day(0),cost:5,sessions:1}},{{day:day(1),cost:4,sessions:1,availability:{{cost:false}}}}],'yesterdayUnavailable');
-run([{{day:day(1),cost:4,sessions:1}}],'noActivityToday');
-run([{{day:day(0),cost:5,sessions:1}},{{day:day(1),cost:4,sessions:1,basis:'mixed'}}],'yesterdayEstimated');
-process.stdout.write(JSON.stringify(out));
-"""
-        out = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
-        for case in (out[name] for name in ("both", "today", "yesterday", "none")):
-            self.assertEqual(case["spend"], "$57.25")
-            self.assertNotEqual(case["vs"], "--")
-        self.assertEqual(out["both"]["note"], "vs $50.00 yesterday · both days partial")
-        self.assertEqual(out["today"]["note"], "vs $50.00 yesterday · today partial")
-        self.assertEqual(out["yesterday"]["note"], "vs $50.00 yesterday · yesterday partial")
-        self.assertEqual(out["none"]["note"], "vs $50.00 yesterday")
-        self.assertEqual(out["none"]["vs"], out["both"]["vs"])
-        # Estimates stay disclosed now that the value has no suffix.
-        self.assertEqual(out["both"]["spendNote"], "Partial billing coverage · includes estimates")
-        self.assertEqual(out["none"]["spendNote"], "API-equivalent estimate · includes local estimates")
-        self.assertEqual(out["yesterdayEstimated"]["note"], "vs $4.00 est yesterday")
-        self.assertEqual((out["noYesterday"]["vs"], out["noYesterday"]["note"]),
-                         ("New", "No recorded spend yesterday · today partial"))
-        self.assertEqual((out["yesterdayUnavailable"]["vs"], out["yesterdayUnavailable"]["note"]),
-                         ("--", "Yesterday cost unavailable"))
-        self.assertEqual((out["noActivityToday"]["vs"], out["noActivityToday"]["note"]),
-                         ("--", "No recorded activity today"))
-
-    def test_sessions_overview_shows_exact_day_spend_summary_and_tokenomics_link(self):
-        for marker in (
-            'class=currentDaySummary aria-label="Today\'s usage summary"',
-            "id=current-day-spend",
-            "id=current-day-sessions",
-            "id=current-day-vs-yesterday",
-            "Spend today",
-            "Sessions today",
-            "Vs yesterday",
-            "function renderCurrentDaySummary(xs)",
-            "if(!Array.isArray(xs?.daily))",
-            "const todayKey=localDayKey(),yesterdayDate=new Date()",
-            "days.find(row=>row.day===todayKey)",
-            "days.find(row=>row.day===yesterdayKey)",
-            'href="https://www.splunk.com/en_us/products/tokenomics.html"',
-            'target=_blank rel="noopener noreferrer"',
-            'aria-label="Get Enterprise Tokenomics from Splunk (opens in a new tab)"',
-            ">Get Enterprise Tokenomics<",
-            "id=current-month-spend",
-            ">View month spend<",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertLess(self.page.index("class=currentDaySummary"), self.page.index("id=current-session-grid"))
-        self.assertIn("renderCurrentDaySummary(state?.xsession);", self.page)
-        self.assertIn(".currentDayReadouts{display:grid;grid-template-columns:repeat(3,minmax(0,1fr))", self.page)
-        self.assertIn(".currentDayMetric:nth-child(3){grid-column:1/-1", self.page)
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_readouts_compare_against_prior_days_and_never_invent_baselines(self):
-        functions = []
-        for name in ("localDayKey", "typicalComparison", "typicalCaption", "readoutScaleHtml", "dailyBaseline"):
-            match = re.search(rf"^function {name}\(.*?^\}}\n", self.page, re.MULTILINE | re.DOTALL)
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        medians = re.search(r"^const medianOf=.*$", self.page, re.MULTILINE)
-        self.assertIsNotNone(medians)
-        script = """
-const esc=s=>String(s??'');
-const money=n=>'$'+Number(n||0).toFixed(2);
-const pct=n=>Math.round((n||0)*100)+'%';
-const waitFmt=n=>Math.round(n)+'s';
-const metricAvailable=(row,metric)=>row?.availability?.[metric]!==false;
-const metricPartial=(row,metric)=>row?.coverage?.[metric]?.complete===false;
-const hasLocalEstimate=row=>row?.usage_basis==='local_estimate';
-""" + medians.group(0) + "\n" + "".join(functions) + """
-const days=[
- {day:'2026-10-13',sessions:9,cost:50},
- {day:'2026-10-12',sessions:2,cost:2},
- {day:'2026-10-11',sessions:4,cost:4},
- {day:'2026-10-10',sessions:6,cost:6,coverage:{cost:{complete:false}}},
- {day:'2026-10-09',sessions:0,cost:0},
- {day:'2026-08-01',sessions:30,cost:900},
-];
-const baseline=dailyBaseline(days,'2026-10-13');
-const burst=dailyBaseline([
- {day:'2026-10-12',sessions:1000,cost:200},
- {day:'2026-10-11',sessions:10,cost:120},
- {day:'2026-10-10',sessions:5,cost:50},
-],'2026-10-13');
-console.log(JSON.stringify({
- baseline,
- burst,
- empty:dailyBaseline([], '2026-10-13'),
- above:typicalCaption(6,2,'your typical day','$2.00'),
- below:typicalCaption(1,4,'your typical day','$4.00'),
- near:typicalCaption(2.1,2,'your typical day','$2.00'),
- none:typicalCaption(0,2,'your typical day','$2.00'),
- missing:typicalCaption(3,null,'your typical day',''),
- scale:readoutScaleHtml({value:6,typical:2,label:'x'}),
- calm:readoutScaleHtml({value:6,typical:2,toned:false}),
- noScale:readoutScaleHtml({value:6,typical:0}),
-}));
-"""
-        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
-        # Today, the partial-cost day, idle days, and days older than 30 days stay out of the baseline.
-        self.assertEqual(result["baseline"]["days"], 3)
-        self.assertEqual(result["baseline"]["typicalCost"], 3)
-        self.assertEqual(result["baseline"]["highCost"], 4)
-        self.assertEqual(result["baseline"]["typicalSessions"], 4)
-        self.assertEqual(result["baseline"]["sessionCost"], 1)
-        # A day of many tiny scripted sessions must not swamp the per-session baseline.
-        self.assertEqual(result["burst"]["sessionCost"], 10)
-        self.assertIsNone(result["empty"]["typicalCost"])
-        self.assertIsNone(result["empty"]["sessionCost"])
-        self.assertEqual(result["above"], "3.0× your typical day of $2.00")
-        self.assertEqual(result["below"], "75% below your typical day of $4.00")
-        self.assertEqual(result["near"], "In line with your typical day of $2.00")
-        self.assertEqual(result["none"], "Nothing yet · your typical day is $2.00")
-        self.assertEqual(result["missing"], "")
-        self.assertIn('data-tone="high"', result["scale"])
-        self.assertIn("--at:90.9%;--typ:30.3%", result["scale"])
-        self.assertIn('data-tone=""', result["calm"])
-        self.assertEqual(result["noScale"], "")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_sessions_month_spend_action_selects_and_persists_month_before_routing(self):
-        match = re.search(
-            r"^function persistSpendRange\(\)[^\n]*\n"
-            r"^function openMonthSpend\(\).*?^\}\n",
-            self.page,
-            re.MULTILINE | re.DOTALL,
-        )
-        self.assertIsNotNone(match, "dashboard needs a month-spend action")
-        script = """
-const SPEND_RANGE_KEY='tm_spend_range_v1';
-let spendRangeChoice='7',spendCustomFrom='2026-08-01',spendCustomTo='2026-08-03';
-const writes=[],routes=[];
-const localStorage={setItem(key,value){writes.push([key,JSON.parse(value)]);}};
-const setHashRoute=route=>routes.push(route);
-""" + match.group(0) + """
-openMonthSpend();
-console.log(JSON.stringify({spendRangeChoice,writes,routes}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        self.assertEqual(json.loads(result.stdout), {
-            "spendRangeChoice": "month",
-            "writes": [["tm_spend_range_v1", {
-                "range": "month",
-                "from": "2026-08-01",
-                "to": "2026-08-03",
-            }]],
-            "routes": ["spend"],
-        })
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_empty_current_sessions_render_live_arrival_and_real_seven_day_history(self):
-        functions = []
-        for name in ("currentSessionsIdleHistory", "currentSessionsEmptyHtml"):
-            match = re.search(
-                rf"^function {name}\(.*?^\}}\n",
-                self.page,
-                re.MULTILINE | re.DOTALL,
-            )
-            self.assertIsNotNone(match, f"dashboard needs {name}")
-            functions.append(match.group(0))
-        fixture = {"daily": [
-            {"day": "2026-08-18", "sessions": 1, "cost": 1.25,
-             "providers": [{"provider": "codex"}],
-             "availability": {"cost": True},
-             "coverage": {"cost": {"complete": True}},
-             "usage_basis": "local_estimate"},
-            {"day": "2026-08-17", "sessions": 5, "cost": 2.0,
-             "providers": [{"provider": "codex"}, {"provider": "claude"}],
-             "availability": {"cost": True},
-             "coverage": {"cost": {"complete": True}},
-             "usage_basis": "reported"},
-            {"day": "2026-08-12", "sessions": 2, "cost": 50.0,
-             "providers": [{"provider": "claude"}],
-             "availability": {"cost": False},
-             "coverage": {"cost": {"complete": False}},
-             "usage_basis": "unavailable"},
-            {"day": "2026-08-11", "sessions": 99, "cost": 99.0,
-             "providers": [{"provider": "outside-window"}],
-             "availability": {"cost": True},
-             "coverage": {"cost": {"complete": True}},
-             "usage_basis": "reported"},
-        ]}
-        script = """
-const f=value=>String(value);
-const money=value=>'$'+Number(value).toFixed(2);
-const esc=value=>String(value);
-const countWord=(count,singular,plural=singular+'s')=>Number(count)===1?singular:plural;
-""" + "\n".join(functions) + "\nconst xs=" + json.dumps(fixture) + ";\n" + """
-const history=currentSessionsIdleHistory(xs,'2026-08-18');
-const html=currentSessionsEmptyHtml(xs,'2026-08-18');
-const firstRunHtml=currentSessionsEmptyHtml({daily:[]},'2026-08-18');
-console.log(JSON.stringify({history,html,firstRunHtml}));
-"""
-        result = subprocess.run(
-            ["node", "-e", script], capture_output=True, text=True, check=True,
-        )
-        rendered = json.loads(result.stdout)
-        self.assertEqual(rendered["history"], {
-            "days": [
-                {"day": "2026-08-12", "sessions": 2},
-                {"day": "2026-08-13", "sessions": 0},
-                {"day": "2026-08-14", "sessions": 0},
-                {"day": "2026-08-15", "sessions": 0},
-                {"day": "2026-08-16", "sessions": 0},
-                {"day": "2026-08-17", "sessions": 5},
-                {"day": "2026-08-18", "sessions": 1},
-            ],
-            "sessions": 8,
-            "cost": 3.25,
-            "costAvailable": True,
-            "costPartial": True,
-            "costEstimated": True,
-            "runtimes": ["claude", "codex"],
-        })
-        html = rendered["html"]
-        for marker in (
-            "Your next live session appears here",
-            "Next live session",
-            "Cost",
-            "Output / $",
-            "Context in use",
-            "Speed",
-            "8 past sessions",
-            "At least $3.25 est tracked",
-            "2 runtimes",
-            "data-current-empty-history",
-            "Explore 8 past sessions",
-            'href="https://github.com/splunk/token-meter/issues"',
-            "Share feedback",
-        ):
-            self.assertIn(marker, html)
-        self.assertIn("No past sessions yet", rendered["firstRunHtml"])
-        self.assertIn("Your seven-day activity will build here.", rendered["firstRunHtml"])
-        self.assertNotIn("data-current-empty-history", rendered["firstRunHtml"])
-
-    def test_session_cards_use_compact_readable_metrics(self):
-        for marker in (
-            ".currentSessionGrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}",
-            ".currentSessionGrid{gap:10px}",
-            ".currentSessionCard{min-height:190px;padding:16px 18px 14px}",
-            ".currentSessionIdentity h3{font-size:var(--fs-18)}",
-            ".currentSessionMetric b{margin-top:4px;font-size:var(--fs-18)}",
-            "font-variant-numeric:tabular-nums",
-            ".currentSessionMetric b.mono{font-size:var(--fs-18)}",
-            ".currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-20)}",
-            "@media(max-width:700px){.currentSessionGrid{grid-template-columns:1fr;gap:8px}",
-            ".currentSessionCard{min-height:184px;padding:14px 14px 12px}",
-            ".currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-16)",
-            "@media(max-width:700px){.currentSessionMetric b,.currentSessionMetric b.mono{font-size:var(--fs-18)}",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_session_cards_show_context_pressure_or_window_fallback(self):
-        for marker in (
-            "function currentSessionContextSparkline(row)",
-            "Array.isArray(context.samples)",
-            "if(!windowSize)return {",
-            "currentSessionContextUnavailable",
-            "window --",
-            "Context window unavailable;",
-            "Context window and latest token count unavailable.",
-            "const plotted=samples.slice(-24)",
-            "const values=plotted.map(value=>value/windowSize)",
-            "const width=96,height=22",
-            "currentSessionContextBar",
-            "value>=.85?' high':value>=.7?' watch'",
-            "<svg class=currentSessionContextSpark",
-            "class=currentSessionContextValue",
-            "const contextSpark=currentSessionContextSparkline(row)",
-            "${contextSpark.html}",
-            "<span>Context in use</span>",
-            ">Context in use</div><div class=\"v mono\" id=ov-context>",
-            ">Context in use</div><div class=\"v mono\" id=preview-context>",
-            "cacheSavingsAvailable?money(cache.saved||s.cache_saved||0):'--'",
-            "const cardDescription=`${heroCaption?heroCaption+'. ':''}${contextSpark.summary}",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("const values=windowSize?plotted.map(value=>value/windowSize):plotted", self.page)
-        self.assertNotIn("currentSessionContextCaption", self.page)
-        self.assertNotIn("currentSessionContextGuide", self.page)
-
-    def test_session_cards_do_not_have_native_hover_tooltips(self):
-        session_cards = self.page.split("function renderCurrentSessions(state=LATEST){", 1)[1].split(
-            "const currentSessionGrid=$('current-session-grid');", 1
-        )[0]
-        for marker in (
-            'class=currentSessionRuntime title=',
-            '<h3 title=',
-            '<p title=',
-            '<b class=mono title=',
-            "const contextNote=",
-        ):
-            self.assertNotIn(marker, session_cards)
-        self.assertIn('aria-description="${esc(cardDescription)}"', session_cards)
-
-    def test_redundant_hover_tips_are_removed_from_dashboard_labels(self):
-        for marker in (
-            '<h1 class=fieldtip id=session-page-title',
-            '<h1 class=fieldtip tabindex=0 aria-description="Local AI app logs',
-            '<h1 class=fieldtip tabindex=0 aria-description="Compare model runtimes',
-            '<h1 class=fieldtip tabindex=0 aria-description="What changed',
-            '<h1 class=fieldtip tabindex=0 aria-description="A practical review loop',
-            '<h1 class=fieldtip tabindex=0 aria-description="Review local tool',
-            '<h1 class=fieldtip tabindex=0 aria-description="Machine-wide controls',
-            'class="currentSessionsCount fieldtip"',
-            'class="previewStartText fieldtip"',
-            'class="card previewKpi fieldtip',
-            'class="learnShortcut fieldtip"',
-            '<h2 class=fieldtip tabindex=0 aria-description="Where the day’s covered spend',
-        ):
-            self.assertNotIn(marker, self.page)
-        for marker in (
-            '<h1 id=session-page-title>Sessions</h1>',
-            '<h2 class=workSrOnly>All sessions</h2>',
-            '<h1>Models</h1>',
-            '<h1>Spend</h1>',
-            '<h1>Learn</h1>',
-            '<h1>Tools</h1>',
-            '<h1>Settings</h1>',
-            '<div class="card previewKpi metric">',
-            'data-tip="Observed model output divided by attributable timing.',
-            'data-tip="Budget minus observed spend.',
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_sessions_use_the_distilled_token_meter_spectrum_system(self):
-        for marker in (
-            "shared-spectrum-system-v1",
-            "session-spectrum-field-v2",
-            "THESIS: Sessions are live instruments",
-            "<body class=spectrumApp>",
-            ":root,[data-theme=classic]{",
-            "--signal:#00bceb",
-            "--signal-mid:#1ba0e1",
-            "--signal-hi:#7fdbf2",
-            "--aura:#c7a7ff",
-            "--orange:#ffb457",
-            "body.sessionRoute{",
-            "--session-signal:var(--signal)",
-            'class="previewHead spectrumPageHead sessionFlowHead"',
-            'class="previewHeadCopy spectrumPageHeadCopy"',
-            ".spectrumPageHead:before",
-            ".spectrumPageHead{position:relative;isolation:isolate;display:flex;width:100%;max-width:none;height:138px;align-items:flex-start",
-            ".currentSessionCard:before{content:none}",
-            ".currentSessionCard.activity-working",
-            ".currentSessionGrip",
-            "@media(prefers-reduced-motion:reduce)",
-            "document.body.classList.toggle('sessionRoute',t==='session');",
-            "$('view-session').classList.toggle('sessionOverview',overview);",
-            "$('view-session').classList.toggle('sessionDetail',!overview);",
-            "$('session-page-title').textContent=overview?'Sessions':sessionDisplayName(CURRENT);",
-            "function sessionDisplayName(s)",
-            "activity-${activity}",
-            "<svg class=currentSessionGrip",
-            'font-family:"Tektur Local"',
-            'src:url("/assets/fonts/Tektur-Variable.ttf")',
-            "filterView.countLabel",
-            "concept-roll seed a5c0fdde",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertNotIn("id=current-eyebrow", self.page)
-        self.assertNotIn("miraiVerticalNote", self.page)
-        self.assertNotIn("miraiGaugeScale", self.page)
-        self.assertNotIn("直近30分", self.page)
-        self.assertNotIn("稼働状況", self.page)
-        self.assertNotIn("session-solar-field-v1", self.page)
-        self.assertNotIn("body.sessionRoute #view-session.sessionDetail .previewHead{min-height:152px}", self.page)
-        self.assertNotIn("body.sessionRoute #view-session.sessionDetail .previewStatus:before", self.page)
-        self.assertNotIn("body.sessionRoute #view-session.sessionDetail .previewStatus:after", self.page)
-
-    def test_run_status_card_has_no_decorative_context_circle(self):
-        self.assertNotIn("#view-session.sessionDetail .previewStatus:before", self.page)
-        self.assertNotIn("--context-pressure", self.page)
-        self.assertNotIn(".style.setProperty('--context-pressure'", self.page)
-        self.assertIn('id=preview-context-bar', self.page)
-        self.assertIn("$('preview-context-bar').querySelector('i').style.width=", self.page)
-
-    def test_top_level_views_share_the_spectrum_design_primitives(self):
-        for marker in (
-            "shared-spectrum-system-v1",
-            "spectrum-professional-finish-v2",
-            "--spectrum-card:",
-            "--spectrum-edge-light:",
-            "--spectrum-edge-hover:",
-            "--spectrum-depth-focus:",
-            "--spectrum-active-hover:",
-            "body.spectrumApp .card{",
-            "body.spectrumApp .tbtn{",
-            "body.spectrumApp .seg{",
-            "body.spectrumApp .tab.on,body.spectrumApp .seg button.on",
-            "body.spectrumApp :is(input:not([type=checkbox]):not([type=range]),select,textarea,.modelPicker>summary)",
-            "body.spectrumApp .spectrumPageHead:after",
-            "--spectrum-page:radial-gradient",
-            "--spectrum-card:radial-gradient",
-            "--spectrum-control:radial-gradient",
-            "--spectrum-active:linear-gradient",
-            '<div class="previewHead spectrumPageHead sessionFlowHead"',
-            '<header class="capPageHead spectrumPageHead"',
-            '<div class="modelHead spectrumPageHead"',
-            '<div class="dailyHead spectrumPageHead"',
-            '<div class="learnHead spectrumPageHead"',
-            '<div class="learnHead settingsPageHead spectrumPageHead"',
-            "<h1>Tools</h1>",
-            "<span class=allSessionsHint id=g-hint>Recent activity</span>",
-            "vertical-navigation-rail-v1",
-            "body.spectrumApp .wrap{--navigation-rail-width:184px",
-            "grid-template-columns:var(--navigation-rail-width) minmax(0,1320px)",
-            "body.spectrumApp .top{grid-column:1;grid-row:1;position:sticky",
-            "body.spectrumApp .top .tabs{display:flex;min-width:0;max-width:100%;overflow:visible;flex:1;flex-direction:column",
-            "body.spectrumApp .top .tab{display:grid;width:100%;min-height:42px",
-            "class=tabIcon",
-            "class=navPrimary",
-            "class=navSecondary",
-            ".navPrimary,.navSecondary{display:flex;flex-direction:column;gap:4px}",
-            ".navSecondary{margin-top:auto",
-            "@media(max-width:1180px){body.spectrumApp .wrap{--navigation-rail-width:68px",
-            "@media(max-width:760px){body.spectrumApp .wrap{display:block",
-            "body.spectrumApp .top .tabs{grid-column:1/-1;grid-row:2;min-width:0;width:100%;overflow-x:auto;flex:none;flex-direction:row",
-            ".navPrimary,.navSecondary{display:contents}",
-            "@media(max-width:760px){#view-models{overflow-x:clip}}",
-            "body.spectrumApp .settingsMap{grid-template-columns:repeat(6,minmax(0,1fr))",
-        ):
-            self.assertIn(marker, self.page)
-        for marker in (
-            "data-settings-target=budget-settings><span>01",
-            "data-settings-target=agent-access><span>02",
-            "data-settings-target=model-pricing-settings><span>03",
-            "data-settings-target=frustration-settings><span>04",
-            "data-settings-target=update-settings><span>05",
-            "&#8249;",
-            "&#8250;",
-        ):
-            self.assertNotIn(marker, self.page)
-
-    def test_sessions_is_default_new_cards_lead_and_known_cards_keep_manual_order(self):
-        for marker in (
-            "$('tab-session').onclick=()=>{window.scrollTo(0,0);openCurrentSessions();};",
-            "label:'Sessions'",
-            "action:'sessions'}",
-            "setHashRoute('sessions',{replace:true,apply:false})",
-            "const CURRENT_SESSION_ORDER_KEY='tm_current_session_order_v1'",
-            "const CURRENT_SESSION_ORDER_MIGRATION_KEY='tm_current_session_newest_first_v1'",
-            "function orderedCurrentSessionRows(rows)",
-            "function currentSessionActivity(row)",
-            "function syncCurrentSessionActivity(root,rows)",
-            "if(!Array.isArray(sourceRows))",
-            "function moveCurrentSessionCard(sourceId,targetId,after=false)",
-            "function moveCurrentSessionCardBy(sourceId,delta)",
-            "function focusCurrentSessionCard(id)",
-            "draggable=true",
-            "event.dataTransfer.effectAllowed='move'",
-            "currentSessionGrid.addEventListener('dragover'",
-            "currentSessionGrid.addEventListener('drop'",
-            "currentSessionGrid.addEventListener('dragend'",
-            "currentSessionGrid.addEventListener('keydown'",
-            "event.altKey",
-            "Press ⌥ and an arrow key to move.",
-            "id=current-session-order-status",
-        ):
-            self.assertIn(marker, self.page)
-        self.assertIn("if(!id||byId.has(id))return;", self.page)
-        self.assertIn(
-            "const known=currentSessionOrder.filter(id=>byId.has(id)),seen=new Set(known);",
-            self.page,
-        )
-        self.assertIn(
-            "if(currentSessionDragId||(interactingCurrentSessionCard&&currentSessionIdsMatch(mountedCurrentSessionIds,rows))){syncCurrentSessionActivity(currentGrid,rows);return;}",
-            self.page,
-        )
-        self.assertIn(
-            "const unseen=sourceIds.filter(id=>!seen.has(id));\n"
-            " let next=[...unseen,...known];",
-            self.page,
-        )
-        self.assertIn(
-            "if(currentSessionOrderNeedsNewestMigration&&sourceIds.length){\n"
-            "  const newest=sourceIds[0];\n"
-            "  next=[newest,...next.filter(id=>id!==newest)];",
-            self.page,
-        )
-        self.assertNotIn("next.push(id);seen.add(id)", self.page)
-        limit = re.search(r"const CURRENT_SESSION_ORDER_LIMIT=(\d+);", self.page)
-        self.assertIsNotNone(limit)
-        self.assertEqual(int(limit.group(1)), meter.CURRENT_SESSION_LIMIT)
-        self.assertIn(".slice(0,CURRENT_SESSION_ORDER_LIMIT))]:[];", self.page)
-        self.assertIn("JSON.stringify(currentSessionOrder.slice(0,CURRENT_SESSION_ORDER_LIMIT))", self.page)
-        self.assertNotIn("slice(0,64))]:[];", self.page)
-
-    def test_cursor_provenance_is_integrated_across_dashboard_views(self):
-        for marker in (
-            "const hasLocalEstimate", "const estimateSuffix",
-            "local token proxies are not comparable", "stroke-dasharray",
-            "id=c-runtime-filter", "Input context proxy",
-            "visible text estimate", "hasLocalEstimate(row)",
-        ):
-            self.assertIn(marker, self.page)
-
-    def test_handler_swallows_browser_disconnects(self):
-        source = Path(meter.IMPLEMENTATION_FILE).read_text()
-        self.assertIn("except (BrokenPipeError, ConnectionResetError):", source)
-
-    def test_dashboard_live_updates_do_not_hold_event_stream_connections(self):
-        self.assertNotIn("new EventSource('/events')", self.page)
-        self.assertIn("const LIVE_STATE_POLL_MS=1000", self.page)
-        self.assertIn("setInterval(refreshLiveState,LIVE_STATE_POLL_MS)", self.page)
-        self.assertIn("if(statePollBusy)return", self.page)
-        poll = self.page.split("async function refreshLiveState(){", 1)[1].split("\n}\n", 1)[0]
-        self.assertIn("applyLiveState(await fetchLiveJson('/state',LIVE_XSESSION.state,'State'))", poll)
-        source = Path(meter.IMPLEMENTATION_FILE).read_text()
-        state_route = source.index('elif req_path == "/state":')
-        self.assertIn("dashboard_state_body(", source[state_route:state_route + 400])
-        session_route = source.index('elif req_path == "/session":')
-        self.assertIn(
-            "dashboard_state_body(st or {}, known)",
-            source[session_route:state_route],
-        )
-        events = source.index('elif req_path == "/events":')
-        self.assertIn("self.send_response(204)", source[events:events + 700])
-
-    def test_http_server_tolerates_browser_connection_bursts(self):
-        self.assertTrue(meter.TokenMeterHTTPServer.daemon_threads)
-        self.assertGreaterEqual(meter.TokenMeterHTTPServer.request_queue_size, 32)
-
-    def test_dynamic_responses_cannot_be_reused_from_an_http_cache(self):
-        handler = mock.Mock()
-        meter.H._send(handler, "{}", "application/json")
-
-        handler.send_header.assert_any_call("Cache-Control", "no-store, max-age=0")
-        handler.send_header.assert_any_call("Pragma", "no-cache")
-        handler.send_header.assert_any_call("Expires", "0")
-
-
-class MenubarSourceTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.source = Path(meter.__file__).with_name("menubar").joinpath("TokenMeterMenuBar.swift").read_text()
-
-    def test_spend_action_opens_cross_session_spend_route(self):
-        self.assertIn('case .spend: return "Spend"', self.source)
-        self.assertIn('case .spend:\n                self.openDailyBrief()', self.source)
-        self.assertIn('@objc private func openDailyBrief()', self.source)
-        self.assertIn('openDashboardPanel("spend", includePinnedSession: false)', self.source)
-
-    def test_dashboard_opens_sessions_unless_a_session_is_pinned(self):
-        self.assertIn(
-            'tokenMeterDashboardURL = URL(string: "http://127.0.0.1:8722/#sessions")',
-            self.source,
-        )
-        self.assertIn("if pinnedSessionID?.isEmpty == false", self.source)
-        self.assertIn('openDashboardPanel("summary")', self.source)
-        self.assertIn('openDashboardPanel("sessions", includePinnedSession: false)', self.source)
-
-    def test_model_prices_setting_opens_dashboard_pricing_editor(self):
-        self.assertIn('NSMenuItem(title: "Model Prices", action: #selector(openModelPrices)', self.source)
-        self.assertIn('@objc private func openModelPrices()', self.source)
-        self.assertIn('openDashboardPanel("model-pricing", includePinnedSession: false)', self.source)
-
-    def test_enterprise_tokenomics_is_a_top_level_native_action_below_settings(self):
-        self.assertIn(
-            'private let tokenMeterEnterpriseTokenomicsURL = URL(string: "https://www.splunk.com/en_us/products/tokenomics.html")!',
-            self.source,
-        )
-        rebuild = self.source[
-            self.source.index("    private func rebuildMenu()"):
-            self.source.index("    private var activeShortcutKeyCode")
-        ]
-        self.assertIn(
-            'NSMenuItem(title: "Get Enterprise Tokenomics", action: #selector(openEnterpriseTokenomics)',
-            rebuild,
-        )
-        self.assertLess(
-            rebuild.index("menu.addItem(settingsItem)"),
-            rebuild.index('NSMenuItem(title: "Get Enterprise Tokenomics"'),
-        )
-        self.assertIn('@objc private func openEnterpriseTokenomics()', self.source)
-        self.assertIn('NSWorkspace.shared.open(tokenMeterEnterpriseTokenomicsURL)', self.source)
-
-    def test_native_menu_does_not_advertise_removed_session_trace_view(self):
-        for marker in (
-            'NSMenuItem(title: "Open Trace"', '#selector(openTrace)',
-            '@objc private func openTrace()', 'openDashboardPanel("activity")',
-        ):
-            self.assertNotIn(marker, self.source)
-
-    def test_output_speed_remains_available_without_a_standing_menu_row(self):
-        rebuild = self.source[
-            self.source.index("    private func rebuildMenu()"):
-            self.source.index("    private var activeShortcutKeyCode")
-        ]
-        self.assertNotIn('addMetricRow("Output', rebuild)
-        self.assertIn(r'· \(outputSpeedLabel) · \(model)', self.source)
-        self.assertIn('formatTokenRate(rate)', self.source)
-        self.assertIn(
-            'return "\\(formatTokenRate(rate)) tok/s\\(estimatedTokens ? " est" : "")"',
-            self.source,
-        )
-        self.assertNotIn('tok/s\\(live)', self.source)
-        self.assertIn('print(snapshot.outputSpeedLabel)', self.source)
-
-    def test_selected_session_cost_and_context_are_not_menu_rows(self):
-        rebuild = self.source[
-            self.source.index("    private func rebuildMenu()"):
-            self.source.index("    private var activeShortcutKeyCode")
-        ]
-        self.assertIn('return "\\(costLabel) · \\(contextLabel) · \\(outputSpeedLabel) · \\(model)"', self.source)
-        self.assertNotIn('return "\\(verdict.prefix) \\(formatMoney(totalCost))', self.source)
-        self.assertNotIn('addMetricRow("Cost", snapshot.costLabel', rebuild)
-        self.assertNotIn('"Context",\n                contextDetail', rebuild)
-        self.assertNotIn('addMetricRow("Status"', rebuild)
-        self.assertNotIn('"Now"', rebuild)
-        self.assertNotIn('"Action"', rebuild)
-
-    def test_cursor_uses_provider_identity_and_estimated_usage_labels(self):
-        self.assertIn('catalog[provider] ?? catalog["unknown-runtime"]', self.source)
-        self.assertIn('case "runtime.cursor": return "cursorarrow"', self.source)
-        self.assertIn('let costAvailable = metricAvailable(availability, "cost")', self.source)
-        self.assertIn('let tokensAvailable = metricAvailable(availability, "tokens")', self.source)
-        self.assertIn('let estimatedTokens = bool(source["token_estimate"])', self.source)
-        self.assertIn('var menuBarTodaySpendLabel: String', self.source)
-
-    def test_live_polling_bypasses_cached_menubar_responses(self):
-        self.assertIn('cachePolicy: .reloadIgnoringLocalCacheData', self.source)
-        self.assertIn('request.setValue("no-cache", forHTTPHeaderField: "Cache-Control")', self.source)
-        self.assertIn('request.setValue("no-cache", forHTTPHeaderField: "Pragma")', self.source)
-
-    def test_native_menu_surfaces_updates_and_installs_without_the_dashboard(self):
-        for marker in (
-            "struct SoftwareUpdateSnapshot",
-            'dict["software_update"] as? [String: Any]',
-            'title: "New update available",',
-            'action: #selector(installSoftwareUpdate),',
-            'NSMenuItem(title: "Updating Token Meter...", action: nil',
-            'title: "Update needs attention",',
-            'action: #selector(openUpdateSettings),',
-            '@objc private func installSoftwareUpdate()',
-            'request.httpMethod = "POST"',
-            'request.setValue("application/json", forHTTPHeaderField: "Content-Type")',
-            'request.setValue(softwareUpdate.actionToken, forHTTPHeaderField: "X-Token-Meter-Action")',
-            'request.httpBody = Data("{}".utf8)',
-            '@objc private func openUpdateSettings()',
-            'tokenMeterUpdateSettingsURL',
-        ):
-            self.assertIn(marker, self.source)
-        rebuild = self.source[
-            self.source.index("    private func rebuildMenu()"):
-            self.source.index("    private var activeShortcutKeyCode")
-        ]
-        self.assertLess(
-            rebuild.index("addQuickActions()"),
-            rebuild.index("addSoftwareUpdateItem()"),
-        )
-        self.assertLess(
-            rebuild.index("addSoftwareUpdateItem()"),
-            rebuild.index("addSessionPicker()"),
-        )
-        self.assertIn("if self.softwareUpdate.isUpdating", self.source)
-        self.assertIn('print("native-update=available updating attention")', self.source)
-
-    def test_status_item_owns_a_clean_native_menu(self):
-        app = self.source[
-            self.source.index("final class TokenMeterMenuBar"):
-            self.source.index("private func string(")
-        ]
-        self.assertIn('private let menu = NSMenu(title: "Token Meter")', app)
-        self.assertIn('statusItem.menu = menu', app)
-        self.assertIn('menu.delegate = self', app)
-        self.assertIn('func menuNeedsUpdate(_ menu: NSMenu)', app)
-        self.assertIn('func menuWillOpen(_ menu: NSMenu)', app)
-        self.assertIn('func menuDidClose(_ menu: NSMenu)', app)
-        self.assertIn('private var menuRefreshPending = false', app)
-        self.assertIn('guard !menuIsOpen else', app)
-        self.assertIn('func runMenuSmoke() throws', app)
-        self.assertIn('TOKEN_METER_MENUBAR_MENU_SMOKE', self.source)
-        self.assertIn('native-menu=ready sessions=direct follow-latest=direct', self.source)
-        self.assertIn('native-quick-actions=Dashboard,Spend,Tools,Settings height=26', self.source)
-        self.assertNotIn('private let popover = NSPopover()', app)
-        self.assertNotIn('popover.show(relativeTo: button.bounds', app)
-        self.assertIn('NSSegmentedControl', app)
-
-    def test_native_menu_exposes_direct_session_following(self):
-        self.assertIn('let selectedSessionID = string(selection["selected_id"])', self.source)
-        self.assertIn('let selectedSession = recentSessions.first { $0.id == snapshot.selectedSessionID }', self.source)
-        self.assertIn('NSMenuItem(title: "Follow latest", action: #selector(followLatest)', self.source)
-        self.assertIn('for session in recentSessions.prefix(5)', self.source)
-        self.assertIn('NSMenuItem(title: session.menuTitle, action: #selector(pinSession(_:))', self.source)
-        self.assertIn('item.state = pinnedSessionID == session.id ? .on : .off', self.source)
-        self.assertIn('item.representedObject = session.id', self.source)
-        self.assertIn('@objc private func followLatest()', self.source)
-        self.assertIn('@objc private func pinSession(_ sender: NSMenuItem)', self.source)
-        self.assertIn('let maximumNameLength = 36', self.source)
-
-    def test_provider_limits_and_budgets_use_separate_native_submenus(self):
-        self.assertIn('NSMenuItem(title: "Provider limits (Beta)", action: nil', self.source)
-        self.assertIn('description: "Provider limits (Beta)"', self.source)
-        self.assertIn('limitsItem.submenu = makeLimitsMenu()', self.source)
-        self.assertIn('private func makeLimitsMenu() -> NSMenu', self.source)
-        self.assertIn('for window in provider.windows', self.source)
-        self.assertIn('"\\(window.label) · \\(window.percentLabel) used"', self.source)
-        self.assertIn('coverageNote: string(dict["coverage_note"]) ?? ""', self.source)
-        self.assertIn('coverage=\\(coverage)', self.source)
-        self.assertIn('case "opencode": return "gearshape.2"', self.source)
-        self.assertIn('let budget = double(row["allocation"])', self.source)
-        self.assertIn('NSMenuItem(title: "Budgets", action: nil', self.source)
-        self.assertIn('budgetsItem.submenu = makeBudgetsMenu()', self.source)
-        self.assertIn('private func makeBudgetsMenu() -> NSMenu', self.source)
-        self.assertIn('let overallTitle = budget.configured', self.source)
-        self.assertIn('"Overall · \\(formatMoney(budget.spend)) of \\(formatMoney(budget.budget)) · \\(Int(budget.percent.rounded()))% used"', self.source)
-        self.assertIn('for scope in budget.scopes where scope.id != "overall"', self.source)
-        self.assertIn('"\\(scope.label) · \\(formatMoney(scope.spend)) of \\(formatMoney(scope.budget)) · \\(Int(scope.percent.rounded()))% used"', self.source)
-        self.assertIn('"\\(scope.label) · Not set"', self.source)
-        self.assertIn('action: #selector(openBudgetSettings)', self.source)
-        self.assertIn('Native budgets omitted the OpenCode monthly budget.', self.source)
-        self.assertIn('overallBudgetItems.count == 1', self.source)
-        self.assertIn('budgetActionItems.count == runtimeBudgetScopes.count + 1', self.source)
-
-        limits = self.source[
-            self.source.index("    private func makeLimitsMenu()"):
-            self.source.index("    private func makeBudgetsMenu()")
-        ]
-        self.assertNotIn("monthlyBudget", limits)
-        self.assertNotIn("budgetScope", limits)
-        self.assertNotIn("openBudgetSettings", limits)
-
-    def test_menu_bar_settings_are_visible_and_quota_threshold_is_explicit(self):
-        self.assertIn('case .settings: return "Settings"', self.source)
-        self.assertIn('case .settings:\n                self.openSettings()', self.source)
-        self.assertIn('NSMenuItem(title: "Menu bar settings", action: nil', self.source)
-        self.assertIn('settingsItem.submenu = makeSettingsMenu()', self.source)
-        self.assertNotIn('NSMenuItem(title: "More", action: nil', self.source)
-        self.assertIn('NSMenuItem(title: "Open Settings", action: #selector(openSettings)', self.source)
-        self.assertIn('addAction("Quit Token Meter", #selector(quit))', self.source)
-        self.assertNotIn('Quit Token Meter Menubar', self.source)
-        self.assertIn('NSMenuItem(title: "Quota alert threshold (\\(quotaAlertThreshold)%)"', self.source)
-        self.assertIn('NSMenu(title: "Quota alert threshold")', self.source)
-        self.assertIn('title: "\\(threshold)% used",', self.source)
-        self.assertNotIn('NSMenuItem(title: "Warn at"', self.source)
-
-    def test_configurable_title_and_quota_notifications_have_safe_defaults(self):
-        self.assertIn('enum TitleMetric: String, CaseIterable', self.source)
-        self.assertIn('metrics = [.cost, .speed]', self.source)
-        self.assertIn('for metric in TitleMetric.allCases', self.source)
-        self.assertIn('#selector(toggleTitleMetric(_:))', self.source)
-        self.assertIn('TitleMetric.allCases.filter(titleMetrics.contains).map(\\.rawValue)', self.source)
-        self.assertIn('let presentation = selectedStatusTitlePresentation()', self.source)
-        self.assertIn('let title = presentation.accessibilityTitle', self.source)
-        self.assertIn('let text = snapshot.menuBarCostLabel', self.source)
-        self.assertIn('let text = snapshot.menuBarOutputSpeedLabel', self.source)
-        self.assertIn('let text = snapshot.menuBarContextLabel', self.source)
-        self.assertIn('let text = snapshot.model', self.source)
-        self.assertIn('case .todaySpend:', self.source)
-        self.assertIn('let text = snapshot.menuBarTodaySpendLabel', self.source)
-        self.assertIn('case .todaySpend: return "Today spend"', self.source)
-        self.assertIn(
-            'return "\\(String(format: "$%.0f", todaySpendTotalCost))\\(todaySpendEstimated ? " est" : "")"',
-            self.source,
-        )
-        self.assertIn('parts[parts.count - 1].text = "· " + parts[parts.count - 1].text', self.source)
-        self.assertIn('metrics.insert(.todaySpend)', self.source)
-        self.assertIn('todaySpendTitlePreferenceDefaultsKey', self.source)
-        self.assertIn('todaySpendEstimated ? " est" : ""', self.source)
-        self.assertIn('metrics = [.limits]', self.source)
-        self.assertIn(
-            'tokenMeterDefaults.set(true, forKey: todaySpendTitlePreferenceDefaultsKey)',
-            self.source,
-        )
-        self.assertIn('let accessibilityText = limitsStatusTitle()', self.source)
-        self.assertIn('symbol: runtimeCatalog[constrained.provider.id]?.symbol', self.source)
-        self.assertNotIn('private func compactStatusTitle()', self.source)
-        self.assertIn('private func limitsStatusTitle() -> String?', self.source)
-        self.assertIn('return "\\(constrained.provider.label) \\(constrained.window.percentLabel)"', self.source)
-        self.assertNotIn('constrained.window.compactKind', self.source)
-        self.assertIn('Native menu still exposes hover tooltips.', self.source)
-        self.assertIn('guard statusItem.button?.toolTip == nil, !menuContainsToolTip(menu)', self.source)
-        self.assertIn('private var quotaAlertsEnabled: Bool { notificationFeed?.quotaAlerts ?? true }', self.source)
-        self.assertIn('saveQuotaAlertPreferences(enabled: !quotaAlertsEnabled, threshold: quotaAlertThreshold)', self.source)
-        self.assertIn('process.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")', self.source)
-        self.assertIn('"--", title, body', self.source)
-
-    def test_native_companion_only_claims_and_shows_server_notifications(self):
-        for removed in (
-            'evaluateQuotaNotifications', 'evaluateBudgetNotifications', 'evaluateLiveHintNotifications',
-            'struct QuotaNotificationState', 'struct BudgetNotificationState', 'firedThresholds',
-            'quotaObservationEstablished', 'deliveredLiveHintIDs', 'dict["live_hints"]',
-        ):
-            self.assertNotIn(removed, self.source)
-        for marker in (
-            'struct NotificationFeed', 'optionalDouble(dict["schema_version"]).map(Int.init) == 1',
-            'NotificationFeed.fromJSON(dict["notifications"] as? [String: Any])',
-            'private let notificationConsumer = "token-meter-menubar"',
-            'body: ["id": event.id, "consumer": notificationConsumer]',
-            'if ok, bool(response?["claimed"]) {',
-            'showNotification(title: event.title, body: event.body)',
-            '"http://127.0.0.1:8722/notifications/claim"', '"http://127.0.0.1:8722/settings/notifications"',
-            'body: ["quota_alerts": enabled, "quota_threshold": threshold, "migrate": true]',
-            'legacyNotificationDefaultsKeys.forEach(tokenMeterDefaults.removeObject(forKey:))',
-            '"TokenMeterQuotaNotificationStates", "TokenMeterBudgetNotificationStates"',
-            '"TokenMeterBudgetExceededNotificationMonths", "TokenMeterLiveHintNotificationIDs"',
-            'sampleFeed.deliverable.map(\\.id) == ["e5", "e4", "e3", "e2", "e1"]',
-            'events.filter(\\.claimable)',
-            'action: canEditQuotaAlerts ? #selector(toggleQuotaAlerts(_:)) : nil',
-        ):
-            self.assertIn(marker, self.source)
-
-    def test_status_item_uses_a_compact_cross_display_hit_target(self):
-        self.assertIn('NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)', self.source)
-        self.assertIn('private func splunkChevronImage(', self.source)
-        self.assertIn('private func statusTitleImage(_ presentation: StatusTitlePresentation) -> NSImage', self.source)
-        self.assertIn('private func runtimeMarkImage(symbol: String', self.source)
-        self.assertIn('var providerSymbol: String', self.source)
-        self.assertIn('var providerAccessibilityText: String', self.source)
-        self.assertIn('symbol: presentation.providerSymbol', self.source)
-        self.assertIn('let providerSymbol = runtimeCatalog[snapshot.provider]?.symbol ?? "runtime.generic"', self.source)
-        self.assertIn('let presentationWithoutLimits = selectedStatusTitlePresentation()', self.source)
-        self.assertIn('presentationWithoutLimits.providerSymbol == expectedProviderSymbol', self.source)
-        self.assertIn('button.image = splunkChevronImage()', self.source)
-        self.assertNotIn('systemSymbolName: "waveform.path.ecg"', self.source)
-        self.assertIn('button.imagePosition = .imageOnly', self.source)
-        self.assertIn('.foregroundColor: NSColor.black', self.source)
-        self.assertIn('image.isTemplate = true', self.source)
-        self.assertIn('let titleImage = statusTitleImage(presentation)', self.source)
-        self.assertIn('statusItem.length = titleImage.size.width + 8', self.source)
-        self.assertIn('button.contentTintColor = nil', self.source)
-        self.assertIn('button.setAccessibilityLabel("Token Meter")', self.source)
-        self.assertIn('button.setAccessibilityValue(title)', self.source)
-        self.assertNotIn('button.toolTip =', self.source)
-        self.assertIn('button.contentTintColor = budgetExceeded', self.source)
-        self.assertIn('enum StatusDisplayMode: String, CaseIterable', self.source)
-        self.assertIn('StatusDisplayMode.text.rawValue', self.source)
-        self.assertIn('screen.visibleFrame.width < 1200 ? .icon : .text', self.source)
-        self.assertIn('private func selectedStatusTitle() -> String', self.source)
-        self.assertIn('let renderedTitle = statusItem.button?.accessibilityValue() as? String', self.source)
-        self.assertIn('renderedTitle == expectedTitle', self.source)
-        self.assertIn('titleMetrics = Set(TitleMetric.allCases)', self.source)
-        self.assertIn('titleMetrics = originalTitleMetrics', self.source)
-        self.assertIn('statusItem.autosaveName = statusItemAutosaveName', self.source)
-        self.assertIn('"NSStatusItem Preferred Position \\(statusItemAutosaveName)"', self.source)
-        self.assertIn('statusItemInitialPreferredPosition = 50', self.source)
-        self.assertIn('object(forKey: statusItemPreferredPositionDefaultsKey) == nil', self.source)
-        self.assertNotIn('statusTitleColor(for:', self.source)
-        self.assertNotIn('NSWorkspace.didActivateApplicationNotification', self.source)
-
-    def test_native_menu_omits_cost_and_context_below_recent_sessions(self):
-        rebuild = self.source[
-            self.source.index("    private func rebuildMenu()"):
-            self.source.index("    private var activeShortcutKeyCode")
-        ]
-        sessions_position = rebuild.index('addSessionPicker()')
-        limits_position = rebuild.index('let limitsItem = NSMenuItem(title: "Provider limits (Beta)"')
-        self.assertLess(sessions_position, limits_position)
-        self.assertNotIn('addMetricRow("Cost", snapshot.costLabel', rebuild)
-        self.assertNotIn('"Context",\n                contextDetail', rebuild)
-        self.assertNotIn('addMetricRow("Tokens"', rebuild)
-        self.assertNotIn('addMetricRow("Cache"', rebuild)
-        self.assertNotIn('addMetricRow("Output', rebuild)
-        self.assertNotIn('ExecutionTraceView', rebuild)
-
-    def test_global_toggle_shortcut_is_configurable_and_persisted(self):
-        self.assertIn('import Carbon.HIToolbox', self.source)
-        self.assertIn('enum MenuBarShortcut: String, CaseIterable', self.source)
-        self.assertIn('case .controlOptionT: return "⌃⌥T"', self.source)
-        self.assertIn('private let globalShortcutDefaultsKey = "TokenMeterGlobalShortcut"', self.source)
-        self.assertIn('RegisterEventHotKey(', self.source)
-        self.assertIn('delegate.openMenu()', self.source)
-        self.assertIn('NSMenuItem(title: "Keyboard shortcut"', self.source)
-        self.assertIn('case .custom: return "Custom…"', self.source)
-        self.assertIn('@objc private func configureCustomShortcut(_ sender: NSMenuItem)', self.source)
-        self.assertIn('NSEvent.addLocalMonitorForEvents(matching: .keyDown)', self.source)
-        self.assertIn('tokenMeterDefaults.set(shortcut.rawValue, forKey: globalShortcutDefaultsKey)', self.source)
-
-    def test_native_menu_header_has_no_splunk_wordmark(self):
-        header = self.source[
-            self.source.index("    private func addHeader()"):
-            self.source.index("    private func addSessionPicker()")
-        ]
-        self.assertIn('titleText = selectedSession?.identifier ?? snapshot.menuTitle', header)
-        self.assertIn('"Following latest"', header)
-        self.assertIn('"Following this session"', header)
-        self.assertNotIn('splunkWordmarkImage', header)
-        self.assertNotIn('logo', header)
-
-    def test_monthly_budget_status_is_native_and_alerts_come_from_the_server(self):
-        for marker in (
-            'struct MonthlyBudget',
-            'let budgetExceeded = monthlyBudget?.anyExceeded == true',
-            'description: budgetExceeded ? "Budget alert" : "Budgets"',
-            'budgetsItem.submenu = makeBudgetsMenu()',
-            'tokenMeterBudgetSettingsURL',
-            'action: #selector(openBudgetSettings)',
-            'var exceeded: Bool { configured && percent >= 100 }',
-            'var anyExceeded: Bool { exceeded || !exceededRuntimeScopes.isEmpty }',
-            'if let scope = exceededRuntimeScopes.first',
-            'return "\\(scope.label) · \\(Int(scope.percent.rounded()))%"',
-            'warning: monthlyBudget?.anyExceeded == true',
-            'button.contentTintColor = budgetExceeded',
-            'NSColor.systemRed',
-            'button.setAccessibilityLabel("Token Meter")',
-            'let activeTitle = budget?.anyExceeded == true ? "⚠︎ \\(baseTitle)" : baseTitle',
-            'print("budget-state=\\(budget?.compactLabel ?? "unconfigured") exceeded=\\(budget?.anyExceeded == true)")',
-        ):
-            self.assertIn(marker, self.source)
-        self.assertNotIn("· over budget", self.source)
-        self.assertNotIn(
-            'monthlyBudget?.exceeded == true ? NSColor.systemRed : NSColor.labelColor',
-            self.source,
-        )
-        self.assertNotIn(
-            'valueColor: budget.exceeded ? .systemRed : .labelColor',
-            self.source,
-        )
-
-
-class TrayLogicTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        import importlib.util
-        tray_path = Path(meter.__file__).with_name("menubar").joinpath("token_meter_tray.py")
-        spec = importlib.util.spec_from_file_location("token_meter_tray", tray_path)
-        cls.tray = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(cls.tray)
-
-    def test_dashboard_url_opens_sessions_unless_pinned(self):
-        self.assertEqual(
-            self.tray.dashboard_url("#sessions", pinned_session=None, include_pinned_session=False),
-            "http://127.0.0.1:8722/#sessions",
-        )
-        self.assertEqual(
-            self.tray.dashboard_url("#summary", pinned_session="abc"),
-            "http://127.0.0.1:8722/sessions/abc#summary",
-        )
-
-    def test_status_display_mode_selects_or_hides_the_tray_label(self):
-        label = "$1 · 12 tok/s"
-        self.assertEqual(self.tray.normalize_status_display_mode(None), "automatic")
-        self.assertEqual(self.tray.normalize_status_display_mode("invalid"), "automatic")
-        self.assertEqual(self.tray.normalize_status_display_mode({"mode": "icon"}), "automatic")
-        self.assertEqual(self.tray.status_display_label(label, "automatic"), label)
-        self.assertEqual(self.tray.status_display_label(label, "text"), label)
-        self.assertEqual(self.tray.status_display_label(label, "icon"), "")
-
-    def test_update_tray_label_keeps_title_when_icon_mode_hides_label(self):
-        tray = object.__new__(self.tray.TokenMeterTray)
-        tray.error = ""
-        tray.title_metrics = set()
-        tray.snapshot = {}
-        tray.provider_quotas = []
-        tray.monthly_budget = None
-        tray.indicator = mock.Mock()
-        tray.status_display_mode = "icon"
-
-        tray.update_tray_label()
-
-        tray.indicator.set_label.assert_called_once_with(
-            "", "⚠︎ $999.99 · 999 tok/s · 100% ctx",
-        )
-        tray.indicator.set_title.assert_called_once_with("Token Meter")
-
-    def test_update_tray_label_uses_descriptive_tooltip_but_keeps_compact_status(self):
-        tray = object.__new__(self.tray.TokenMeterTray)
-        tray.error = ""
-        tray.title_metrics = {"cost", "speed", "today_spend"}
-        tray.snapshot = {
-            "availability": {"cost": True, "throughput": True, "tokens": True},
-            "source": {"label": "Claude", "token_estimate": False},
-            "total_cost": 1.25,
-            "throughput": {"available": True, "output_tps": 12.3},
-            "today_spend": {"available": True, "total_cost": 2.75, "estimated": True},
-        }
-        tray.provider_quotas = []
-        tray.monthly_budget = None
-        tray.indicator = mock.Mock()
-        tray.status_display_mode = "automatic"
-
-        tray.update_tray_label()
-
-        tray.indicator.set_label.assert_called_once_with(
-            "$1 · 12 tok/s · $3 est", "⚠︎ $999.99 · 999 tok/s · 100% ctx",
-        )
-        tray.indicator.set_title.assert_called_once_with(
-            "Current session cost: $1.25\nOutput speed: 12.3 tok/s\n"
-            "Today's spend across sessions: $2.75 est",
-        )
-
-    def test_update_tray_label_explains_offline_status_in_tooltip(self):
-        tray = object.__new__(self.tray.TokenMeterTray)
-        tray.error = "server unavailable"
-        tray.title_metrics = {"cost", "speed"}
-        tray.indicator = mock.Mock()
-        tray.status_display_mode = "automatic"
-
-        tray.update_tray_label()
-
-        tray.indicator.set_label.assert_called_once_with(
-            "TM off", "⚠︎ $999.99 · 999 tok/s · 100% ctx",
-        )
-        tray.indicator.set_title.assert_called_once_with("Token Meter · Server offline")
-
-    def test_display_mode_selection_persists_and_refreshes_the_tray(self):
-        tray = object.__new__(self.tray.TokenMeterTray)
-        tray.status_display_mode = "automatic"
-        tray.save_state = mock.Mock()
-        tray.update_tray_label = mock.Mock()
-        tray.refresh_menu_content = mock.Mock()
-        item = mock.Mock()
-        item.get_active.return_value = True
-        item.token_meter_status_display_mode = "icon"
-
-        tray._on_display_mode_toggled(item)
-
-        self.assertEqual(tray.status_display_mode, "icon")
-        tray.save_state.assert_called_once_with()
-        tray.update_tray_label.assert_called_once_with()
-        tray.refresh_menu_content.assert_called_once_with()
-
-    def test_tray_status_title_uses_selected_metrics_and_budget_warning(self):
-        state = {
-            "availability": {"cost": True, "throughput": True, "cache": True, "tokens": True},
-            "source": {"label": "Claude", "token_estimate": False},
-            "total_cost": 1.25,
-            "model": "claude-test",
-            "context": {"latest_pct": 0.42},
-            "throughput": {"available": True, "output_tps": 12.3},
-        }
-        providers = [{
-            "id": "claude",
-            "label": "Claude",
-            "status": "ok",
-            "stale": False,
-            "windows": [{"id": "weekly", "kind": "weekly", "label": "Weekly", "used_percent": 88}],
-        }]
-        budget = {
-            "configured": True,
-            "percent": 110,
-            "spend": 11,
-            "budget": 10,
-            "month": "2026-07",
-            "lower_bound": False,
-            "scopes": [{
-                "id": "overall", "label": "Overall", "spend": 11, "budget": 10, "percent": 110,
-            }],
-        }
-        title = self.tray.tray_status_title(
-            state, {"cost", "speed", "limits"}, providers, budget,
-        )
-        self.assertTrue(title.startswith("⚠︎ "))
-        self.assertIn("$1", title)
-        self.assertIn("12 tok/s", title)
-        self.assertIn("Claude 88% · weekly", title)
-
-    def test_tray_status_title_includes_today_spend_with_native_compact_labels(self):
-        state = {
-            "availability": {"cost": True, "throughput": True, "tokens": True},
-            "source": {"label": "Claude", "token_estimate": False},
-            "total_cost": 1.25,
-            "cost_approx": True,
-            "context": {"latest_pct": 0.42},
-            "throughput": {"available": True, "output_tps": 12.3},
-            "live_throughput": {"available": True, "output_tps": 24.6},
-            "today_spend": {"available": True, "total_cost": 2.75, "estimated": True},
-        }
-        title = self.tray.tray_status_title(
-            state, {"cost", "speed", "context", "today_spend"}, [], None,
-        )
-        self.assertEqual(title, "$1 · 25 tok/s · 42% · $3 est")
-        self.assertNotIn("$1 est", title)
-
-        unavailable_context = dict(state)
-        unavailable_context["context"] = {}
-        unavailable_title = self.tray.tray_status_title(
-            unavailable_context, {"context"}, [], None,
-        )
-        self.assertEqual(unavailable_title, "--%")
-
-    def test_load_state_persists_today_spend_migration(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "tray.json"
-            path.write_text(json.dumps({
-                "title_metrics": ["cost", "speed"],
-                "selected_tab": "run",
-            }), encoding="utf-8")
-            with mock.patch.object(self.tray, "STATE_PATH", str(path)):
-                loaded = self.tray.TokenMeterTray.load_state(object.__new__(
-                    self.tray.TokenMeterTray,
-                ))
-            self.assertIn("today_spend", loaded["title_metrics"])
-            persisted = json.loads(path.read_text(encoding="utf-8"))
-            self.assertEqual(persisted["title_metrics"], [
-                "cost", "speed", "today_spend",
-            ])
-            self.assertTrue(persisted["today_spend_title_preference"])
-
-    def test_load_state_migrates_and_preserves_status_display_mode(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "tray.json"
-            path.write_text(json.dumps({
-                "today_spend_title_preference": True,
-                "title_metrics": ["cost", "speed"],
-            }), encoding="utf-8")
-            with mock.patch.object(self.tray, "STATE_PATH", str(path)):
-                loaded = self.tray.TokenMeterTray.load_state(object.__new__(
-                    self.tray.TokenMeterTray,
-                ))
-            self.assertEqual(loaded["status_display_mode"], "automatic")
-            self.assertEqual(
-                json.loads(path.read_text(encoding="utf-8"))["status_display_mode"],
-                "automatic",
-            )
-
-            path.write_text(json.dumps({
-                "today_spend_title_preference": True,
-                "title_metrics": ["cost"],
-                "status_display_mode": "icon",
-            }), encoding="utf-8")
-            with mock.patch.object(self.tray, "STATE_PATH", str(path)):
-                loaded = self.tray.TokenMeterTray.load_state(object.__new__(
-                    self.tray.TokenMeterTray,
-                ))
-            self.assertEqual(loaded["status_display_mode"], "icon")
-
-    def test_parse_monthly_budget_preserves_unconfigured_runtime_scopes(self):
-        budget = self.tray.parse_monthly_budget({
-            "configured": True,
-            "month": "2026-07",
-            "spend": 6.5,
-            "budget": 1000,
-            "percent": 0.0065,
-            "runtimes": [
-                {
-                    "provider": "claude", "label": "Claude", "spend": 0,
-                    "allocation": 0, "percent": None,
-                },
-                {
-                    "provider": "codex", "label": "Codex", "spend": 6.5,
-                    "allocation": 1000, "percent": 0.0065,
-                },
-            ],
-        })
-        self.assertEqual([scope["id"] for scope in budget["scopes"]], [
-            "overall", "claude", "codex",
-        ])
-        self.assertEqual(budget["scopes"][1]["percent"], 0)
-        self.assertAlmostEqual(budget["scopes"][2]["percent"], 0.65)
-
-    def feed(self, **prefs):
-        return {
-            "schema_version": 1,
-            "events": [
-                {"id": f"e{i}", "title": f"t{i}", "body": "b", "created_at": 100 - i, "claimable": i != 6}
-                for i in range(7)
-            ],
-            "prefs": {"source": "saved", "quota_alerts": True, "quota_threshold": 90, **prefs},
-            "actions": {"token": "tok"},
-        }
-
-    def tray_instance(self, settings=None):
-        tray = object.__new__(self.tray.TokenMeterTray)
-        tray.settings = dict(settings or {})
-        tray.notification_feed = None
-        tray.legacy_notification_prefs_handled = False
-        tray.pinned_session = None
-        tray.selected_tab = "run"
-        tray.title_metrics = set(self.tray.DEFAULT_TITLE_METRICS)
-        tray.status_display_mode = "automatic"
-        return tray
-
-    def test_notification_feed_is_parsed_and_delivered_oldest_first(self):
-        feed = self.tray.parse_notification_feed(self.feed())
-        self.assertEqual(feed["quota_threshold"], 90)
-        self.assertEqual([e["id"] for e in self.tray.deliverable_notifications(feed)],
-                         ["e5", "e4", "e3", "e2", "e1"])
-        self.assertIsNone(self.tray.parse_notification_feed({"schema_version": 2}))
-        self.assertIsNone(self.tray.parse_notification_feed(None))
-        self.assertEqual(self.tray.parse_notification_feed(self.feed(quota_threshold=85))["quota_threshold"], 80)
-
-    def test_tray_shows_only_events_it_claimed(self):
-        tray = self.tray_instance()
-        claimed = {"e5", "e3"}
-        calls = []
-
-        def post(path, body, token):
-            calls.append((path, body, token))
-            return True, {"ok": True, "claimed": body["id"] in claimed}
-
-        with mock.patch.object(self.tray, "post_json", side_effect=post), \
-                mock.patch.object(self.tray, "deliver_notification") as deliver:
-            tray._handle_notifications(self.tray.parse_notification_feed(self.feed()))
-        self.assertEqual([c[1]["consumer"] for c in calls], ["token-meter-tray"] * 5)
-        self.assertEqual({c[0] for c in calls}, {"/notifications/claim"})
-        self.assertEqual([c.args for c in deliver.call_args_list], [("t5", "b"), ("t3", "b")])
-        self.assertTrue(tray.quota_alerts_enabled)
-        self.assertEqual(tray.quota_alert_threshold, 90)
-
-    def test_tray_stops_claiming_for_this_poll_after_a_failed_post(self):
-        tray = self.tray_instance()
-        with mock.patch.object(self.tray, "post_json", return_value=(False, {})) as post, \
-                mock.patch.object(self.tray, "deliver_notification") as deliver:
-            tray._handle_notifications(self.tray.parse_notification_feed(self.feed()))
-        self.assertEqual(post.call_count, 1)
-        deliver.assert_not_called()
-        self.assertLessEqual(self.tray.NOTIFICATION_POST_TIMEOUT_S, 2)
-
-    def test_tray_migrates_local_quota_prefs_once_then_drops_legacy_keys(self):
-        with tempfile.TemporaryDirectory() as directory:
-            path = os.path.join(directory, "tray.json")
-            tray = self.tray_instance({
-                "quota_alerts_enabled": False, "quota_alert_threshold": 95,
-                "quota_notification_states": {"codex:primary": {}}, "budget_exceeded_notification_months": [],
-            })
-            feed = self.tray.parse_notification_feed(self.feed(source="default"))
-            feed["events"] = []
-            with mock.patch.object(self.tray, "STATE_PATH", path), \
-                    mock.patch.object(self.tray, "post_json", return_value=(True, {"ok": True})) as post:
-                tray._handle_notifications(feed)
-                tray._handle_notifications(feed)
-            post.assert_called_once_with("/settings/notifications", {
-                "quota_alerts": False, "quota_threshold": 95, "migrate": True,
-            }, "tok")
-            with open(path, encoding="utf-8") as fh:
-                saved = json.load(fh)
-            for key in self.tray.LEGACY_NOTIFICATION_KEYS:
-                self.assertNotIn(key, saved)
-                self.assertNotIn(key, tray.settings)
-
-    def test_tray_keeps_local_prefs_until_the_server_takes_them(self):
-        with tempfile.TemporaryDirectory() as directory:
-            path = os.path.join(directory, "tray.json")
-            tray = self.tray_instance({"quota_alerts_enabled": False, "quota_alert_threshold": 95})
-            feed = self.tray.parse_notification_feed(self.feed(source="default"))
-            feed["events"] = []
-            with mock.patch.object(self.tray, "STATE_PATH", path), \
-                    mock.patch.object(self.tray, "post_json", return_value=(False, {})):
-                tray._handle_notifications(feed)
-                tray.save_state()
-            with open(path, encoding="utf-8") as fh:
-                saved = json.load(fh)
-            self.assertEqual(saved["quota_alerts_enabled"], False)
-            self.assertEqual(saved["quota_alert_threshold"], 95)
-            self.assertFalse(tray.legacy_notification_prefs_handled)
-
-
-class TraySourceTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.source = (
-            Path(meter.__file__).with_name("menubar").joinpath("token_meter_tray.py").read_text()
-        )
-
-    def test_linux_tray_matches_native_dashboard_routing_and_actions(self):
-        for marker in (
-            "def open_dashboard(self):",
-            'self.open_url("#sessions", include_pinned_session=False)',
-            'self.open_url("#summary")',
-            "Open Budget Settings",
-            "#settings-budgets",
-            "Open Settings",
-            "#settings",
-            "Model Prices",
-            "#model-pricing",
-            "Budgets",
-            "Get Enterprise Tokenomics",
-            "TOKENOMICS_URL",
-            "open_external_url",
-        ):
-            self.assertIn(marker, self.source)
-
-    def test_linux_tray_does_not_advertise_removed_session_trace_view(self):
-        self.assertNotIn('"Open Trace"', self.source)
-        self.assertNotIn('self.open_url("#activity")', self.source)
-
-    def test_linux_tray_exposes_tabs_title_metrics_and_notifications(self):
-        for marker in (
-            '("overview", "All")',
-            '("claude", "Claude")',
-            '("today_spend", "Today spend")',
-            'DEFAULT_TITLE_METRICS = ("cost", "speed", "today_spend")',
-            "_apply_budget_menu",
-            "for index, scope in enumerate(scopes):",
-            "self.budget_scope_items.append(item)",
-            "Menu bar title",
-            "Quota notifications",
-            "Warn at",
-            "parse_notification_feed",
-            'NOTIFICATION_CONSUMER = "token-meter-tray"',
-            '["notify-send", title, body]',
-            "Output speed:",
-            "Monthly budget:",
-            "Most constrained:",
-        ):
-            self.assertIn(marker, self.source)
-
-    def test_linux_tray_has_no_local_notification_rules(self):
-        for removed in ("def evaluate_quota_notifications", "def evaluate_budget_notifications",
-                        "fired_thresholds", '"quota_notification_states": {}'):
-            self.assertNotIn(removed, self.source)
-
-    def test_linux_tray_exposes_persisted_status_display_modes(self):
-        for marker in (
-            '"status_display_mode": "automatic"',
-            'self.status_display_mode = normalize_status_display_mode',
-            '"status_display_mode": self.status_display_mode',
-            'self.display_mode_item, self.display_mode_menu = self._submenu_item("Menu bar display")',
-            '("automatic", "Automatic")',
-            '("text", "Cost + speed text")',
-            '("icon", "Icon only")',
-            'def _on_display_mode_toggled(self, item):',
-            'status_display_label(label, self.status_display_mode)',
-        ):
-            self.assertIn(marker, self.source)
-
-
-class ProviderQuotaTests(unittest.TestCase):
-    def tearDown(self):
-        meter.reset_provider_quota_cache()
-
-    def test_pace_forecast_distinguishes_runout_reserve_and_early_window(self):
-        now = 1_000_000.0
-        base = {"window_seconds": 1000, "reset_at": now + 500}
-
-        runout = meter.quota_pace({**base, "used_percent": 70}, now=now)
-        reserve = meter.quota_pace({**base, "used_percent": 30}, now=now)
-        on_pace = meter.quota_pace({**base, "used_percent": 50}, now=now)
-        early = meter.quota_pace({"window_seconds": 1000, "reset_at": now + 980,
-                                  "used_percent": 20}, now=now)
-
-        self.assertEqual(runout["state"], "deficit")
-        self.assertFalse(runout["will_last_to_reset"])
-        self.assertIn("runs out in", runout["summary"])
-        self.assertEqual(reserve["state"], "reserve")
-        self.assertTrue(reserve["will_last_to_reset"])
-        self.assertEqual(on_pace["state"], "on_pace")
-        self.assertIsNone(early)
-
-    def test_codex_parser_preserves_main_and_named_spark_windows(self):
-        now = 1_000_000.0
-        payload = {
-            "rateLimits": {
-                "planType": "business",
-                "primary": {"usedPercent": 12, "windowDurationMins": 300,
-                            "resetsAt": now + 1800},
-                "secondary": {"usedPercent": 34, "windowDurationMins": 10080,
-                              "resetsAt": now + 3600},
-            },
-            "rateLimitsByLimitId": {
-                "codex-spark": {
-                    "limitName": "GPT-5.3-Codex-Spark",
-                    "primary": {"usedPercent": 56, "windowDurationMins": 300,
-                                "resetsAt": now + 1800},
-                    "secondary": {"usedPercent": 78, "windowDurationMins": 10080,
-                                  "resetsAt": now + 3600},
-                },
-            },
-        }
-
-        result = meter.parse_codex_quota(payload, now=now)
-
-        self.assertEqual(result["status"], "ok")
-        self.assertEqual(result["plan"], "business")
-        self.assertEqual(
-            [(row["label"], row["used_percent"]) for row in result["windows"]],
-            [("Session", 12.0), ("Weekly", 34.0),
-             ("Spark session", 56.0), ("Spark weekly", 78.0)],
-        )
-        self.assertEqual(result["coverage_note"], "")
-
-    def test_codex_parser_does_not_fabricate_absent_main_windows(self):
-        result = meter.parse_codex_quota({
-            "rate_limit": {"primary_window": None, "secondary_window": None},
-            "additional_rate_limits": [{
-                "metered_feature": "codex_spark",
-                "limit_name": "GPT-5.3-Codex-Spark",
-                "rate_limit": {
-                    "primary_window": {"used_percent": 4, "limit_window_seconds": 18000,
-                                       "reset_at": 1_001_000},
-                    "secondary_window": {"used_percent": 9, "limit_window_seconds": 604800,
-                                         "reset_at": 1_002_000},
-                },
-            }],
-        }, source="Codex OAuth API", now=1_000_000)
-
-        self.assertEqual([row["label"] for row in result["windows"]],
-                         ["Spark session", "Spark weekly"])
-        self.assertIn("Regular Session and Weekly limits were not reported by Codex",
-                      result["coverage_note"])
-        self.assertIn("missing does not mean 0%", result["coverage_note"])
-
-    def test_codex_app_server_uses_wrapper_safe_launchagent_environment(self):
-        process = mock.Mock()
-        process.stdin = mock.Mock()
-        process.stdout = mock.Mock()
-        process.poll.return_value = 0
-        selector = mock.Mock()
-        with mock.patch.object(meter, "provider_cli_path", return_value="/nvm/bin/codex"), \
-                mock.patch.object(meter, "agent_client_environment", return_value={"PATH": "/nvm/bin"}) as environment, \
-                mock.patch.object(meter.subprocess, "Popen", return_value=process) as popen, \
-                mock.patch.object(meter.selectors, "DefaultSelector", return_value=selector), \
-                mock.patch.object(meter, "_rpc_read_response", side_effect=[{}, {"rateLimits": {}}]):
-            result = meter.codex_app_server_rate_limits()
-
-        environment.assert_called_once_with("/nvm/bin/codex")
-        self.assertEqual(popen.call_args.kwargs["env"], {"PATH": "/nvm/bin"})
-        self.assertEqual(result, {"rateLimits": {}})
-
-    def test_claude_parser_maps_reported_and_scoped_windows(self):
-        now = 1_000_000.0
-        result = meter.parse_claude_quota({
-            "five_hour": {"utilization": 8, "resets_at": now + 3600},
-            "seven_day": {"utilization": 23, "resets_at": now + 7200},
-            "seven_day_opus": {"utilization": 41, "resets_at": now + 7200},
-            "limits": [{
-                "kind": "weekly_scoped", "is_active": True, "percent": 52,
-                "resets_at": now + 7200,
-                "scope": {"model": {"display_name": "Sonnet 4.5"}},
-            }],
-        }, credentials={"subscriptionType": "max"}, now=now)
-
-        self.assertEqual(result["status"], "ok")
-        self.assertEqual(result["plan"], "max")
-        self.assertEqual([row["label"] for row in result["windows"]],
-                         ["Session", "Weekly", "Opus weekly", "Sonnet 4.5 weekly"])
-        self.assertEqual(result["coverage_note"], "")
-
-    def test_claude_scoped_weekly_does_not_hide_missing_regular_weekly_limit(self):
-        result = meter.parse_claude_quota({
-            "five_hour": {"utilization": 8, "resets_at": 1_001_000},
-            "limits": [{
-                "kind": "weekly_scoped", "percent": 52, "resets_at": 1_002_000,
-                "scope": {"model": {"display_name": "Sonnet"}},
-            }],
-        }, now=1_000_000)
-
-        self.assertEqual([row["label"] for row in result["windows"]],
-                         ["Session", "Sonnet weekly"])
-        self.assertIn("Weekly limit was not reported by Claude", result["coverage_note"])
-
-    def test_third_party_claude_auth_is_explicitly_unavailable(self):
-        with mock.patch.object(meter, "claude_auth_status", return_value={
-            "loggedIn": True, "authMethod": "third_party", "apiProvider": "bedrock",
-        }), mock.patch.object(meter, "claude_oauth_credentials") as credentials:
-            result = meter.load_claude_quota(now=1_000_000)
-
-        credentials.assert_not_called()
-        self.assertEqual(result["status"], "unavailable")
-        self.assertEqual(result["plan"], "Bedrock")
-        self.assertIn("not exposed", result["error"])
-        self.assertIn("Session and Weekly limits were not reported by Claude",
-                      result["coverage_note"])
-
-    def test_cursor_parser_labels_monthly_individual_cap(self):
-        now = 1_000_000.0
-        result = meter.parse_cursor_quota({
-            "membershipType": "enterprise",
-            "billingCycleStart": now - 1000,
-            "billingCycleEnd": now + 2000,
-            "individualUsage": {
-                "plan": {"used": 0, "limit": 0},
-                "overall": {"used": 987, "limit": 100000},
-            },
-        }, now=now)
-
-        self.assertEqual(result["status"], "ok")
-        self.assertEqual(result["windows"][0]["kind"], "monthly")
-        self.assertEqual(result["windows"][0]["label"], "Plan")
-        self.assertAlmostEqual(result["windows"][0]["used_percent"], 0.99, places=2)
-        self.assertEqual(result["windows"][0]["window_seconds"], 3000)
-        self.assertIn("Session and Weekly limits were not reported by Cursor",
-                      result["coverage_note"])
-        self.assertIn("missing does not mean 0%", result["coverage_note"])
-
-    def test_cache_marks_old_provider_data_stale_and_recomputes_pace(self):
-        row = meter.quota_provider("codex", "Codex", "ok", "test", windows=[
-            meter.quota_window("codex", "codex-session", "session", "Session", 50,
-                               window_seconds=1000, reset_at=1_001_000, now=1_000_000),
-        ])
-        with meter._quota_lock:
-            meter._quota_cache["codex"] = {**row, "fetched_at": 1_000_000,
-                                            "attempted_at": 1_000_000}
-
-        result = meter.provider_quota_snapshots(
-            now=1_000_601, loaders={"codex": mock.Mock()}, start_refresh=False,
-        )[0]
-
-        self.assertEqual(result["status"], "stale")
-        self.assertTrue(result["stale"])
-        self.assertEqual(result["age_seconds"], 601)
-
-    def test_empty_cache_returns_loading_and_starts_only_one_worker(self):
-        loader = mock.Mock()
-        worker = mock.Mock()
-        with mock.patch.object(meter.threading, "Thread", return_value=worker) as thread:
-            first = meter.provider_quota_snapshots(now=1_000_000, loaders={"codex": loader})
-            second = meter.provider_quota_snapshots(now=1_000_001, loaders={"codex": loader})
-
-        self.assertEqual(first[0]["status"], "loading")
-        self.assertEqual(second[0]["status"], "loading")
-        thread.assert_called_once()
-        worker.start.assert_called_once()
-
-    def test_refresh_retains_last_good_windows_and_sanitizes_unexpected_errors(self):
-        good = meter.quota_provider("codex", "Codex", "ok", "test", windows=[
-            meter.quota_window("codex", "codex-session", "session", "Session", 44,
-                               window_seconds=1000, reset_at=1_001_000, now=1_000_000),
-        ])
-        meter.refresh_provider_quota("codex", lambda now: good, now=1_000_000)
-
-        def fail(now):
-            raise RuntimeError("secret bearer token")
-
-        result = meter.refresh_provider_quota("codex", fail, now=1_000_100)
-
-        self.assertEqual(result["status"], "error")
-        self.assertEqual(result["windows"][0]["used_percent"], 44.0)
-        self.assertEqual(result["fetched_at"], 1_000_000)
-        self.assertEqual(result["attempted_at"], 1_000_100)
-        self.assertEqual(result["error"], "Provider quota refresh failed.")
-        self.assertNotIn("secret", result["error"])
-
-
-class HealthStateTests(unittest.TestCase):
-    def test_health_uses_cached_inventory_without_discovering_sessions(self):
-        inventory = {
-            "ready": True,
-            "sources": (),
-            "count": 2400,
-            "clients": {"codex": 2300, "claude_code": 100},
-            "updated_at": 1,
-        }
-        with mock.patch.object(meter, "STATE", {"source": {"id": "ready"}}), \
-                mock.patch.object(meter, "_SOURCE_INVENTORY", inventory), \
-                mock.patch.object(meter, "page_path", return_value="/runtime/page.html"), \
-                mock.patch.object(
-                    meter, "all_session_sources",
-                    side_effect=AssertionError("health must not discover sessions"),
-                ):
-            payload, status = meter.health_state()
-
-        self.assertEqual(status, 200)
-        self.assertTrue(payload["ok"])
-        self.assertTrue(payload["state_ready"])
-        self.assertTrue(payload["inventory_ready"])
-        self.assertEqual(payload["sources"], 2400)
-        self.assertEqual(payload["source_clients"], {"codex": 2300, "claude_code": 100})
-
-    def test_health_never_exposes_local_paths(self):
-        page = os.path.join(os.path.expanduser("~"), "Library", "Token Meter", "runtime", "page.html")
-        candidates = [page, "/opt/token-meter/page.html"]
-        for found in (page, None):
-            with self.subTest(page_found=bool(found)), \
-                    mock.patch.object(meter, "STATE", {}), \
-                    mock.patch.object(meter, "page_path", return_value=found), \
-                    mock.patch.object(meter, "PAGE_CANDIDATES", candidates):
-                payload, status = meter.health_state()
-            self.assertNotIn("page_path", payload)
-            self.assertNotIn("page_candidates", payload)
-            text = json.dumps(payload)
-            for fragment in (os.path.expanduser("~"), "page.html", "/opt/token-meter"):
-                self.assertNotIn(fragment, text)
-            self.assertEqual(payload["page_ready"], bool(found))
-            self.assertEqual(status, 200 if found else 503)
-
-    def test_health_answers_runtime_ownership_without_revealing_the_path(self):
-        with tempfile.TemporaryDirectory() as directory:
-            runtime = os.path.join(directory, "runtime")
-            os.makedirs(runtime)
-            page = os.path.join(runtime, "page.html")
-            cases = (
-                (runtime, page, True),
-                (runtime + os.sep, page, True),
-                (os.path.join(directory, "other"), page, False),
-                (runtime + "-old", page, False),
-                (runtime, None, False),
-                ("relative/runtime", page, False),
-                ("x" * 5000, page, False),
-            )
-            for expected, found, owned in cases:
-                with self.subTest(expected=expected[:40], found=bool(found)), \
-                        mock.patch.object(meter, "STATE", {}), \
-                        mock.patch.object(meter, "page_path", return_value=found):
-                    payload, _ = meter.health_state(expected_runtime=expected)
-                self.assertIs(payload["runtime_matches"], owned)
-                self.assertNotIn(directory, json.dumps(payload))
-            with mock.patch.object(meter, "STATE", {}), \
-                    mock.patch.object(meter, "page_path", return_value=page):
-                self.assertNotIn("runtime_matches", meter.health_state()[0])
-
-    def test_health_route_reads_one_runtime_query_value(self):
-        def get(query):
-            handler = object.__new__(meter.H)
-            handler.path = "/health" + query
-            handler.headers = {"Host": "127.0.0.1:8722"}
-            handler._send = mock.Mock()
-            handler.send_error = mock.Mock()
-            with mock.patch.object(meter, "health_state", return_value=({"ok": True}, 200)) as health:
-                handler.do_GET()
-            return health.call_args
-
-        self.assertEqual(get(""), mock.call(expected_runtime=None))
-        self.assertEqual(get("?runtime=%2Fopt%2Ftm"), mock.call(expected_runtime="/opt/tm"))
-        self.assertEqual(get("?runtime=a&runtime=b"), mock.call(expected_runtime=""))
-
-    def test_health_marks_undiscovered_inventory_unavailable_instead_of_zero(self):
-        inventory = {
-            "ready": False, "sources": (), "count": None, "clients": {}, "updated_at": None,
-        }
-        with mock.patch.object(meter, "STATE", {}), \
-                mock.patch.object(meter, "_SOURCE_INVENTORY", inventory), \
-                mock.patch.object(meter, "page_path", return_value="/runtime/page.html"):
-            payload, status = meter.health_state()
-
-        self.assertEqual(status, 200)
-        self.assertTrue(payload["ok"])
-        self.assertFalse(payload["state_ready"])
-        self.assertFalse(payload["inventory_ready"])
-        self.assertIsNone(payload["sources"])
-        self.assertEqual(payload["source_clients"], {})
-
-    def test_current_state_returns_loading_without_competing_with_watcher(self):
-        inventory = {
-            "ready": True, "sources": (), "count": 5000, "clients": {"codex": 5000},
-            "updated_at": 1,
-        }
-        with mock.patch.object(meter, "STATE", {}), \
-                mock.patch.object(meter, "_SOURCE_INVENTORY", inventory), \
-                mock.patch.object(
-                    meter, "newest_source",
-                    side_effect=AssertionError("state request must not rediscover sessions"),
-                ), \
-                mock.patch.object(
-                    meter, "recompute",
-                    side_effect=AssertionError("state request must not rebuild history"),
-                ):
-            payload = meter.current_state()
-
-        self.assertTrue(payload["loading"])
-        self.assertIn("5,000 local sessions", payload["message"])
-
-    def test_watcher_publishes_ready_empty_state_when_no_logs_exist(self):
-        published = []
-        inventory_updates = []
-        with mock.patch.object(meter, "STATE", {}), \
-                mock.patch.object(meter, "all_session_sources", return_value=[]), \
-                mock.patch.object(
-                    meter, "publish_source_inventory",
-                    side_effect=lambda sources: inventory_updates.append(list(sources)),
-                ), \
-                mock.patch.object(
-                    meter, "refresh_cross_session_state",
-                    return_value={"sessions": [], "total_sessions": 0},
-                ), \
-                mock.patch.object(meter, "publish", side_effect=published.append), \
-                mock.patch.object(meter.time, "monotonic", return_value=3), \
-                mock.patch.object(meter.time, "sleep", side_effect=StopIteration), \
-                isolated_pricing_state():
-            with self.assertRaises(StopIteration):
-                meter.watcher()
-
-        self.assertEqual(inventory_updates, [[]])
-        self.assertEqual(len(published), 1)
-        self.assertFalse(published[0]["loading"])
-        self.assertEqual(published[0]["xsession"]["total_sessions"], 0)
-
-    def test_watcher_test_survives_leftover_repricing_state(self):
-        for leftover in ({"running": True}, {"cache_revision": "p_stale"}):
-            with self.subTest(leftover=leftover), \
-                    mock.patch.dict(meter._pricing_recalc, {"running": leftover.get("running", False)}), \
-                    mock.patch.dict(meter._pricing_state, {"cache_revision": leftover.get("cache_revision")}):
-                self.test_watcher_publishes_ready_empty_state_when_no_logs_exist()
-
-
-class MenubarSessionTests(unittest.TestCase):
-    def test_menubar_state_projects_today_cross_session_spend(self):
-        today = datetime.date.today().isoformat()
-        source = {
-            "id": "live", "provider": "codex", "label": "Codex",
-            "path": "/tmp/live.jsonl", "session": "live.jsonl", "project": "/repo",
-        }
-        state = {
-            "provider": "codex", "source": source, "session": "live.jsonl",
-            "project": "/repo", "context": {}, "cache": {}, "executions": [], "insights": [],
-        }
-        cross = {
-            "daily": [{
-                "day": today, "cost": 1.25,
-                "availability": {"cost": True},
-                "provenance": {"estimated_cost": 0.25},
-            }],
-        }
-        with mock.patch.object(meter, "STATE", state), \
-                mock.patch.object(meter, "cached_session_sources", return_value=([source], True)), \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]), \
-                mock.patch.dict(meter._xsess, {"data": cross}, clear=False):
-            payload = meter.menubar_state()
-
-        self.assertEqual(payload["today_spend"], {
-            "available": True,
-            "total_cost": 1.25,
-            "estimated": True,
-        })
-
-    def test_menubar_today_spend_keeps_unavailable_cost_unavailable(self):
-        today = datetime.date.today()
-
-        projection = meter.menubar_today_spend({"daily": [{
-            "day": today.isoformat(), "cost": 0,
-            "availability": {"cost": False},
-        }]}, today=today)
-
-        self.assertEqual(projection, {
-            "available": False,
-            "total_cost": None,
-            "estimated": False,
-        })
-
-    def test_recommendations_always_target_the_single_run_surface(self):
-        states = (
-            {"context": {"latest_pct": 0.9}, "executions": [], "insights": []},
-            {"context": {}, "last_turn_cost": 0, "executions": [],
-             "insights": [{"kind": "warn", "text": "Check this signal"}]},
-        )
-        for state in states:
-            with self.subTest(state=state):
-                self.assertEqual(meter.menubar_recommendation(state)["target"], "summary")
-
-    def test_menubar_reuses_watcher_state_for_the_live_selected_session(self):
-        source = {
-            "id": "live", "provider": "codex", "label": "Codex",
-            "path": "/tmp/live.jsonl", "session": "live.jsonl",
-            "project": "/repo", "mtime": 1,
-        }
-        state = {
-            "provider": "codex", "source": source, "session": "live.jsonl",
-            "project": "/repo", "context": {}, "cache": {},
-            "executions": [], "insights": [],
-        }
-        with mock.patch.object(meter, "STATE", state), \
-                mock.patch.object(
-                    meter, "cached_session_sources", return_value=([source], True),
-                ), \
-                mock.patch.object(
-                    meter, "recompute",
-                    side_effect=AssertionError("menu poll must reuse watcher state"),
-                ), \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
-            payload = meter.menubar_state("live")
-
-        self.assertTrue(payload["ok"])
-        self.assertEqual(payload["selection"]["selected_id"], "live")
-
-    def test_context_pulse_is_bounded_numeric_only_and_does_not_leak_trace_content(self):
-        state = {
-            "executions": [
-                {"context_pct": -0.5, "detail": "private prompt"},
-                {"context_pct": 0.251234, "tool_input": "private arguments"},
-                {"context_pct": 1.5, "path": "/private/logs/trace.jsonl"},
-                {"context_pct": None},
-                {"context_pct": "not a number"},
-                {"context_pct": True},
-            ],
-        }
-        pulse = meter.menubar_context_pulse(state, limit=2)
-
-        self.assertEqual(pulse, [0.2512, 1.0])
-        encoded = json.dumps(pulse)
-        self.assertNotIn("private", encoded)
-        self.assertNotIn("trace.jsonl", encoded)
-
-    def test_recent_sessions_are_limited_and_keep_an_older_pin_visible(self):
-        sources = [{
-            "id": f"s{idx}", "provider": "codex" if idx % 2 else "claude",
-            "label": "Codex" if idx % 2 else "Claude Code", "path": f"/tmp/s{idx}.jsonl",
-            "session": f"s{idx}.jsonl", "project": f"/repo/project-{idx}", "mtime": idx,
-            "title": f"Task {idx}",
-        } for idx in range(7)]
-
-        latest = meter.menubar_recent_sessions(sources)
-        pinned = meter.menubar_recent_sessions(sources, selected_id="s0")
-
-        self.assertEqual([row["id"] for row in latest], ["s6", "s5", "s4", "s3", "s2"])
-        self.assertEqual([row["id"] for row in pinned], ["s0", "s6", "s5", "s4", "s3"])
-        self.assertEqual(pinned[0]["name"], "Task 0")
-        self.assertNotIn("project", pinned[0])
-
-    def test_recent_sessions_use_sanitized_summary_name_when_discovery_has_no_title(self):
-        sources = [{
-            "id": "claude-session", "provider": "claude", "label": "Claude Code",
-            "path": "/tmp/claude-session.jsonl", "session": "claude-session.jsonl",
-            "project": "/repo/token-meter", "mtime": 10, "title": None,
-        }]
-        summaries = [{
-            "id": "claude-session", "provider": "claude",
-            "session_name": "Default model configuration opus 5",
-        }]
-
-        recent = meter.menubar_recent_sessions(sources, summaries=summaries)
-
-        self.assertEqual(recent[0]["name"], "Default model configuration opus 5")
-
-    def test_menubar_state_joins_recent_session_names_from_cross_session_summaries(self):
-        source = {
-            "id": "claude-session", "provider": "claude", "label": "Claude Code",
-            "path": "/tmp/claude-session.jsonl", "session": "claude-session.jsonl",
-            "project": "/repo/token-meter", "mtime": 10, "title": None,
-        }
-        state = {
-            "provider": "claude", "source": source, "session": "claude-session.jsonl",
-            "project": "/repo/token-meter", "context": {}, "cache": {}, "trace": [],
-            "insights": [], "executions": [], "throughput": {}, "live_throughput": {},
-        }
-        cross = {
-            "current_sessions": [{
-                "id": "claude-session", "provider": "claude",
-                "session_name": "Default model configuration opus 5",
-            }],
-            "sessions": [],
-        }
-        with mock.patch.object(meter, "STATE", state), \
-                mock.patch.object(meter, "cached_session_sources", return_value=([source], True)), \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]), \
-                mock.patch.dict(meter._xsess, {"data": cross}, clear=False):
-            payload = meter.menubar_state()
-
-        self.assertEqual(
-            payload["recent_sessions"][0]["name"],
-            "Default model configuration opus 5",
-        )
-
-    def test_menubar_state_uses_requested_session_and_marks_pin(self):
-        sources = [{
-            "id": "pinned", "provider": "codex", "label": "Codex", "path": "/tmp/pinned.jsonl",
-            "session": "pinned.jsonl", "project": "/repo/pinned-project", "mtime": 1, "title": "Pinned task",
-        }]
-        state = {
-            "provider": "codex", "source": sources[0], "session": "pinned.jsonl",
-            "project": "/repo/pinned-project", "context": {}, "cache": {}, "trace": [], "insights": [],
-            "executions": [{"idx": 1, "model": "gpt-5.6-sol", "context_pct": 0.2}],
-            "throughput": {"available": True, "output_tps": 42.5, "basis": "end_to_end",
-                           "sample_count": 2, "timing_coverage": 0.75},
-            "live_throughput": {"available": True, "output_tps": 18.25,
-                                "basis": "live_end_to_end", "completed_steps": 3,
-                                "measured_output_tokens": 365, "measured_seconds": 20},
-        }
-        with mock.patch.object(meter, "STATE", {"source": {"id": "live"}}), \
-                mock.patch.object(meter, "cached_session_sources", return_value=(sources, True)), \
-                mock.patch.object(meter, "cached_session_state", return_value=state), \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
-            payload = meter.menubar_state("pinned")
-
-        self.assertTrue(payload["selection"]["pinned"])
-        self.assertFalse(payload["selection"]["missing"])
-        self.assertEqual(payload["selection"]["selected_id"], "pinned")
-        self.assertEqual(payload["recent_sessions"][0]["name"], "Pinned task")
-        self.assertEqual(payload["model"], "gpt-5.6-sol")
-        self.assertEqual(payload["provider_quotas"], [])
-        self.assertEqual(payload["context_pulse"], [0.2])
-        self.assertEqual(payload["project"], "pinned-project")
-        self.assertEqual(payload["source"]["project"], "pinned-project")
-        self.assertNotIn("/repo/pinned-project", json.dumps(payload))
-        self.assertEqual(payload["throughput"], {
-            "available": True, "output_tps": 42.5, "basis": "end_to_end",
-            "sample_count": 2, "timing_coverage": 0.75,
-        })
-        self.assertEqual(payload["live_throughput"], {
-            "available": True, "output_tps": 18.25, "basis": "live_end_to_end",
-            "completed_steps": 3, "measured_output_tokens": 365,
-            "measured_seconds": 20,
-        })
-
-    def test_cold_start_does_not_rebuild_all_history_for_each_menu_poll(self):
-        with mock.patch.object(meter, "STATE", {}), \
-                mock.patch.object(meter, "cached_session_sources", return_value=([], False)), \
-                mock.patch.object(
-                    meter, "all_session_sources",
-                    side_effect=AssertionError("menu polling must not discover sessions"),
-                ), \
-                mock.patch.object(meter, "recompute") as recompute, \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
-            payload = meter.menubar_state()
-
-        recompute.assert_not_called()
-        self.assertFalse(payload["ok"])
-        self.assertEqual(payload["provider_quotas"], [])
-
-    def test_cold_start_does_not_recompute_a_persisted_pinned_session(self):
-        sources = [{
-            "id": "pinned", "provider": "codex", "label": "Codex",
-            "path": "/tmp/pinned.jsonl", "session": "pinned.jsonl",
-            "project": "/repo", "mtime": 1,
-        }]
-        with mock.patch.object(meter, "STATE", {}), \
-                mock.patch.object(meter, "cached_session_sources", return_value=(sources, True)), \
-                mock.patch.object(meter, "recompute") as recompute, \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]):
-            payload = meter.menubar_state("pinned")
-
-        recompute.assert_not_called()
-        self.assertTrue(payload["selection"]["pinned"])
-        self.assertEqual(payload["selection"]["selected_id"], "pinned")
-        self.assertFalse(payload["selection"]["missing"])
-
-    def test_menubar_uses_published_monthly_budget_when_cross_cache_rotates(self):
-        budget = {
-            "month": "2026-07", "configured": True, "budget": 1000,
-            "spend": 420, "percent": 0.42, "settings": {
-                "monthly_total": 1000, "allocations": {}, "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            },
-        }
-        with mock.patch.object(meter, "STATE", {"xsession": {"budget": budget}}), \
-                mock.patch.object(meter, "cached_session_sources", return_value=([], True)), \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value=[]), \
-                mock.patch.dict(meter._xsess, {"data": None}, clear=False):
-            payload = meter.menubar_state()
-        self.assertEqual(payload["budget"], budget)
-
-
-class DynamicCatalogTests(unittest.TestCase):
-    def test_flattens_namespace_and_legacy_functions(self):
-        catalog = meter.normalize_dynamic_tools([
-            {
-                "type": "namespace",
-                "name": "codex_app",
-                "tools": [
-                    {"name": "open_page", "deferLoading": False, "description": "Open a page"},
-                    {"name": "create_thread", "deferLoading": True, "description": "Create a thread"},
-                ],
-            },
-            {"name": "mcp__jira__search", "namespace": "jira", "deferLoading": True},
-        ])
-        self.assertEqual(
-            [row["name"] for row in catalog],
-            ["mcp__codex_app__open_page", "mcp__codex_app__create_thread", "mcp__jira__search"],
-        )
-        self.assertEqual(catalog[0]["namespace"], "codex_app")
-        self.assertEqual(catalog[2]["namespace"], "jira")
-        self.assertEqual(catalog[2]["kind"], "mcp")
-        self.assertEqual(meter.catalog_counts(catalog), {"advertised": 3, "eager": 1, "deferred": 2})
-
-    def test_embedded_image_bytes_are_not_counted_as_text(self):
-        chars = meter.observable_output_chars({"image_url": "data:image/png;base64," + "A" * 10000})
-        self.assertLess(chars, 100)
-
-
-class ClaudeDesktopDiscoveryTests(unittest.TestCase):
-    def test_default_discovery_scans_standard_and_third_party_roots(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            standard = Path(tmp) / "Claude"
-            third_party = Path(tmp) / "Claude-3p"
-            standard_metadata = standard / "claude-code-sessions" / "account" / "workspace" / "local_standard.json"
-            third_party_metadata = third_party / "local-agent-mode-sessions" / "account" / "workspace" / "local_bedrock.json"
-            standard_metadata.parent.mkdir(parents=True)
-            third_party_metadata.parent.mkdir(parents=True)
-            standard_metadata.write_text(json.dumps({"cliSessionId": "standard-cli"}))
-            third_party_metadata.write_text(json.dumps({"cliSessionId": "bedrock-cli"}))
-
-            with mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", [str(standard), str(third_party)]):
-                paths = set(meter.claude_desktop_metadata_paths())
-
-        self.assertEqual(paths, {str(standard_metadata), str(third_party_metadata)})
-
-    def test_default_discovery_recurses_below_known_session_roots(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            standard = Path(tmp) / "Claude"
-            third_party = Path(tmp) / "Claude-3p"
-            nested_metadata = (
-                standard / "local-agent-mode-sessions" / "account" / "workspace" /
-                "additional-level" / "local_nested.json"
-            )
-            unrelated_metadata = standard / "unrelated" / "local_ignore.json"
-            nested_metadata.parent.mkdir(parents=True)
-            unrelated_metadata.parent.mkdir(parents=True)
-            nested_metadata.write_text(json.dumps({"cliSessionId": "nested-cli"}))
-            unrelated_metadata.write_text(json.dumps({"cliSessionId": "ignore-cli"}))
-
-            with mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", [str(standard), str(third_party)]):
-                paths = set(meter.claude_desktop_metadata_paths())
-
-        self.assertEqual(paths, {str(nested_metadata)})
-
-    def test_default_discovery_prunes_the_non_session_skills_plugin_tree(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            standard = Path(tmp) / "Claude"
-            valid_metadata = (
-                standard / "local-agent-mode-sessions" / "account" /
-                "workspace" / "extra" / "local_session.json"
-            )
-            plugin_metadata = (
-                standard / "local-agent-mode-sessions" / "skills-plugin" /
-                "bundle" / "nested" / "local_not-a-session.json"
-            )
-            valid_metadata.parent.mkdir(parents=True)
-            plugin_metadata.parent.mkdir(parents=True)
-            valid_metadata.write_text(json.dumps({"cliSessionId": "session"}))
-            plugin_metadata.write_text(json.dumps({"cliSessionId": "plugin"}))
-
-            with mock.patch.object(
-                    meter, "CLAUDE_DESKTOP_DATA_ROOTS", [str(standard)]):
-                paths = set(meter.claude_desktop_metadata_paths())
-
-        self.assertEqual(paths, {str(valid_metadata)})
-
-    def test_indexes_desktop_metadata_by_cli_session(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "account" / "workspace" / "local_desktop-session.json"
-            path.parent.mkdir(parents=True)
-            path.write_text(json.dumps({
-                "sessionId": "local_desktop-session",
-                "cliSessionId": "cli-session-id",
-                "cwd": "/tmp/project",
-                "title": "Desktop project task",
-                "model": "claude-fable-5",
-                "lastActivityAt": 123456,
-            }))
-            idx = meter.claude_desktop_index(tmp)
-        self.assertIn("cli-session-id", idx)
-        self.assertEqual(idx["cli-session-id"]["label"], "Claude Desktop")
-        self.assertEqual(idx["cli-session-id"]["desktop_session_id"], "local_desktop-session")
-        self.assertEqual(idx["cli-session-id"]["cwd"], "/tmp/project")
-        self.assertEqual(idx["cli-session-id"]["title"], "Desktop project task")
-
-    def test_desktop_resume_id_is_the_cli_uuid_of_project_transcripts(self):
-        from token_meter.runtimes.claude import ClaudeRuntimeAdapter
-        cli_id = "0f9f0062-51be-4131-acfa-51034ef23f99"
-        cowork_id = "45892917-f18f-4f00-b89e-5e332838e372"
-        with tempfile.TemporaryDirectory() as tmp:
-            projects = Path(tmp) / "projects" / "-tmp-project"
-            projects.mkdir(parents=True)
-            (projects / f"{cli_id}.jsonl").write_text("{}\n")
-            (projects / "not-a-uuid.jsonl").write_text("{}\n")
-            agent_root = Path(tmp) / "Claude" / "local-agent-mode-sessions" / "account" / "org"
-            trace = agent_root / "local_cowork" / ".claude" / "projects" / "outputs" / f"{cowork_id}.jsonl"
-            trace.parent.mkdir(parents=True)
-            trace.write_text("{}\n")
-            (agent_root / "local_cowork.json").write_text(json.dumps({
-                "sessionId": "local_cowork", "cliSessionId": cowork_id,
-                "cwd": str(agent_root / "local_cowork" / "outputs"), "lastActivityAt": 1,
-            }))
-            adapter = ClaudeRuntimeAdapter(Path(tmp) / "projects", [Path(tmp) / "Claude"])
-            records = {row["id"]: row for row in adapter.discover_legacy(None)}
-        self.assertEqual(records[cli_id]["desktop_resume_id"], cli_id)
-        self.assertIsNone(records["not-a-uuid"]["desktop_resume_id"])
-        self.assertIsNone(records[cowork_id].get("desktop_resume_id"))
-
-    def test_discovers_no_project_agent_trace(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "local-agent-mode-sessions" / "account" / "org"
-            metadata = root / "local_agent-session.json"
-            trace = root / "local_agent-session" / ".claude" / "projects" / "outputs" / "cli-agent-id.jsonl"
-            trace.parent.mkdir(parents=True)
-            metadata.write_text(json.dumps({
-                "sessionId": "local_agent-session",
-                "cliSessionId": "cli-agent-id",
-                "cwd": str(root / "local_agent-session" / "outputs"),
-                "title": "No-project task",
-                "lastActivityAt": 123456,
-            }))
-            trace.write_text("{}\n")
-            idx = meter.claude_desktop_index(tmp)
-            sources = meter.claude_local_agent_sources(idx)
-        self.assertEqual(idx["cli-agent-id"]["source_kind"], "agent")
-        self.assertEqual(idx["cli-agent-id"]["project"], "No project")
-        self.assertEqual(len(sources), 1)
-        self.assertEqual(sources[0]["client"], "claude_desktop")
-        self.assertEqual(sources[0]["title"], "No-project task")
-
-    def test_agent_uses_user_selected_folder_as_project(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "local-agent-mode-sessions" / "account" / "org"
-            metadata = root / "local_agent-session.json"
-            metadata.parent.mkdir(parents=True)
-            metadata.write_text(json.dumps({
-                "sessionId": "local_agent-session",
-                "cliSessionId": "cli-agent-id",
-                "cwd": str(root / "local_agent-session" / "outputs"),
-                "userSelectedFolders": ["/tmp/selected-project"],
-                "lastActivityAt": 123456,
-            }))
-            idx = meter.claude_desktop_index(tmp)
-
-        self.assertEqual(idx["cli-agent-id"]["cwd"], "/tmp/selected-project")
-        self.assertEqual(idx["cli-agent-id"]["project"], "/tmp/selected-project")
-
-
-class ToolEvidenceTests(unittest.TestCase):
-    def test_tool_summary_reconciles_types_calls_and_per_execution_peak(self):
-        executions = [
-            {"idx": 1, "tools": [{"name": "exec", "namespace": "exec"}]},
-            {"idx": 2, "tools": [
-                {"name": "exec", "namespace": "exec"},
-                {"name": "wait", "namespace": "wait", "skills": ["browser"]},
-            ]},
-        ]
-        summary = meter.tool_summary(executions)
-        self.assertEqual(summary["activity"]["observed_unique"], 2)
-        self.assertEqual(summary["activity"]["total_calls"], 3)
-        self.assertEqual(summary["activity"]["peak_calls_per_execution"], 2)
-        self.assertEqual(summary["skills"], [{"name": "browser", "activations": 1}])
-        self.assertFalse(summary["execution_rows_truncated"])
-
-    def test_tool_summary_discloses_latest_execution_window(self):
-        executions = [{"idx": idx, "tools": [{"name": "exec", "namespace": "exec"}]}
-                      for idx in range(1, 82)]
-        summary = meter.tool_summary(executions)
-        self.assertEqual(summary["total_calls"], 81)
-        self.assertEqual(summary["execution_rows_total"], 81)
-        self.assertEqual(summary["execution_rows_shown"], 80)
-        self.assertEqual(summary["execution_calls_shown"], 80)
-        self.assertTrue(summary["execution_rows_truncated"])
-
-    def test_flags_tokens_once_across_oversize_repeat_and_error_rules(self):
-        calls = [
-            {**meter.tool_identity("exec_command"), "output_tokens": 9000, "ts": 100,
-             "args_fingerprint": "same", "error": False},
-            {**meter.tool_identity("exec_command"), "output_tokens": 100, "ts": 110,
-             "args_fingerprint": "same", "error": False},
-            {**meter.tool_identity("mcp__jira__search"), "output_tokens": 50, "ts": 120,
-             "args_fingerprint": "jira", "error": True},
-        ]
-        evidence = meter.summarize_tool_evidence(calls)
-        self.assertEqual(evidence["total_output_tokens"], 9150)
-        self.assertEqual(evidence["flagged_tokens"], 9150)
-        self.assertEqual(evidence["oversized_calls"], 1)
-        self.assertEqual(evidence["repeat_calls"], 1)
-        self.assertEqual(evidence["errors"], 1)
-
-    def test_global_aggregation_finds_reported_unused_mcp(self):
-        catalog = [{
-            "name": "mcp__salesforce__query", "namespace": "salesforce", "kind": "mcp",
-            "defer_loading": False, "definition_tokens": 100,
-        }]
-        rows = []
-        for idx in range(5):
-            calls = []
-            if idx == 0:
-                calls = [{**meter.tool_identity("exec_command"), "output_tokens": 9000, "ts": 100,
-                          "args_fingerprint": "one", "error": False}]
-            rows.append({
-                "id": f"s{idx}", "path": f"/tmp/s{idx}", "provider": "codex",
-                "project": "/repo", "_tool_evidence": meter.summarize_tool_evidence(calls, catalog),
-            })
-        waste = meter.global_tool_waste(rows)
-        self.assertEqual(waste["total_calls"], 1)
-        self.assertEqual(waste["oversized_calls"], 1)
-        candidate = next(row for row in waste["by_name"] if row["name"] == "mcp__salesforce__query")
-        self.assertEqual(candidate["recommendation"], "disable")
-        self.assertEqual(candidate["advertised_sessions"], 5)
-        self.assertEqual(candidate["sessions_used"], 0)
-
-    def test_tracks_eager_definition_tax_and_skill_trace_references(self):
-        calls = [{**meter.tool_identity("exec_command"), "output_tokens": 10, "ts": 100,
-                  "args_fingerprint": "x", "skills": ["execution-plan"]}]
-        catalog = [
-            {"name": "unused_eager", "namespace": "app", "kind": "tool",
-             "defer_loading": False, "definition_tokens": 120},
-            {"name": "later", "namespace": "app", "kind": "tool",
-             "defer_loading": True, "definition_tokens": 80},
-        ]
-        evidence = meter.summarize_tool_evidence(calls, catalog)
-        self.assertEqual(evidence["definition_tokens"], 200)
-        self.assertEqual(evidence["unused_eager_definition_tokens"], 120)
-        self.assertEqual(evidence["skills"][0]["name"], "execution-plan")
-
-    def test_plain_tool_names_stay_separate_by_runtime(self):
-        call = {**meter.tool_identity("read_file"), "output_tokens": 10, "ts": 100,
-                "args_fingerprint": "x", "error": False}
-        rows = [
-            {"id": "codex", "provider": "codex", "runtime": "Codex", "project": "/repo",
-             "_tool_evidence": meter.summarize_tool_evidence([call])},
-            {"id": "cursor", "provider": "cursor", "runtime": "Cursor", "project": "/repo",
-             "_tool_evidence": meter.summarize_tool_evidence([call])},
-        ]
-        waste = meter.global_tool_waste(rows)
-        tools = [row for row in waste["inventory_tools"] if row["name"] == "read_file"]
-        self.assertEqual({row["id"] for row in tools}, {"Codex::read_file", "Cursor::read_file"})
-        self.assertEqual({row["runtime"] for row in tools}, {"Codex", "Cursor"})
-        self.assertEqual(waste["provider_sessions"], {"codex": 1, "cursor": 1})
-        self.assertEqual(waste["runtime_sessions"], {"Codex": 1, "Cursor": 1})
-
-    def test_skill_name_is_inferred_from_skill_descriptor_path(self):
-        value = {"cmd": "sed -n '1,80p' /tmp/skills/execution-plan/SKILL.md"}
-        self.assertEqual(meter.skill_names_from_value(value), ["execution-plan"])
-
-    def test_native_skill_tool_input_records_the_invoked_skill(self):
-        value = {"skill": "documentation-skills:sharepoint-docs", "args": "find the policy"}
-        self.assertEqual(
-            meter.skill_names_from_value(value, "Skill"),
-            ["sharepoint-docs"],
-        )
-        self.assertEqual(meter.skill_names_from_value(value, "OtherTool"), [])
-
-    def test_native_claude_skill_call_excludes_its_pack_from_review_candidates(self):
-        objs = [{
-            "type": "assistant", "timestamp": "2026-08-05T00:00:00Z",
-            "message": {
-                "id": "message-1", "content": [{
-                    "type": "tool_use", "id": "tool-1", "name": "Skill",
-                    "input": {"skill": "sharepoint-docs"},
-                }],
-            },
-        }]
-        calls = meter.claude_tool_call_evidence(objs)
-        evidence = meter.summarize_tool_evidence(calls)
-        waste = meter.global_tool_waste([{
-            "id": "claude-session", "provider": "claude", "runtime": "Claude",
-            "project": "/repo", "_tool_evidence": evidence,
-        }])
-        usage = next(row for row in waste["skills"] if row["name"] == "sharepoint-docs")
-        groups = meter.capability_control_groups([], [{
-            "id": "sharepoint-docs", "name": "sharepoint-docs", "runtime": "Claude",
-            "plugin_id": "documentation-skills@skills-marketplace", "mutable": True,
-            "enabled": True, "reviewable": True, "used": bool(usage),
-            "activations": usage["activations"], "last_used": usage["last_used"],
-        }])
-        summary = meter.optional_capability_summary(groups)
-
-        self.assertEqual(calls[0]["skills"], ["sharepoint-docs"])
-        self.assertEqual(summary["used"], 1)
-        self.assertEqual(summary["review_candidates"], [])
-
-    def test_skill_frontmatter_parses_name_description_only(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: caveman\ndescription: Ultra-compressed communication mode\n---\n\nbody")
-            path = f.name
-        try:
-            fm = meter._skill_frontmatter(path)
-            self.assertEqual(fm, {"name": "caveman", "description": "Ultra-compressed communication mode"})
-        finally:
-            os.unlink(path)
-
-    def test_skill_frontmatter_parses_allowed_tools(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: firewall-manager\nallowed-tools: Bash, Read\n---\n\nbody")
-            path = f.name
-        try:
-            fm = meter._skill_frontmatter(path)
-            self.assertEqual(fm["allowed-tools"], "Bash, Read")
-        finally:
-            os.unlink(path)
-
-    def test_skill_frontmatter_returns_empty_for_missing_file(self):
-        fm = meter._skill_frontmatter("/nonexistent/path/SKILL.md")
-        self.assertEqual(fm, {})
-
-    def test_skill_has_measurable_capabilities_with_allowed_tools(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: firewall\ndescription: Manage firewall\nallowed-tools: Bash\n---\n\nbody")
-            path = f.name
-        try:
-            self.assertTrue(meter._skill_has_measurable_capabilities(path))
-        finally:
-            os.unlink(path)
-
-    def test_skill_without_capability_metadata_has_unknown_measurement(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: caveman\ndescription: Be terse\n---\n\nbody")
-            path = f.name
-        try:
-            self.assertFalse(meter._skill_has_measurable_capabilities(path))
-            self.assertEqual(meter._skill_measurability(path), "unknown")
-        finally:
-            os.unlink(path)
-
-    def test_skill_requires_mcp_block_is_measurable(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: sourcegraph-search\nrequires-mcp:\n  - sourcegraph\n---\n\nbody")
-            path = f.name
-        try:
-            self.assertEqual(meter._skill_measurability(path), "measurable")
-            self.assertTrue(meter._skill_has_measurable_capabilities(path))
-        finally:
-            os.unlink(path)
-
-    def test_skill_allowed_tools_block_is_measurable(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: firewall\nallowed-tools:\n  - Bash\n  - Read\n---\n\nbody")
-            path = f.name
-        try:
-            self.assertEqual(meter._skill_measurability(path), "measurable")
-        finally:
-            os.unlink(path)
-
-    def test_skill_empty_allowed_tools_is_instruction_only(self):
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as f:
-            f.write("---\nname: caveman\nallowed-tools: []\n---\n\nbody")
-            path = f.name
-        try:
-            self.assertEqual(meter._skill_measurability(path), "instruction")
-            self.assertFalse(meter._skill_has_measurable_capabilities(path))
-        finally:
-            os.unlink(path)
-
-    def test_instruction_only_skill_pack_excluded_from_review_candidates(self):
-        skill_items = [
-            {"id": "skill:claude:caveman:caveman", "name": "caveman", "runtime": "Claude",
-             "plugin_id": "caveman@skills-marketplace", "mutable": True, "enabled": True,
-             "used": False, "activations": 0, "measurement": "instruction", "reviewable": True},
-        ]
-        groups = meter.capability_control_groups([], skill_items)
-        self.assertEqual(groups[0]["unmeasurable"], True)
-        self.assertEqual(groups[0]["measurement"], "instruction")
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(summary["enabled"], 1)
-        self.assertEqual(summary["unused"], 0)
-        self.assertEqual(summary["unmeasurable_packs"], 1)
-        self.assertEqual(summary["instruction_packs"], 1)
-        self.assertEqual(summary["unknown_evidence_packs"], 0)
-        self.assertEqual(summary["review_candidates"], [])
-
-    def test_unknown_skill_pack_excluded_from_review_candidates(self):
-        skill_items = [
-            {"id": "skill:claude:unknown:unknown", "name": "unknown", "runtime": "Claude",
-             "plugin_id": "unknown@skills-marketplace", "mutable": True, "enabled": True,
-             "used": False, "activations": 0, "measurement": "unknown", "reviewable": True},
-        ]
-        groups = meter.capability_control_groups([], skill_items)
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(groups[0]["measurement"], "unknown")
-        self.assertTrue(groups[0]["unmeasurable"])
-        self.assertEqual(summary["unused"], 0)
-        self.assertEqual(summary["unknown_evidence_packs"], 1)
-        self.assertEqual(summary["review_candidates"], [])
-
-    def test_mixed_measurement_pack_is_not_a_review_candidate(self):
-        skill_items = [
-            {"id": "instruction", "name": "caveman", "runtime": "Claude",
-             "plugin_id": "mixed@skills-marketplace", "mutable": True, "enabled": True,
-             "used": False, "activations": 0, "measurement": "instruction", "reviewable": True},
-            {"id": "tool", "name": "sourcegraph", "runtime": "Claude",
-             "plugin_id": "mixed@skills-marketplace", "mutable": True, "enabled": True,
-             "used": False, "activations": 0, "measurement": "measurable", "reviewable": True},
-        ]
-        groups = meter.capability_control_groups([], skill_items)
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(groups[0]["measurement"], "unknown")
-        self.assertTrue(groups[0]["unmeasurable"])
-        self.assertEqual(summary["unused"], 0)
-        self.assertEqual(summary["review_candidates"], [])
-
-    def test_measurable_skill_pack_remains_review_candidate(self):
-        skill_items = [
-            {"id": "skill:codex:browser:browser", "name": "browser", "runtime": "Codex",
-             "plugin_id": "browser@personal", "mutable": True, "enabled": True,
-             "used": False, "activations": 0, "measurement": "measurable", "reviewable": True},
-        ]
-        groups = meter.capability_control_groups([], skill_items)
-        self.assertEqual(groups[0]["unmeasurable"], False)
-        self.assertEqual(groups[0]["measurement"], "measurable")
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(summary["unused"], 1)
-        self.assertEqual(summary["unmeasurable_packs"], 0)
-        self.assertEqual(len(summary["review_candidates"]), 1)
-
-    def test_used_skill_pack_never_unmeasurable(self):
-        skill_items = [
-            {"id": "skill:claude:caveman:caveman", "name": "caveman", "runtime": "Claude",
-             "plugin_id": "caveman@skills-marketplace", "mutable": True, "enabled": True,
-             "used": True, "activations": 3, "measurement": "instruction", "reviewable": True},
-        ]
-        groups = meter.capability_control_groups([], skill_items)
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(groups[0]["measurement"], "measurable")
-        self.assertEqual(summary["used"], 1)
-        self.assertEqual(summary["unused"], 0)
-        self.assertEqual(summary["unmeasurable_packs"], 0)
-        self.assertEqual(len(summary["review_candidates"]), 0)
-
-    def test_token_meter_diagnostics_are_accounted_but_never_recommended_for_cleanup(self):
-        calls = [{**meter.tool_identity("mcp__tokenmeter__check"), "output_tokens": 50000,
-                  "ts": 100, "args_fingerprint": "one", "error": False}]
-        rows = [{
-            "id": "s1", "path": "/tmp/s1", "provider": "codex", "project": "/repo",
-            "_tool_evidence": meter.summarize_tool_evidence(calls),
-        }]
-        waste = meter.global_tool_waste(rows)
-        diagnostic = next(row for row in waste["by_name"] if row["namespace"] == "tokenmeter")
-        self.assertTrue(diagnostic["diagnostic"])
-        self.assertEqual(diagnostic["recommendation"], "keep")
-        self.assertFalse(any("tokenmeter" in row.get("key", "") for row in waste["insights"]))
-
-
-class AgentDataContractTests(unittest.TestCase):
-    def setUp(self):
-        self.source = {
-            "id": "safe-session", "provider": "codex", "client": "codex", "label": "Codex",
-            "path": "/private/logs/secret.jsonl", "session": "secret.jsonl",
-            "project": "/Users/test/work/repository", "mtime": meter.time.time(),
-        }
-        self.state = {
-            "provider": "codex", "source": self.source, "session": "secret.jsonl",
-            "project": self.source["project"], "total_cost": 1.25, "cost_approx": True,
-            "total_tokens": 120000, "turns": 4, "last_turn_cost": 0.21,
-            "context": {"latest": 40000, "window": 200000, "latest_pct": 0.2},
-            "tools": {"total_output_tokens": 9000, "flagged_tokens": 1000, "by_name": []},
-            "executions": [{"idx": 4, "cost": 0.21, "tokens": {
-                "input": 40000, "output": 900, "retrieval": 1000,
-            }, "context_pct": 0.2}],
-            "trace": [
-                {"execution": 4, "kind": "user", "label": "User message", "detail": "private prompt"},
-                {"execution": 4, "kind": "tool_call", "label": "search", "detail": "private args"},
-                {"execution": 4, "kind": "tool_result", "label": "search", "detail": "private result", "tokens": 1000},
-            ],
-            "insights": [], "ended": False,
-        }
-
-    def test_check_matches_runtime_and_project_and_omits_content(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=self.state):
-            result = meter.agent_check(execution=4, caller={
-                "runtime": "codex", "project": "/Users/test/work/repository/subdir",
-            })
-        encoded = json.dumps(result)
-        self.assertTrue(result["ok"])
-        self.assertNotIn("project", result["selected_session"])
-        self.assertNotIn("repository", encoded)
-        self.assertEqual(result["data_scope"], "matched_current_run")
-        self.assertNotIn("private prompt", encoded)
-        self.assertNotIn("private args", encoded)
-        self.assertNotIn("private result", encoded)
-        self.assertNotIn("/private/logs", encoded)
-        self.assertLessEqual(len(result["evidence"]), 3)
-        self.assertLessEqual(len(result["execution"]["activity"]), 5)
-        selected_tools = next(row for row in result["evidence"] if row["label"] == "Selected execution tool results")
-        self.assertEqual(selected_tools["value"], 1000)
-
-    def test_default_check_does_not_present_run_wide_tool_tokens_as_latest(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=self.state):
-            result = meter.agent_check(caller={
-                "runtime": "codex", "project": "/Users/test/work/repository",
-            })
-        latest_tools = next(row for row in result["evidence"] if row["label"] == "Latest execution tool results")
-        self.assertEqual(latest_tools["value"], 1000)
-        self.assertNotEqual(latest_tools["value"], self.state["tools"]["total_output_tokens"])
-
-    def test_cost_check_answers_the_cost_question(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=self.state):
-            result = meter.agent_check(focus="cost", caller={
-                "runtime": "codex", "project": "/Users/test/work/repository",
-            })
-
-        self.assertIn("$1.25", result["answer"])
-        self.assertIn("cost", result["recommended_action"].lower())
-
-    def test_context_check_answers_the_context_question(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=self.state):
-            result = meter.agent_check(focus="context", caller={
-                "runtime": "codex", "project": "/Users/test/work/repository",
-            })
-
-        self.assertIn("20%", result["answer"])
-        self.assertIn("context", result["recommended_action"].lower())
-
-    def test_check_dashboard_url_targets_the_single_run_surface(self):
-        state = {**self.state, "context": {"latest": 180000, "window": 200000,
-                                           "latest_pct": 0.9}}
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=state):
-            result = meter.agent_check(caller={
-                "runtime": "codex", "project": "/Users/test/work/repository",
-            })
-
-        self.assertTrue(result["dashboard_url"].endswith("#summary"))
-
-    def test_tools_check_answers_the_tool_volume_question(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=self.state):
-            result = meter.agent_check(focus="tools", caller={
-                "runtime": "codex", "project": "/Users/test/work/repository",
-            })
-
-        self.assertIn("9,000", result["answer"])
-        self.assertIn("tool", result["recommended_action"].lower())
-
-    def test_next_phase_check_summarizes_all_readiness_signals(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]), \
-                mock.patch.object(meter, "recompute", return_value=self.state):
-            result = meter.agent_check(focus="next_phase", caller={
-                "runtime": "codex", "project": "/Users/test/work/repository",
-            })
-
-        self.assertIn("20%", result["answer"])
-        self.assertIn("$1.25", result["answer"])
-        self.assertIn("9,000", result["answer"])
-        self.assertIn("next phase", result["recommended_action"].lower())
-
-    def test_missing_context_percentage_is_not_described_as_zero(self):
-        state = {"context": {"latest_pct": None}, "last_turn_cost": 0,
-                 "insights": [], "executions": [], "ended": False}
-        recommendation = meter.menubar_recommendation(state)
-        verdict = meter.menubar_verdict(state, recommendation)
-        self.assertIn("not reported", verdict["detail"])
-        self.assertNotIn("Context is 0%", verdict["detail"])
-
-    def test_dashboard_omits_removed_session_tab_payloads(self):
-        state = {
-            "source": {"id": "session", "provider": "codex"},
-            "trace": [{"kind": "usage"}],
-            "insights": [{"kind": "warn"}],
-            "tools": {
-                "total_calls": 7,
-                "total_output_tokens": 1000,
-                "unique_used": 1,
-                "by_namespace": [{"namespace": "shell"}],
-                "by_name": [{"name": "exec"}],
-                "by_execution": [{"execution": 2}],
-            },
-        }
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            projected = meter.dashboard_state_payload(state)
-
-        self.assertNotIn("trace", projected)
-        self.assertNotIn("insights", projected)
-        self.assertEqual(projected["tools"]["total_calls"], 7)
-        self.assertEqual(projected["tools"]["total_output_tokens"], 1000)
-        self.assertEqual(projected["tools"]["unique_used"], 1)
-        for removed in ("by_namespace", "by_name", "by_execution"):
-            self.assertNotIn(removed, projected["tools"])
-        self.assertEqual(state["trace"], [{"kind": "usage"}])
-
-    def test_dashboard_payload_replaces_trace_paths_with_opaque_keys(self):
-        from token_meter.domain.compare import trace_key
-        current = "/Users/private-user/.codex/sessions/rollout-1.jsonl"
-        other = "/Users/private-user/.claude/projects/p/two.jsonl"
-        state = {
-            "source": {"id": "one", "path": current, "project": "~/p"},
-            "xsession": {
-                "sessions": [
-                    {"id": "one", "path": current, "project": "~/p"},
-                    {"id": "two", "path": other, "project": "~/p"},
-                ],
-                "current_sessions": [{"id": "one", "project": "~/p"}],
-                "capabilities": {
-                    "items": [],
-                    "claude_desktop": {
-                        "local_agent_sessions": 1,
-                        "roots": ["~/Library/Application Support/Claude"],
-                    },
-                },
-            },
-        }
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            projected = meter.dashboard_state_payload(state)
-
-        encoded = json.dumps(projected)
-        self.assertNotIn("private-user", encoded)
-        self.assertNotIn("path", projected["source"])
-        self.assertEqual(projected["source"]["key"], trace_key({"path": current}))
-        self.assertEqual(projected["source"]["project"], "~/p")
-        rows = projected["xsession"]["sessions"]
-        self.assertEqual([row["key"] for row in rows],
-                         [trace_key({"path": current}), trace_key({"path": other})])
-        self.assertTrue(all("path" not in row for row in rows))
-        self.assertEqual([row["project"] for row in rows], ["~/p", "~/p"])
-        self.assertEqual(projected["xsession"]["current_sessions"], [{"id": "one", "project": "~/p"}])
-        desktop = projected["xsession"]["capabilities"]["claude_desktop"]
-        self.assertNotIn("roots", desktop)
-        self.assertEqual(desktop["local_agent_sessions"], 1)
-        self.assertEqual(state["source"]["path"], current)
-        self.assertEqual(state["xsession"]["sessions"][0]["path"], current)
-        self.assertIn("roots", state["xsession"]["capabilities"]["claude_desktop"])
-
-    def test_dashboard_reprojects_agent_data_at_the_browser_boundary(self):
-        state = {
-            "source": {"id": "root", "provider": "codex"},
-            "agent_group": {
-                "root_session_id": "root", "selected_agent_id": "root",
-                "coverage": {}, "totals": {"agents": 2},
-                "agents": [{
-                    "id": "root", "kind": "root", "depth": 0,
-                    "agent_path": "/private/agent.md", "prompt": "secret",
-                }],
-                "_all_agents": [{"path": "/private/trace.jsonl"}],
-            },
-            "xsession": {
-                "agent_usage": {
-                    "totals": {"agents": 1},
-                    "models": [{
-                        "id": "model::codex", "runtime": "codex",
-                        "model": "model", "agents": 1,
-                        "session_id": "private-session",
-                    }],
-                },
-            },
-        }
-        registry = mock.Mock()
-        registry.descriptors = ()
-
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            projected = meter.dashboard_state_payload(state)
-
-        encoded = json.dumps(projected)
-        self.assertEqual(projected["agent_group"]["root_session_id"], "root")
-        self.assertEqual(
-            projected["xsession"]["agent_usage"]["models"][0]["id"],
-            "model::codex",
-        )
-        for forbidden in (
-            "/private", "secret", "_all_agents", "agent_path",
-            "private-session", "session_id\": \"private-session",
-        ):
-            self.assertNotIn(forbidden, encoded)
-
-    def _live_state_with_cross(self, cross):
-        return {
-            "ok": True,
-            "source": {"id": "root", "provider": "codex"},
-            "trace": [{"kind": "usage", "text": "PRIVATE-TRACE"}],
-            "insights": [{"text": "PRIVATE-INSIGHT"}],
-            "recommendation": "PRIVATE-RECOMMENDATION",
-            "verdict": "PRIVATE-VERDICT",
-            "tools": {
-                "total_calls": 3,
-                "by_name": [{"name": "PRIVATE-TOOL"}],
-                "by_execution": [{"execution": 1}],
-            },
-            "agent_group": {
-                "root_session_id": "root", "selected_agent_id": "root",
-                "coverage": {}, "totals": {"agents": 1},
-                "agents": [{"id": "root", "kind": "root", "depth": 0,
-                            "agent_path": "/private/agent.md", "prompt": "PRIVATE-PROMPT"}],
-                "_all_agents": [{"path": "/private/trace.jsonl"}],
-            },
-            "total_cost": 1.5,
-            "xsession": cross,
-        }
-
-    def test_dashboard_state_body_replaces_trace_paths_on_cached_and_held_polls(self):
-        from token_meter.domain.compare import trace_key
-        current = "/Users/private-user/.codex/sessions/rollout-1.jsonl"
-        other = "C:\\Users\\private-user\\.claude\\projects\\p\\two.jsonl"
-        cross = {
-            "generated_at": 100,
-            "sessions": [
-                {"id": "one", "path": current, "project": "~/p"},
-                {"id": "two", "path": other, "project": "~/p"},
-            ],
-        }
-        state = {"source": {"id": "one", "path": current}, "xsession": cross}
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            first = meter.dashboard_state_body(state)
-            full = json.loads(first)
-            again = json.loads(meter.dashboard_state_body(state))
-            held = json.loads(meter.dashboard_state_body(state, full["xsession_revision"]))
-
-        self.assertNotIn("private-user", first)
-        self.assertEqual(full["source"]["key"], trace_key({"path": current}))
-        self.assertEqual([row["key"] for row in full["xsession"]["sessions"]],
-                         [trace_key({"path": current}), trace_key({"path": other})])
-        self.assertEqual(again["xsession"], full["xsession"])
-        self.assertNotIn("xsession", held)
-        self.assertEqual(held["source"], full["source"])
-        self.assertEqual(cross["sessions"][0]["path"], current)
-
-    def test_dashboard_state_body_matches_projected_payload(self):
-        cross = {
-            "generated_at": 100,
-            "tool_waste": {"secret": True},
-            "agent_usage": {
-                "totals": {"agents": 1},
-                "models": [{"id": "model::codex", "runtime": "codex", "model": "model",
-                            "agents": 1, "session_id": "private-session"}],
-            },
-            "daily": [{"day": "2026-10-23", "cost": 2.0}],
-        }
-        state = self._live_state_with_cross(cross)
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            expected = meter.dashboard_state_payload(state)
-            body = json.loads(meter.dashboard_state_body(state))
-
-        revision = body.pop("xsession_revision")
-        self.assertTrue(revision)
-        # Discounts are attached fresh from settings, outside the cached snapshot.
-        self.assertEqual(set(body.pop("cost_discounts")), set(meter.cost_discount_settings()))
-        self.assertEqual(body, expected)
-        self.assertNotIn("tool_waste", body["xsession"])
-        encoded = json.dumps(body)
-        for forbidden in ("PRIVATE", "/private", "_all_agents", "agent_path",
-                          "private-session", "by_name", "by_execution"):
-            self.assertNotIn(forbidden, encoded)
-
-    def test_dashboard_state_body_omits_unchanged_cross_session_snapshot(self):
-        cross = {"generated_at": 100, "daily": [{"day": "2026-10-23"}]}
-        state = self._live_state_with_cross(cross)
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            first = json.loads(meter.dashboard_state_body(state))
-            revision = first["xsession_revision"]
-            state["total_cost"] = 2.5
-            repeat = json.loads(meter.dashboard_state_body(state, revision))
-            stale = json.loads(meter.dashboard_state_body(state, "older"))
-
-        self.assertNotIn("xsession", repeat)
-        self.assertTrue(repeat["xsession_unchanged"])
-        self.assertEqual(repeat["xsession_revision"], revision)
-        self.assertEqual(repeat["total_cost"], 2.5)
-        self.assertEqual(stale["xsession"], first["xsession"])
-        self.assertNotIn("xsession_unchanged", stale)
-
-    def test_dashboard_state_body_encodes_each_cross_snapshot_once(self):
-        cross = {"generated_at": 100, "daily": [{"day": "2026-10-23"}]}
-        rebuilt = {"generated_at": 100, "daily": [{"day": "2026-10-24"}]}
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            with mock.patch.object(
-                    meter, "_dashboard_public_cross",
-                    wraps=meter._dashboard_public_cross) as project:
-                first = json.loads(meter.dashboard_state_body(
-                    self._live_state_with_cross(cross)))
-                again = json.loads(meter.dashboard_state_body(
-                    self._live_state_with_cross(cross)))
-                self.assertEqual(project.call_count, 1)
-                changed = json.loads(meter.dashboard_state_body(
-                    self._live_state_with_cross(rebuilt),
-                    first["xsession_revision"],
-                ))
-                self.assertEqual(project.call_count, 2)
-
-        self.assertEqual(first["xsession_revision"], again["xsession_revision"])
-        self.assertNotEqual(changed["xsession_revision"], first["xsession_revision"])
-        self.assertEqual(changed["xsession"]["daily"], [{"day": "2026-10-24"}])
-
-    def test_dashboard_state_body_keeps_published_and_rebuilt_snapshots_encoded(self):
-        published = {"generated_at": 100, "daily": [{"day": "a"}]}
-        rebuilt = {"generated_at": 115, "daily": [{"day": "b"}]}
-        registry = mock.Mock()
-        registry.descriptors = ()
-        previous_state, saved_cache = meter.STATE, dict(meter._xsess)
-        try:
-            meter.STATE = self._live_state_with_cross(published)
-            meter._xsess["data"] = rebuilt
-            with mock.patch.object(meter, "runtime_registry", return_value=registry), \
-                    mock.patch.object(meter, "_dashboard_public_cross",
-                                      wraps=meter._dashboard_public_cross) as project:
-                revisions = [
-                    json.loads(meter.dashboard_state_body(
-                        self._live_state_with_cross(cross)))["xsession_revision"]
-                    for cross in (published, rebuilt, published, rebuilt)
-                ]
-                self.assertEqual(project.call_count, 2)
-                self.assertEqual(revisions[0], revisions[2])
-                self.assertEqual(revisions[1], revisions[3])
-                self.assertNotEqual(revisions[0], revisions[1])
-
-                replacement = {"generated_at": 130, "daily": [{"day": "c"}]}
-                meter.STATE = self._live_state_with_cross(replacement)
-                meter._xsess["data"] = replacement
-                meter.dashboard_state_body(meter.STATE)
-                cached = [entry[0] for entry in meter._dashboard_cross_cache["entries"]]
-                self.assertEqual(len(cached), 1)
-                self.assertIs(cached[0], replacement)
-        finally:
-            meter.STATE = previous_state
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-    def test_state_route_omits_cross_session_snapshot_the_client_holds(self):
-        cross = {"generated_at": 100, "daily": [{"day": "2026-10-23"}]}
-        previous = meter.STATE
-        try:
-            meter.STATE = self._live_state_with_cross(cross)
-            request = BuilderRecapEndpointTests.request
-            full, status, content_type = request(self, "/state")
-            self.assertEqual(status, 200)
-            self.assertEqual(content_type, "application/json")
-            revision = full["xsession_revision"]
-            self.assertEqual(full["xsession"]["daily"], cross["daily"])
-            held, _, _ = request(self, "/state?xsession=" + revision)
-            stale, _, _ = request(self, "/state?xsession=older")
-        finally:
-            meter.STATE = previous
-        self.assertNotIn("xsession", held)
-        self.assertTrue(held["xsession_unchanged"])
-        self.assertEqual(held["xsession_revision"], revision)
-        self.assertEqual(held["total_cost"], full["total_cost"])
-        self.assertEqual(stale["xsession"], full["xsession"])
-        for body in (full, held, stale):
-            self.assertNotIn("PRIVATE", json.dumps(body))
-
-    def test_session_route_omits_cross_session_snapshot_the_client_holds(self):
-        cross = {"generated_at": 100, "current_sessions": [{"id": "session-1"}]}
-        source = {"id": "session-1", "path": "/logs/exact.jsonl"}
-        saved_cache = dict(meter._xsess)
-
-        def get(path):
-            handler = object.__new__(meter.H)
-            handler.path = path
-            handler.headers = {"Host": "127.0.0.1:8722"}
-            sent = []
-            handler._send = lambda body, *_args, **_kwargs: sent.append(json.loads(body))
-            state = {"source": {"id": "session-1"}, "timing": {}}
-            with mock.patch.object(meter, "find_session", return_value=source), \
-                    mock.patch.object(meter, "cached_session_state", return_value=state), \
-                    mock.patch.object(meter, "selected_session_stats", return_value={}):
-                handler.do_GET()
-            return sent[0]
-
-        try:
-            meter._xsess["data"] = cross
-            full = get("/session?id=session-1&live=1")
-            held = get("/session?id=session-1&live=1&xsession=" + full["xsession_revision"])
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertEqual(full["xsession"]["current_sessions"], cross["current_sessions"])
-        self.assertFalse(full["ended"])
-        self.assertNotIn("xsession", held)
-        self.assertTrue(held["xsession_unchanged"])
-        self.assertFalse(held["ended"])
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for live polling verification")
-    def test_live_polling_reuses_only_the_snapshot_matching_its_revision(self):
-        page_path = Path(DASHBOARD_PAGE)
-        script = f"""
-const fs=require('fs'),page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start-(page.slice(start-6,start)==='async '?6:0),i+1);}}throw Error(`unclosed ${{name}}`);}}
-eval(extract('adoptXsession'));eval(extract('fetchLiveJson'));
-const urls=[];let replies=[];
-global.fetch=async url=>{{urls.push(url);const r=replies.shift();return {{ok:r.status===undefined,status:r.status||200,json:async()=>r}};}};
-(async()=>{{
- const holder={{snapshot:null,revision:''}};
- replies=[{{xsession_revision:'r1',xsession:{{n:1}}}}];
- const first=await fetchLiveJson('/state',holder,'State');
- replies=[{{xsession_revision:'r1',xsession_unchanged:true}}];
- const reused=await fetchLiveJson('/session?id=a&live=1',holder,'Session');
- holder.revision='r1';holder.snapshot={{n:1}};
- replies=[{{xsession_revision:'r2',xsession_unchanged:true}},{{xsession_revision:'r2',xsession:{{n:2}}}}];
- const mismatch=await fetchLiveJson('/state',holder,'State');
- replies=[{{status:503}}];
- let error='';try{{await fetchLiveJson('/state',holder,'State');}}catch(e){{error=e.message;}}
- console.log(JSON.stringify({{urls,first:first.xsession,reused:reused.xsession,sameObject:reused.xsession===first.xsession,
-  mismatch:mismatch.xsession,held:holder.revision,error}}));
-}})().catch(e=>{{console.error(e);process.exit(1);}});
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=False)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), {
-            "urls": [
-                "/state?xsession=",
-                "/session?id=a&live=1&xsession=r1",
-                "/state?xsession=r1",
-                "/state?xsession=",
-                "/state?xsession=r2",
-            ],
-            "first": {"n": 1},
-            "reused": {"n": 1},
-            "sameObject": True,
-            "mismatch": {"n": 2},
-            "held": "r2",
-            "error": "State request failed (503).",
-        })
-
-    def test_dashboard_state_body_without_cross_session_has_no_revision(self):
-        registry = mock.Mock()
-        registry.descriptors = ()
-        with mock.patch.object(meter, "runtime_registry", return_value=registry):
-            body = json.loads(meter.dashboard_state_body(
-                {"ok": False, "loading": True, "source": {}}, "stale",
-            ))
-        self.assertNotIn("xsession", body)
-        self.assertNotIn("xsession_unchanged", body)
-        self.assertEqual(body["xsession_revision"], "")
-
-    def test_publish_skips_serialization_without_subscribers(self):
-        state = {"ok": True, "source": {"id": "s"}}
-        previous = meter.STATE
-        try:
-            with mock.patch.object(meter.json, "dumps") as dumps:
-                meter.publish(state)
-            dumps.assert_not_called()
-            self.assertIs(meter.STATE, state)
-            q_ = meter.queue.Queue(maxsize=2)
-            with meter.subscribers_lock:
-                meter.subscribers.append(q_)
-            try:
-                meter.publish(state)
-            finally:
-                with meter.subscribers_lock:
-                    meter.subscribers.remove(q_)
-            self.assertEqual(q_.get_nowait(), "data: " + json.dumps(state) + "\n\n")
-        finally:
-            meter.STATE = previous
-
-    def test_check_refuses_to_fall_back_across_projects(self):
-        with mock.patch.object(meter, "all_session_sources", return_value=[self.source]):
-            result = meter.agent_check(caller={"runtime": "codex", "project": "/another/repository"})
-        self.assertFalse(result["ok"])
-        self.assertIn("did not fall back", result["caveat"])
-
-    def test_claude_trace_cwd_preserves_hyphenated_project_name(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "session.jsonl"
-            path.write_text(json.dumps({
-                "type": "user", "cwd": "/Users/test/Documents/github/token-meter",
-            }) + "\n")
-            cwd = meter.claude_trace_cwd(str(path))
-        self.assertEqual(cwd, "/Users/test/Documents/github/token-meter")
-
-    def test_current_run_resolution_prefers_exact_project_over_newer_parent(self):
-        now = meter.time.time()
-        exact = {**self.source, "id": "exact", "project": "/Users/test/work/repository", "mtime": now - 10}
-        parent = {**self.source, "id": "parent", "project": "/Users/test/work", "mtime": now}
-        selected, resolution = meter.resolve_agent_source(
-            caller={"runtime": "codex", "project": "/Users/test/work/repository"},
-            sources=[parent, exact],
-        )
-        self.assertEqual(selected["id"], "exact")
-        self.assertEqual(resolution, "matched")
-
-    def test_current_run_resolution_rejects_stale_implicit_match(self):
-        stale = {**self.source, "mtime": meter.time.time() - meter.AGENT_CURRENT_MAX_AGE_S - 1}
-        selected, resolution = meter.resolve_agent_source(
-            caller={"runtime": "codex", "project": "/Users/test/work/repository"},
-            sources=[stale],
-        )
-        self.assertIsNone(selected)
-        self.assertIn("No recent Codex run", resolution)
-
-    def test_usage_is_aggregate_only_and_ranked_categories_are_bounded(self):
-        cross = {
-            "daily": [{"day": time_day, "cost": 2.0, "sessions": 2,
-                       "providers": [{"provider": "codex", "cost": 2.0}],
-                       "tool_tokens": 1000, "flagged_tokens": 300}
-                      for time_day in ("2026-07-01", "2026-06-30")],
-            "sessions": [{"cost_approx": True, "title": "private title", "project": "/private/repo"}],
-            "model_mix": [{"model": f"model-{idx}", "cost": idx, "tokens": idx * 100}
-                          for idx in range(8)],
-            "tool_waste": {"by_name": [
-                {"name": f"tool-{idx}", "namespace": "safe", "output_tokens": idx * 100, "calls": idx}
-                for idx in range(8)
-            ]},
-        }
-        with mock.patch.dict(meter._xsess, {
-                "data": cross, "at": meter.time.time(), "internal_rows": (),
-        }):
-            result = meter.agent_usage(window="7d", focus="models")
-        encoded = json.dumps(result)
-        self.assertEqual(result["data_scope"], "anonymous_aggregate_history")
-        self.assertLessEqual(len(result["categories"]), 5)
-        self.assertTrue(result["dashboard_url"].endswith("/#spend"))
-        self.assertNotIn("private title", encoded)
-        self.assertNotIn("/private/repo", encoded)
-
-    def test_usage_model_categories_are_scoped_to_calendar_window(self):
-        today = datetime.date.today()
-        recent = today - datetime.timedelta(days=1)
-        outside_seven_days = today - datetime.timedelta(days=7)
-        daily = [
-            {"day": today.isoformat(), "cost": 2.0, "sessions": 1,
-             "providers": [{"provider": "codex", "cost": 2.0}]},
-            {"day": recent.isoformat(), "cost": 3.0, "sessions": 1,
-             "providers": [{"provider": "codex", "cost": 3.0}]},
-            {"day": outside_seven_days.isoformat(), "cost": 5.0, "sessions": 1,
-             "providers": [{"provider": "codex", "cost": 5.0}]},
-        ]
-        internal = {
-            "id": "one", "provider": "codex", "runtime": "Codex",
-            "availability": {"cost": True, "tokens": True},
-            "_model_daily": [
-                {"model": "model-current", "day": today.isoformat(), "cost": 2.0,
-                 "input_tokens": 100, "output_tokens": 20, "executions": 1},
-                {"model": "model-week", "day": recent.isoformat(), "cost": 3.0,
-                 "input_tokens": 200, "output_tokens": 30, "executions": 1},
-                {"model": "model-fortnight", "day": outside_seven_days.isoformat(), "cost": 5.0,
-                 "input_tokens": 300, "output_tokens": 50, "executions": 1},
-            ],
-        }
-        cross = {
-            "daily": daily, "sessions": [internal],
-            "model_mix": [{"model": "all-time", "cost": 999.0, "tokens": 999999}],
-            "tool_waste": {"by_name": []},
-        }
-
-        with mock.patch.dict(meter._xsess, {
-                "data": cross, "at": meter.time.time(), "internal_rows": (internal,),
-        }):
-            today_result = meter.agent_usage(window="today", focus="models")
-            week_result = meter.agent_usage(window="7d", focus="models")
-            fortnight_result = meter.agent_usage(window="14d", focus="models")
-
-        self.assertEqual([row["model"] for row in today_result["categories"]], ["model-current"])
-        self.assertEqual(
-            {row["model"] for row in week_result["categories"]},
-            {"model-current", "model-week"},
-        )
-        self.assertEqual(
-            {row["model"] for row in fortnight_result["categories"]},
-            {"model-current", "model-week", "model-fortnight"},
-        )
-        self.assertEqual([today_result["days_observed"], week_result["days_observed"],
-                          fortnight_result["days_observed"]], [1, 2, 3])
-
-    def test_usage_tool_categories_and_evidence_share_the_selected_window(self):
-        today = datetime.date.today()
-        recent = today - datetime.timedelta(days=1)
-        outside_seven_days = today - datetime.timedelta(days=7)
-
-        def midday(day):
-            return int(time.mktime((*day.timetuple()[:3], 12, 0, 0, 0, 0, -1)))
-
-        internal = {
-            "id": "one", "provider": "codex", "runtime": "Codex",
-            "availability": {"cost": True, "tokens": True},
-            "_tool_evidence": meter.summarize_tool_evidence([
-                {**meter.tool_identity("search"), "output_tokens": 120,
-                 "ts": midday(today), "args_fingerprint": "today", "error": False},
-                {**meter.tool_identity("fetch"), "output_tokens": 80,
-                 "ts": midday(recent), "args_fingerprint": "recent", "error": False},
-                {**meter.tool_identity("search"), "output_tokens": 500,
-                 "ts": midday(outside_seven_days), "args_fingerprint": "older", "error": False},
-            ]),
-        }
-        cross = {
-            "daily": [
-                {"day": today.isoformat(), "cost": 2.0, "sessions": 1,
-                 "providers": [{"provider": "codex", "cost": 2.0}]},
-                {"day": recent.isoformat(), "cost": 3.0, "sessions": 1,
-                 "providers": [{"provider": "codex", "cost": 3.0}]},
-                {"day": outside_seven_days.isoformat(), "cost": 5.0, "sessions": 1,
-                 "providers": [{"provider": "codex", "cost": 5.0}]},
-            ],
-            "sessions": [internal], "model_mix": [],
-            "tool_waste": {"by_name": [
-                {"name": "search", "namespace": "unknown", "output_tokens": 620, "calls": 2},
-                {"name": "fetch", "namespace": "unknown", "output_tokens": 80, "calls": 1},
-            ]},
-        }
-
-        with mock.patch.dict(meter._xsess, {
-                "data": cross, "at": meter.time.time(), "internal_rows": (internal,),
-        }):
-            today_result = meter.agent_usage(window="today", focus="tools")
-            week_result = meter.agent_usage(window="7d", focus="tools")
-            fortnight_result = meter.agent_usage(window="14d", focus="tools")
-
-        def tool_evidence(result):
-            return next(row["value"] for row in result["evidence"]
-                        if row["label"] == "Trace-observed tool results")
-
-        self.assertEqual(today_result["categories"], [{
-            "name": "search", "namespace": "search", "returned_tokens": 120, "calls": 1,
-        }])
-        self.assertEqual(tool_evidence(today_result), 120)
-        self.assertEqual(tool_evidence(week_result), 200)
-        self.assertEqual(tool_evidence(fortnight_result), 700)
-        self.assertEqual(
-            {row["name"]: row["returned_tokens"] for row in week_result["categories"]},
-            {"search": 120, "fetch": 80},
-        )
-
-    def test_usage_headline_and_action_answer_the_requested_focus(self):
-        today = datetime.date.today()
-        recent = today - datetime.timedelta(days=1)
-
-        def midday(day):
-            return int(time.mktime((*day.timetuple()[:3], 12, 0, 0, 0, 0, -1)))
-
-        internal = {
-            "id": "one", "provider": "codex", "runtime": "Codex",
-            "availability": {"cost": True, "tokens": True},
-            "_model_daily": [
-                {"model": "model-top", "day": today.isoformat(), "cost": 5.0,
-                 "input_tokens": 100, "output_tokens": 20, "executions": 1},
-                {"model": "model-top", "day": recent.isoformat(), "cost": 5.0,
-                 "input_tokens": 100, "output_tokens": 20, "executions": 1},
-            ],
-            "_tool_evidence": meter.summarize_tool_evidence([
-                {**meter.tool_identity("search"), "output_tokens": 9000,
-                 "ts": midday(today), "args_fingerprint": "today", "error": False},
-            ]),
-        }
-        cross = {
-            "daily": [
-                {"day": today.isoformat(), "cost": 5.0, "sessions": 1,
-                 "providers": [{"provider": "codex", "cost": 5.0}]},
-                {"day": recent.isoformat(), "cost": 5.0, "sessions": 1,
-                 "providers": [{"provider": "codex", "cost": 5.0}]},
-            ],
-            "sessions": [internal], "model_mix": [], "tool_waste": {"by_name": []},
-        }
-
-        with mock.patch.dict(meter._xsess, {
-                "data": cross, "at": meter.time.time(), "internal_rows": (internal,),
-        }):
-            spend = meter.agent_usage(window="7d", focus="spend")
-            models = meter.agent_usage(window="7d", focus="models")
-            tools = meter.agent_usage(window="7d", focus="tools")
-
-        self.assertIn("$10.00", spend["answer"])
-        self.assertIn("spend", spend["recommended_action"].lower())
-        self.assertIn("model-top", models["answer"])
-        self.assertIn("model", models["recommended_action"].lower())
-        self.assertIn("9,000", tools["answer"])
-        self.assertIn("tool", tools["recommended_action"].lower())
-        self.assertEqual(len({spend["answer"], models["answer"], tools["answer"]}), 3)
-
-    def _windowed_usage_fixture(self):
-        today = datetime.date.today()
-        now = meter.time.time()
-
-        def midday(days_ago):
-            day = today - datetime.timedelta(days=days_ago)
-            return day, time.mktime((*day.timetuple()[:3], 12, 0, 0, 0, 0, -1))
-
-        def source(session_id, provider, days_ago, **extra):
-            _day, ts = midday(days_ago)
-            return {"id": session_id, "provider": provider, "path": f"/missing/{session_id}.jsonl",
-                    "mtime": min(ts, now), "signature_mtime": min(ts, now), **extra}
-
-        sources = [
-            source("recent-claude", "claude", 0),
-            source("old-claude", "claude", 30),
-            source("older-codex", "codex", 40, cost_approx=True),
-            source("old-cursor", "cursor", 50),
-            source("week-codex", "codex", 6),
-        ]
-        calls = []
-
-        def summary(row, opencode_conn=None):
-            calls.append(row["id"])
-            day, ts = midday(int((today - datetime.date.fromtimestamp(row["mtime"])).days))
-            key = day.isoformat()
-            return {
-                "id": row["id"], "provider": row["provider"], "runtime": row["provider"],
-                "mtime": row["mtime"], "turns": 1, "cost_approx": bool(row.get("cost_approx")),
-                "availability": {"cost": True, "tokens": True},
-                "_day_cost": {key: 1.0}, "_model_daily": [{
-                    "model": "m-" + row["id"], "day": key, "cost": 1.0,
-                    "input_tokens": 10, "output_tokens": 2, "executions": 1,
-                }],
-            }
-
-        return sources, calls, summary
-
-    def _windowed_usage(self, sources, summary, **patches):
-        with mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}), \
-                mock.patch.object(meter, "all_session_sources", return_value=list(sources)), \
-                mock.patch.object(meter, "session_summary", side_effect=summary), \
-                mock.patch.object(meter, "cross_session", side_effect=AssertionError), \
-                contextlib.ExitStack() as stack:
-            for name, value in patches.items():
-                stack.enter_context(mock.patch.object(meter, name, value))
-            return {
-                (window, focus): meter.agent_usage(window=window, focus=focus)
-                for window in ("today", "7d", "14d")
-                for focus in ("spend", "models", "tools", "changes")
-            }
-
-    def test_windowed_usage_skips_bounded_sessions_outside_the_window(self):
-        sources, calls, summary = self._windowed_usage_fixture()
-        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 2):
-            windowed = self._windowed_usage(sources, summary)
-        self.assertNotIn("old-claude", calls)
-        self.assertNotIn("older-codex", calls)
-        self.assertIn("old-cursor", calls)
-        self.assertEqual(set(calls), {"recent-claude", "week-codex", "old-cursor"})
-
-        calls.clear()
-        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 2):
-            unfiltered = self._windowed_usage(
-                sources, summary, source_activity_bound=lambda _source: None,
-            )
-        self.assertEqual(set(calls), {source["id"] for source in sources})
-        for key, result in windowed.items():
-            with self.subTest(key=key):
-                expected = dict(unfiltered[key])
-                actual = dict(result)
-                expected.pop("as_of")
-                actual.pop("as_of")
-                self.assertEqual(actual, expected)
-        self.assertEqual(
-            [row["model"] for row in windowed[("7d", "models")]["categories"]],
-            ["m-recent-claude", "m-week-codex"],
-        )
-        self.assertEqual(windowed[("7d", "models")]["approximate_fields"], [])
-
-    def test_windowed_usage_settles_the_recent_session_list(self):
-        sources, calls, summary = self._windowed_usage_fixture()
-        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 3):
-            windowed = self._windowed_usage(sources, summary)
-        # Three recent rows need the newest out-of-window bounded session, and only it.
-        self.assertIn("old-claude", calls)
-        self.assertNotIn("older-codex", calls)
-        self.assertEqual(windowed[("7d", "models")]["approximate_fields"], [])
-
-        calls.clear()
-        with mock.patch.object(meter, "AGENT_USAGE_RECENT_SESSIONS", 4):
-            windowed = self._windowed_usage(sources, summary)
-        self.assertIn("older-codex", calls)
-        self.assertEqual(windowed[("7d", "models")]["approximate_fields"], ["cost"])
-
-    def test_usage_serves_the_previous_snapshot_while_history_reprices(self):
-        today = datetime.date.today().isoformat()
-        cross = {"daily": [{"day": today, "cost": 4.0, "sessions": 1,
-                            "providers": [{"provider": "codex", "cost": 4.0}]}],
-                 "sessions": []}
-        with mock.patch.dict(meter._xsess, {"data": cross, "at": 0.0, "internal_rows": ()}), \
-                mock.patch.object(meter, "pricing_recalculation_running", return_value=True), \
-                mock.patch.object(meter, "all_session_sources", side_effect=AssertionError):
-            result = meter.agent_usage(window="today", focus="spend")
-        self.assertIn("$4.00", result["answer"])
-
-    def test_activity_bound_uses_the_newest_tracked_time_and_only_bounded_runtimes(self):
-        with tempfile.TemporaryDirectory() as directory:
-            path = os.path.join(directory, "trace.jsonl")
-            with open(path, "w", encoding="utf-8") as handle:
-                handle.write("{}\n")
-            os.utime(path, (2_000.0, 2_000.0))
-            self.assertEqual(meter.source_activity_bound(
-                {"provider": "claude", "path": path, "mtime": 1_000.0, "signature_mtime": 1_500.0},
-            ), 2_000.0)
-            self.assertEqual(meter.source_activity_bound(
-                {"provider": "codex", "path": path, "mtime": 3_000.0},
-            ), 3_000.0)
-        for source in (
-            {"provider": "cursor", "mtime": 1.0},
-            {"provider": "claude", "mtime": float("nan")},
-            {"provider": "codex", "mtime": "bad"},
-            {"provider": "claude"},
-            None,
-        ):
-            with self.subTest(source=source):
-                self.assertIsNone(meter.source_activity_bound(source))
-
-    def test_capability_result_names_only_requested_evidence(self):
-        cross = {"capabilities": {
-            "summary": {"optional": {
-                "enabled": 2, "unused": 1,
-                "review_candidates": ["skill_pack:Codex:docs@personal"],
-            }},
-            "control_groups": [
-                {"id": "skill_pack:Codex:docs@personal", "name": "docs@personal",
-                 "control_type": "skill_pack", "runtime": "Codex", "mutable": True,
-                 "reviewable": True, "used": False, "enabled": True, "activations": 0,
-                 "environment": {"TOKEN": "secret"}},
-                {"name": "tokenmeter", "control_type": "skill_pack", "runtime": "Codex",
-                 "used": False, "enabled": True},
-            ],
-        }}
-        with mock.patch.object(meter, "agent_capability_evidence",
-                               return_value=(cross["capabilities"], {"complete": True})):
-            result = meter.agent_capabilities(scope="all", limit=5)
-        encoded = json.dumps(result)
-        self.assertEqual([row["name"] for row in result["candidates"]], ["docs@personal"])
-        self.assertNotIn("TOKEN", encoded)
-        self.assertNotIn("secret", encoded)
-
-    def test_all_scope_capabilities_returns_only_counted_review_candidates(self):
-        candidate_id = "skill_pack:Codex:z-review"
-        cross = {"capabilities": {
-            "summary": {"optional": {
-                "enabled": 1, "unused": 1, "review_candidates": [candidate_id],
-            }},
-            "control_groups": [
-                {"id": "skill_pack:Codex:a-disabled", "name": "a-disabled",
-                 "control_type": "skill_pack", "runtime": "Codex", "mutable": True,
-                 "reviewable": True, "used": False, "enabled": False},
-                {"id": candidate_id, "name": "z-review", "control_type": "skill_pack",
-                 "runtime": "Codex", "mutable": True, "reviewable": True,
-                 "used": False, "enabled": True},
-            ],
-        }}
-
-        with mock.patch.object(meter, "agent_capability_evidence",
-                               return_value=(cross["capabilities"], {"complete": True})):
-            result = meter.agent_capabilities(scope="all", limit=5)
-
-        self.assertEqual([row["name"] for row in result["candidates"]], ["z-review"])
-        self.assertEqual(result["candidate_count"], 1)
-        self.assertEqual(result["candidates_returned"], 1)
-
-    @contextlib.contextmanager
-    def cold_session_history(self, count, parse_s, discovery_s=0.0, discovery_error=None):
-        sources = [
-            {"provider": "codex", "path": f"/synthetic/{index}.jsonl", "id": str(index),
-             "mtime": float(index)}
-            for index in range(count)
-        ]
-        parsed = []
-        scanned_rows = []
-
-        def discover():
-            time.sleep(discovery_s)
-            if discovery_error is not None:
-                raise discovery_error
-            return sources
-
-        def summarize(source, opencode_conn=None):
-            if source["path"] in meter._summary_cache:
-                return meter._summary_cache[source["path"]]["row"]
-            time.sleep(parse_s)
-            parsed.append(source["path"])
-            row = {"turns": 1, "path": source["path"], "mtime": source["mtime"]}
-            meter._summary_cache[source["path"]] = {"signature": source["path"], "row": row}
-            return row
-
-        def waste(rows):
-            scanned_rows[:] = rows
-            return {}
-
-        inventory = {
-            "summary": {"optional": {"enabled": 1, "review_candidates": ["skill_pack:Codex:docs"]}},
-            "control_groups": [{"id": "skill_pack:Codex:docs", "name": "docs",
-                                "control_type": "skill_pack", "runtime": "Codex",
-                                "used": False, "enabled": True}],
-        }
-        with mock.patch.dict(meter._xsess, {"data": None}), \
-                mock.patch.dict(meter._history_scan, {"progress": None, "last_complete": None}), \
-                mock.patch.dict(meter._summary_cache, {}, clear=True), \
-                mock.patch.object(meter, "all_session_sources", side_effect=discover), \
-                mock.patch.object(meter, "canonical_aggregation_sources", side_effect=list), \
-                mock.patch.object(meter, "session_summary", side_effect=summarize), \
-                mock.patch.object(meter, "global_tool_waste", side_effect=waste), \
-                mock.patch.object(meter, "capability_inventory", return_value=inventory), \
-                mock.patch.object(meter, "cross_session", side_effect=AssertionError("full aggregate")):
-            try:
-                yield parsed, scanned_rows
-            finally:
-                # The scan thread must not outlive these patches.
-                progress = meter._history_scan["progress"]
-                if progress is not None:
-                    self.assertTrue(progress["done"].wait(10))
-
-    def wait_for_history_scan(self):
-        self.assertTrue(meter._history_scan["progress"]["done"].wait(10))
-
-    def test_cold_capabilities_answers_inside_the_client_timeout_with_partial_coverage(self):
-        self.assertLess(meter.AGENT_HISTORY_BUDGET_S, 60)
-        with self.cold_session_history(count=40, parse_s=0.1) as (parsed, scanned_rows), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0):
-            started = time.monotonic()
-            result = meter.agent_capabilities(scope="all", limit=5)
-            elapsed = time.monotonic() - started
-
-            self.assertLess(elapsed, 1.0 + 1.0)
-            coverage = result["coverage"]
-            self.assertFalse(coverage["complete"])
-            self.assertEqual(coverage["sessions_total"], 40)
-            self.assertGreater(coverage["sessions_scanned"], 0)
-            self.assertLess(coverage["sessions_scanned"], 40)
-            self.assertEqual(result["assessment"], "Partial review")
-            self.assertIn("unscanned session", result["caveat"])
-            self.assertIn(f"{coverage['sessions_scanned']} of 40", result["answer"])
-            self.assertEqual(result["evidence"][-1]["label"], "Sessions scanned")
-            # Newest sources are scanned first.
-            self.assertEqual(
-                sorted(row["mtime"] for row in scanned_rows),
-                [float(index) for index in range(40 - len(scanned_rows), 40)],
-            )
-
-            self.wait_for_history_scan()
-            again = meter.agent_capabilities(scope="all", limit=5)
-
-        self.assertEqual(again["coverage"],
-                         {"complete": True, "sessions_scanned": 40, "sessions_total": 40})
-        self.assertEqual(again["assessment"], "Review available")
-        self.assertNotIn("unscanned session", again["caveat"])
-        self.assertEqual(len(again["evidence"]), 2)
-        # The background scan parsed each session once.
-        self.assertEqual(sorted(parsed), sorted(set(parsed)))
-        self.assertEqual(len(parsed), 40)
-
-    def test_capabilities_answers_while_discovery_outlasts_the_budget(self):
-        with self.cold_session_history(count=5, parse_s=0, discovery_s=2.0) as (parsed, _rows), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.05):
-            started = time.monotonic()
-            result = meter.agent_capabilities(scope="all", limit=5)
-            elapsed = time.monotonic() - started
-
-            self.assertLess(elapsed, 1.5)
-            self.assertEqual(parsed, [])
-            self.assertFalse(result["ok"])
-            self.assertEqual(result["candidates"], [])
-            self.assertNotIn("candidate_count", result)
-            self.assertEqual(result["evidence"],
-                             [{"label": "Sessions scanned", "value": "0; discovery still running"}])
-            self.assertEqual(result["coverage"],
-                             {"complete": False, "sessions_scanned": 0, "sessions_total": None})
-
-    def test_cold_current_scope_answers_before_discovery_finishes(self):
-        with self.cold_session_history(count=3, parse_s=0, discovery_s=2.0) as (parsed, _rows), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.05), \
-                mock.patch.object(meter, "recompute", side_effect=AssertionError("no run yet")):
-            started = time.monotonic()
-            result = meter.agent_capabilities(
-                scope="current", limit=5, caller={"runtime": "codex", "project": "/synthetic"},
-            )
-            elapsed = time.monotonic() - started
-            discoveries = meter.all_session_sources.call_count
-
-        self.assertLess(elapsed, 1.5)
-        # Run resolution waits for the scan's discovery instead of starting its own.
-        self.assertEqual(discoveries, 1)
-        self.assertFalse(result["ok"])
-        self.assertEqual(result["assessment"], "History scan incomplete")
-        self.assertEqual(result["candidates"], [])
-        self.assertEqual(result["evidence"],
-                         [{"label": "Sessions scanned", "value": "0; discovery still running"}])
-        self.assertNotIn("0 of 0", json.dumps(result))
-
-    def test_current_scope_resolves_the_run_from_the_scan_discovery(self):
-        current = {"provider": "codex", "path": "/synthetic/2.jsonl", "id": "2"}
-        summary = {"enabled": 1, "groups": [
-            {"id": "skill_pack:Codex:docs", "name": "docs", "control_type": "skill_pack",
-             "runtime": "Codex", "current_used": False},
-        ]}
-        resolve = mock.Mock(return_value=(current, ""))
-        with self.cold_session_history(count=40, parse_s=0.1), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0), \
-                mock.patch.object(meter, "resolve_agent_source", resolve), \
-                mock.patch.object(meter, "recompute", return_value={"trace": []}), \
-                mock.patch.object(meter, "agent_session_summary", return_value={"id": "2"}), \
-                mock.patch.object(meter, "session_optional_capabilities", return_value=summary):
-            result = meter.agent_capabilities(scope="current", limit=5)
-            discoveries = meter.all_session_sources.call_count
-
-        self.assertEqual(discoveries, 1)
-        self.assertEqual(len(resolve.call_args.kwargs["sources"]), 40)
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["assessment"], "Partial review")
-        scanned = result["coverage"]["sessions_scanned"]
-        self.assertGreater(scanned, 0)
-        self.assertEqual(result["evidence"][-1]["value"], f"{scanned} of 40")
-        self.assertEqual([row["name"] for row in result["candidates"]], ["docs"])
-
-    def test_a_scan_thread_that_cannot_start_is_retried(self):
-        with self.cold_session_history(count=3, parse_s=0):
-            with mock.patch.object(meter.threading.Thread, "start",
-                                   side_effect=RuntimeError("can't start new thread")):
-                with self.assertRaises(RuntimeError):
-                    meter.agent_capabilities(scope="all", limit=5)
-            stuck = meter._history_scan["progress"]
-            self.assertTrue(stuck["done"].is_set())
-            result = meter.agent_capabilities(scope="all", limit=5)
-            self.assertIsNot(meter._history_scan["progress"], stuck)
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["coverage"],
-                         {"complete": True, "sessions_scanned": 3, "sessions_total": 3})
-
-    def test_cold_git_stats_withholds_totals_until_the_history_scan_completes(self):
-        project = mock.Mock(return_value={"ok": True, "projected": True})
-        spend_rows = []
-        with self.cold_session_history(count=40, parse_s=0.1) as (_parsed, _rows), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0), \
-                mock.patch.object(meter, "cached_git_delivery_candidates", return_value=()), \
-                mock.patch.object(meter, "git_delivery_ledger_candidates", return_value=()), \
-                mock.patch.object(meter, "delivery_spend_rows",
-                                  side_effect=lambda rows: spend_rows.append(
-                                      [row["mtime"] for row in rows]) or []), \
-                mock.patch.object(meter, "delivery_model_spend_rows", return_value=[]), \
-                mock.patch.object(meter, "git_delivery_service") as service, \
-                mock.patch.object(meter._mcp_delivery, "git_stats_projection", project):
-            started = time.monotonic()
-            cold = meter.agent_git_stats(range="30")
-            elapsed = time.monotonic() - started
-            self.wait_for_history_scan()
-            warm = meter.agent_git_stats(range="30")
-
-        self.assertLess(elapsed, 1.0 + 1.0)
-        self.assertTrue(cold["ok"])
-        self.assertFalse(cold["available"])
-        self.assertEqual(cold["reason"], "history_scan_incomplete")
-        self.assertFalse(cold["history"]["complete"])
-        self.assertEqual(cold["history"]["sessions_total"], 40)
-        self.assertNotIn("current", cold)
-        self.assertEqual(warm, {"ok": True, "projected": True})
-        # Totals are computed only from the complete scan, in discovery order like cross_session.
-        self.assertEqual(spend_rows, [[float(index) for index in range(40)]])
-        service.return_value.query.assert_called_once()
-
-    def test_cold_work_stats_withholds_totals_until_the_history_scan_completes(self):
-        settings = {"enabled": True, "paused_until": 0, "areas": [], "backfill_days": 0}
-        service = mock.Mock()
-        service.status.return_value = {"labels": 2, "pending": 0}
-        build = mock.Mock(return_value=({"insights": True}, None))
-        with self.cold_session_history(count=3, parse_s=0, discovery_s=2.0) as (_parsed, _rows), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.05), \
-                mock.patch.object(meter, "work_insights_supported", return_value=True), \
-                mock.patch.object(meter, "work_insights_settings", return_value=settings), \
-                mock.patch.object(meter, "work_insights_service", return_value=service), \
-                mock.patch.object(meter, "_work_insights_aggregate", build), \
-                mock.patch.object(meter._mcp_delivery, "work_stats_projection",
-                                  return_value={"ok": True, "available": True}):
-            started = time.monotonic()
-            cold = meter.agent_work_stats(period="30d", view="suggestions")
-            elapsed = time.monotonic() - started
-            self.wait_for_history_scan()
-            warm = meter.agent_work_stats(period="30d", view="suggestions")
-
-        self.assertLess(elapsed, 1.5)
-        self.assertFalse(cold["available"])
-        self.assertEqual(cold["reason"], "history_scan_incomplete")
-        self.assertEqual(cold["history"],
-                         {"complete": False, "sessions_scanned": 0, "sessions_total": None})
-        self.assertIn("withheld instead of undercounted", cold["caveat"])
-        self.assertTrue(warm["available"])
-        build.assert_called_once()
-        self.assertEqual(len(build.call_args.kwargs["source_rows"]), 3)
-
-    def test_history_scan_fills_newest_chunks_on_the_index_pool(self):
-        chunks = []
-        prefetch = mock.Mock(side_effect=lambda sources: chunks.append(
-            [int(source["id"]) for source in sources]))
-        with self.cold_session_history(count=40, parse_s=0), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_FIRST", 16), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MIN", 16), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MAX", 16), \
-                mock.patch.object(meter, "prefetch_session_summaries", prefetch):
-            result = meter.agent_capabilities(scope="all", limit=5)
-
-        self.assertTrue(result["coverage"]["complete"])
-        self.assertEqual(chunks, [list(range(39, 23, -1)), list(range(23, 7, -1)), list(range(7, -1, -1))])
-
-    def test_history_scan_shrinks_chunks_that_overrun_the_time_target(self):
-        sizes = []
-
-        def slow_fill(sources):
-            sizes.append(len(sources))
-            time.sleep(0.05)
-            return len(sources)
-
-        with self.cold_session_history(count=40, parse_s=0), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_FIRST", 16), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MIN", 4), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MAX", 64), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_TARGET_S", 0.01), \
-                mock.patch.object(meter, "prefetch_session_summaries", side_effect=slow_fill):
-            result = meter.agent_capabilities(scope="all", limit=5)
-
-        self.assertTrue(result["coverage"]["complete"])
-        # 16 sessions parsed in ~0.05 s is ~320/s, so a 0.01 s target is 3, clamped to 4.
-        self.assertEqual(sizes, [16] + [4] * 6)
-
-    def test_history_scan_never_grows_chunks_from_cached_or_tiny_fills(self):
-        sizes = []
-        returns = iter([0, 4, 40] + [0] * 20)
-
-        def fill(sources):
-            sizes.append(len(sources))
-            return next(returns)
-
-        with self.cold_session_history(count=60, parse_s=0), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_FIRST", 8), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MIN", 4), \
-                mock.patch.object(meter, "HISTORY_SCAN_CHUNK_MAX", 64), \
-                mock.patch.object(meter, "prefetch_session_summaries", side_effect=fill):
-            result = meter.agent_capabilities(scope="all", limit=5)
-
-        self.assertTrue(result["coverage"]["complete"])
-        # A cached (0) or sub-pool (4) fill keeps the size; a fast real fill at most doubles it.
-        self.assertEqual(sizes[:4], [8, 8, 8, 16])
-
-    def test_a_refresh_serves_the_last_complete_scan_while_it_runs(self):
-        with self.cold_session_history(count=5, parse_s=0) as (_parsed, _rows), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
-                mock.patch.object(meter, "HISTORY_REFRESH_WAIT_S", 0.05):
-            first = meter.agent_capabilities(scope="all", limit=5)
-            self.assertTrue(first["coverage"]["complete"])
-            self.expire_history_scan()
-            discovered = threading.Event()
-            release = threading.Event()
-
-            def slow_discovery():
-                discovered.set()
-                release.wait(5)
-                return [{"provider": "codex", "path": f"/synthetic/{index}.jsonl", "id": str(index),
-                         "mtime": float(index)} for index in range(5)]
-
-            with mock.patch.object(meter, "all_session_sources", side_effect=slow_discovery):
-                started = time.monotonic()
-                during = meter.agent_capabilities(scope="all", limit=5)
-                elapsed = time.monotonic() - started
-                release.set()
-                self.wait_for_history_scan()
-
-        self.assertTrue(discovered.is_set())
-        self.assertLess(elapsed, 1.5)
-        self.assertEqual(during["coverage"], {
-            "complete": True, "sessions_scanned": 5, "sessions_total": 5, "refreshing": True,
-        })
-        self.assertEqual(during["assessment"], "Review available")
-
-    def expire_history_scan(self):
-        meter._history_scan["progress"]["finished_at"] -= meter._XSESS_TTL + 1
-
-    def test_a_current_scope_refresh_resolves_the_run_from_the_last_complete_scan(self):
-        summary = {"enabled": 1, "groups": [
-            {"id": "skill_pack:Codex:docs", "name": "docs", "control_type": "skill_pack",
-             "runtime": "Codex", "current_used": False},
-        ]}
-        resolve = mock.Mock(return_value=({"provider": "codex", "path": "/synthetic/4.jsonl", "id": "4"}, ""))
-        release = threading.Event()
-
-        def slow_discovery():
-            release.wait(5)
-            return []
-
-        with self.cold_session_history(count=5, parse_s=0), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
-                mock.patch.object(meter, "HISTORY_REFRESH_WAIT_S", 0.05), \
-                mock.patch.object(meter, "resolve_agent_source", resolve), \
-                mock.patch.object(meter, "recompute", return_value={"trace": []}), \
-                mock.patch.object(meter, "agent_session_summary", return_value={"id": "4"}), \
-                mock.patch.object(meter, "session_optional_capabilities", return_value=summary):
-            meter.agent_capabilities(scope="current", limit=5)
-            self.expire_history_scan()
-            with mock.patch.object(meter, "all_session_sources", side_effect=slow_discovery):
-                started = time.monotonic()
-                during = meter.agent_capabilities(scope="current", limit=5)
-                elapsed = time.monotonic() - started
-                release.set()
-                self.wait_for_history_scan()
-
-        self.assertLess(elapsed, 1.5)
-        self.assertTrue(during["ok"])
-        self.assertEqual(len(resolve.call_args.kwargs["sources"]), 5)
-        self.assertTrue(during["coverage"]["refreshing"])
-
-    @contextlib.contextmanager
-    def warm_current_scope(self, previous_age_s=0.0):
-        """A process whose last complete scan finished and has expired; yields the resolve mock."""
-        summary = {"enabled": 1, "groups": [
-            {"id": "skill_pack:Codex:docs", "name": "docs", "control_type": "skill_pack",
-             "runtime": "Codex", "current_used": False},
-        ]}
-        resolve = mock.Mock(return_value=({"provider": "codex", "path": "/synthetic/4.jsonl", "id": "4"}, ""))
-        with self.cold_session_history(count=5, parse_s=0), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 1.0), \
-                mock.patch.object(meter, "HISTORY_REFRESH_WAIT_S", 0.05), \
-                mock.patch.object(meter, "resolve_agent_source", resolve), \
-                mock.patch.object(meter, "recompute", return_value={"trace": []}), \
-                mock.patch.object(meter, "agent_session_summary", return_value={"id": "4"}), \
-                mock.patch.object(meter, "session_optional_capabilities", return_value=summary), \
-                contextlib.redirect_stderr(io.StringIO()):
-            meter.agent_capabilities(scope="current", limit=5)
-            self.wait_for_history_scan()
-            previous = meter._history_scan["last_complete"]
-            self.assertIs(previous, meter._history_scan["progress"])
-            self.expire_history_scan()
-            previous["discovered_at"] -= previous_age_s
-            resolve.reset_mock()
-            yield resolve
-
-    @staticmethod
-    def fresh_sources(count):
-        return [{"provider": "codex", "path": f"/fresh/{index}.jsonl", "id": f"f{index}",
-                 "mtime": float(100 + index)} for index in range(count)]
-
-    def test_a_current_scope_refresh_that_fails_discovery_reuses_a_recent_scan_once(self):
-        with self.warm_current_scope() as resolve:
-            failing = mock.Mock(side_effect=OSError("gone"))
-            with mock.patch.object(meter, "all_session_sources", failing):
-                result = meter.agent_capabilities(scope="current", limit=5)
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(len(resolve.call_args.kwargs["sources"]), 5)
-        self.assertTrue(result["coverage"]["refreshing"])
-        # One call starts one refresh scan, even when that scan fails.
-        self.assertEqual(failing.call_count, 1)
-
-    def test_a_current_scope_refresh_with_old_sources_waits_like_a_cold_call(self):
-        with self.warm_current_scope(previous_age_s=meter.HISTORY_SOURCE_REUSE_S + 1) as resolve:
-            fresh = self.fresh_sources(3)
-
-            def discovery():
-                time.sleep(0.3)  # Longer than the refresh cap, shorter than the call budget.
-                return fresh
-
-            with mock.patch.object(meter, "all_session_sources", side_effect=discovery):
-                result = meter.agent_capabilities(scope="current", limit=5)
-                self.wait_for_history_scan()
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(resolve.call_args.kwargs["sources"], tuple(fresh))
-
-    def test_a_current_scope_refresh_never_resolves_from_old_sources(self):
-        release = threading.Event()
-        with self.warm_current_scope(previous_age_s=meter.HISTORY_SOURCE_REUSE_S + 1) as resolve:
-            with mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 0.1), \
-                    mock.patch.object(meter, "all_session_sources", side_effect=lambda: release.wait(5) and []):
-                result = meter.agent_capabilities(scope="current", limit=5)
-                release.set()
-                self.wait_for_history_scan()
-
-        self.assertFalse(result["ok"])
-        self.assertEqual(result["assessment"], "History scan incomplete")
-        resolve.assert_not_called()
-
-    def test_a_current_scope_refresh_with_old_sources_reports_failed_discovery(self):
-        with self.warm_current_scope(previous_age_s=meter.HISTORY_SOURCE_REUSE_S + 1) as resolve:
-            with mock.patch.object(meter, "all_session_sources", side_effect=OSError("gone")), \
-                    self.assertRaisesRegex(RuntimeError, "could not scan session history"):
-                meter.agent_capabilities(scope="current", limit=5)
-        resolve.assert_not_called()
-
-    def test_a_refresh_that_fails_after_discovery_resolves_from_its_own_sources(self):
-        with self.warm_current_scope() as resolve:
-            fresh = self.fresh_sources(3)
-            summarize = meter.session_summary.side_effect
-
-            def failing_summary(source, opencode_conn=None):
-                if source["path"].startswith("/fresh/"):
-                    raise ValueError("unreadable")
-                return summarize(source, opencode_conn)
-
-            with mock.patch.object(meter, "all_session_sources", return_value=fresh), \
-                    mock.patch.object(meter, "session_summary", side_effect=failing_summary):
-                result = meter.agent_capabilities(scope="current", limit=5)
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(resolve.call_args.kwargs["sources"], tuple(fresh))
-        self.assertTrue(result["coverage"]["refreshing"])
-
-    def test_a_failed_refresh_falls_back_to_the_last_complete_scan(self):
-        with self.cold_session_history(count=5, parse_s=0), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
-                contextlib.redirect_stderr(io.StringIO()):
-            meter.agent_capabilities(scope="all", limit=5)
-            self.expire_history_scan()
-            with mock.patch.object(meter, "all_session_sources", side_effect=OSError("gone")):
-                result = meter.agent_capabilities(scope="all", limit=5)
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["coverage"], {
-            "complete": True, "sessions_scanned": 5, "sessions_total": 5, "refreshing": True,
-        })
-
-    def test_capabilities_reports_a_failed_history_scan_and_retries_it(self):
-        stderr = io.StringIO()
-        with self.cold_session_history(count=3, parse_s=0, discovery_error=OSError("/secret/path boom")), \
-                mock.patch.object(meter, "AGENT_HISTORY_BUDGET_S", 5), \
-                contextlib.redirect_stderr(stderr):
-            with self.assertRaisesRegex(RuntimeError, "could not scan session history"):
-                meter.agent_capabilities(scope="all", limit=5)
-            failed = meter._history_scan["progress"]
-            with self.assertRaises(RuntimeError):
-                meter.agent_capabilities(scope="all", limit=5)
-            self.assertIsNot(meter._history_scan["progress"], failed)
-
-        self.assertIn("history scan: internal error at OSError at", stderr.getvalue())
-        self.assertNotIn("secret", stderr.getvalue())
-        self.assertNotIn("boom", stderr.getvalue())
-
-    def test_agent_result_has_a_hard_serialized_bound(self):
-        result = meter.bounded_agent_result({
-            "answer": "a" * 10000, "evidence": [{"label": "x", "value": "y" * 10000}] * 10,
-            "recommended_action": "z" * 10000, "caveat": "c" * 10000,
-        })
-        self.assertTrue(result["truncated"])
-        self.assertLessEqual(len(result["evidence"]), 2)
-
-
-class SoftwareUpdateTests(unittest.TestCase):
-    def enabled_settings(self, root):
-        path = Path(root) / "settings.json"
-        path.write_text(json.dumps({"updates": {"enabled": True}, "keep": "value"}))
-        return path
-
-    def runner(self, outputs, calls):
-        def run(command, **kwargs):
-            args = tuple(command[3:])
-            calls.append(args)
-            value = outputs.get(args)
-            if isinstance(value, int):
-                return meter.subprocess.CompletedProcess(command, value, "", "failed")
-            if value is None:
-                raise AssertionError(f"Unexpected git command: {args}")
-            return meter.subprocess.CompletedProcess(command, 0, value, "")
-        return run
-
-    def test_windows_background_git_checks_do_not_create_a_console_window(self):
-        observed = {}
-
-        def runner(command, **kwargs):
-            observed.update(kwargs)
-            return meter.subprocess.CompletedProcess(command, 0, "main\n", "")
-
-        windows = meter.platform_services(
-            "windows", environment={"USERPROFILE": r"C:\Users\example"},
-            home=r"C:\Users\example",
-        )
-        with mock.patch.object(meter, "_PLATFORM_SERVICES", windows):
-            self.assertEqual(
-                meter._run_update_git(r"C:\Token Meter", ["rev-parse", "HEAD"],
-                                      runner=runner),
-                "main",
-            )
-
-        self.assertEqual(observed["creationflags"], 0x08000000)
-        self.assertTrue(observed["close_fds"])
-
-    def test_update_setting_defaults_on_and_preserves_an_explicit_off_choice(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"model_pricing": {"claude": {}}}))
-            initial = meter.update_settings(str(path))
-            invalid = meter.set_update_settings({"enabled": "yes"}, str(path))
-            result = meter.set_update_settings(
-                {"enabled": False, "auto_install": True}, str(path)
-            )
-            stored = json.loads(path.read_text())
-            explicit = meter.update_settings(str(path))
-        self.assertTrue(initial["enabled"])
-        self.assertTrue(initial["auto_install"])
-        self.assertEqual(initial["interval_seconds"], 600)
-        self.assertFalse(invalid["ok"])
-        self.assertTrue(result["ok"])
-        self.assertFalse(explicit["enabled"])
-        self.assertFalse(explicit["auto_install"])
-        self.assertEqual(
-            stored["updates"], {"enabled": False, "auto_install": False}
-        )
-        self.assertIn("model_pricing", stored)
-
-    def test_auto_install_can_be_disabled_without_disabling_update_checks(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"keep": "value"}))
-            result = meter.set_update_settings(
-                {"enabled": True, "auto_install": False}, str(path)
-            )
-            stored = json.loads(path.read_text())
-            explicit = meter.update_settings(str(path))
-        self.assertTrue(result["ok"])
-        self.assertEqual(
-            explicit,
-            {"enabled": True, "auto_install": False, "interval_seconds": 600},
-        )
-        self.assertEqual(
-            stored,
-            {"keep": "value", "updates": {"enabled": True, "auto_install": False}},
-        )
-
-    def test_menubar_update_projection_is_bounded_and_actionable(self):
-        status = {
-            "enabled": True,
-            "auto_install": False,
-            "state": "available",
-            "available": True,
-            "can_update": True,
-            "current_revision": "a" * 40,
-            "latest_revision": "b" * 40,
-            "message": "/private/source checkout has an update",
-            "path": "/private/source",
-            "actions": {
-                "token": "local_action_token-123",
-                "check": True,
-                "install": True,
-            },
-        }
-        projected = meter.menubar_software_update(status)
-        self.assertEqual(projected, {
-            "enabled": True,
-            "auto_install": False,
-            "state": "available",
-            "available": True,
-            "can_update": True,
-            "current_revision": "a" * 40,
-            "latest_revision": "b" * 40,
-            "actions": {
-                "token": "local_action_token-123",
-                "install": True,
-            },
-        })
-        self.assertNotIn("message", projected)
-        self.assertNotIn("path", projected)
-
-    def test_update_watcher_preserves_terminal_result_for_one_interval_then_checks(self):
-        wake = mock.Mock()
-        wake.wait.side_effect = [False, RuntimeError("stop watcher")]
-        with (mock.patch.object(meter, "_update_wake", wake),
-              mock.patch.object(
-                  meter, "update_settings",
-                  return_value={"enabled": True, "auto_install": False},
-              ),
-              mock.patch.object(meter, "_update_status_record", return_value={"phase": "complete"}),
-              mock.patch.object(meter, "check_for_software_update") as check):
-            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
-                meter.software_update_watcher()
-        self.assertEqual(
-            wake.wait.call_args_list,
-            [mock.call(meter.UPDATE_CHECK_INTERVAL_S), mock.call(meter.UPDATE_CHECK_INTERVAL_S)],
-        )
-        check.assert_called_once_with()
-
-    def test_update_watcher_starts_a_safe_available_update_when_enabled(self):
-        wake = mock.Mock()
-        wake.wait.side_effect = [RuntimeError("stop watcher")]
-        available = {
-            "available": True,
-            "can_update": True,
-            "latest_revision": "b" * 40,
-        }
-        with (mock.patch.object(meter, "_update_wake", wake),
-              mock.patch.object(
-                  meter, "update_settings",
-                  return_value={"enabled": True, "auto_install": True},
-              ),
-              mock.patch.object(meter, "_update_status_record", return_value={"phase": "current"}),
-              mock.patch.object(
-                  meter, "check_for_software_update", return_value=available,
-              ) as check,
-              mock.patch.object(meter, "start_software_update") as start):
-            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
-                meter.software_update_watcher()
-        check.assert_called_once_with()
-        start.assert_called_once_with()
-
-    def test_update_watcher_keeps_checking_when_auto_install_is_disabled(self):
-        wake = mock.Mock()
-        wake.wait.side_effect = [RuntimeError("stop watcher")]
-        available = {
-            "available": True,
-            "can_update": True,
-            "latest_revision": "b" * 40,
-        }
-        with (mock.patch.object(meter, "_update_wake", wake),
-              mock.patch.object(
-                  meter, "update_settings",
-                  return_value={"enabled": True, "auto_install": False},
-              ),
-              mock.patch.object(meter, "_update_status_record", return_value={"phase": "current"}),
-              mock.patch.object(
-                  meter, "check_for_software_update", return_value=available,
-              ) as check,
-              mock.patch.object(meter, "start_software_update") as start):
-            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
-                meter.software_update_watcher()
-        check.assert_called_once_with()
-        start.assert_not_called()
-
-    def test_update_watcher_does_not_repeat_the_same_failed_revision(self):
-        wake = mock.Mock()
-        wake.wait.side_effect = [RuntimeError("stop watcher")]
-        target = "b" * 40
-        available = {
-            "available": True,
-            "can_update": True,
-            "latest_revision": target,
-        }
-        record = {"phase": "available", "failed_revision": target}
-        with (mock.patch.object(meter, "_update_wake", wake),
-              mock.patch.object(
-                  meter, "update_settings",
-                  return_value={"enabled": True, "auto_install": True},
-              ),
-              mock.patch.object(meter, "_update_status_record", return_value=record),
-              mock.patch.object(
-                  meter, "check_for_software_update", return_value=available,
-              ),
-              mock.patch.object(meter, "start_software_update") as start):
-            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
-                meter.software_update_watcher()
-        start.assert_not_called()
-
-    def test_automatic_check_fetches_and_reports_a_clean_fast_forward_update(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            calls = []
-            outputs = {
-                ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"):
-                    "origin/main\n",
-                ("rev-parse", "--abbrev-ref", "HEAD"): "main\n",
-                ("fetch", "--quiet", "--prune", "--no-tags", "origin"): "",
-                ("rev-parse", "HEAD"): "a" * 40,
-                ("rev-parse", "@{upstream}"): "b" * 40,
-                ("rev-list", "--left-right", "--count", "HEAD...@{upstream}"): "0\t2\n",
-                ("status", "--porcelain"): "",
-            }
-            with mock.patch.object(meter.shutil, "which", return_value="/usr/bin/git"):
-                status = meter.check_for_software_update(
-                    checkout=tmp,
-                    runner=self.runner(outputs, calls),
-                    now=1234,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-        self.assertEqual(status["state"], "available")
-        self.assertTrue(status["available"])
-        self.assertTrue(status["can_update"])
-        self.assertEqual(status["current_revision"], "a" * 40)
-        self.assertEqual(status["latest_revision"], "b" * 40)
-        self.assertEqual(status["behind"], 2)
-        self.assertEqual(status["next_check_at"], 1834)
-        self.assertIn(("fetch", "--quiet", "--prune", "--no-tags", "origin"), calls)
-        self.assertNotIn(tmp, json.dumps(status))
-
-    def test_available_update_fails_closed_when_checkout_is_dirty(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            outputs = {
-                ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"):
-                    "origin/main\n",
-                ("rev-parse", "--abbrev-ref", "HEAD"): "main\n",
-                ("fetch", "--quiet", "--prune", "--no-tags", "origin"): "",
-                ("rev-parse", "HEAD"): "a" * 40,
-                ("rev-parse", "@{upstream}"): "b" * 40,
-                ("rev-list", "--left-right", "--count", "HEAD...@{upstream}"): "0 1",
-                ("status", "--porcelain"): " M page.html\n",
-            }
-            with mock.patch.object(meter.shutil, "which", return_value="/usr/bin/git"):
-                status = meter.check_for_software_update(
-                    checkout=tmp,
-                    runner=self.runner(outputs, []),
-                    now=1234,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-        self.assertEqual(status["state"], "attention")
-        self.assertTrue(status["available"])
-        self.assertFalse(status["can_update"])
-        self.assertTrue(status["dirty"])
-        self.assertIn("local changes", status["message"])
-
-    def test_automatic_update_rejects_a_checkout_not_on_main(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            outputs = {
-                ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"):
-                    "origin/feature\n",
-                ("rev-parse", "--abbrev-ref", "HEAD"): "feature\n",
-            }
-            with mock.patch.object(meter.shutil, "which", return_value="/usr/bin/git"):
-                status = meter.check_for_software_update(
-                    checkout=tmp,
-                    runner=self.runner(outputs, []),
-                    now=1234,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-        self.assertEqual(status["state"], "attention")
-        self.assertFalse(status["can_update"])
-        self.assertIn("main", status["message"])
-
-    def test_linux_helper_failure_has_an_actionable_bounded_status(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            meter._persist_update_status({
-                "phase": "failed",
-                "error_code": "linux_helper_unavailable",
-                "checked_at": 1234,
-                "available": False,
-                "can_update": False,
-            }, str(status_path))
-            status = meter.software_update_status(
-                settings_path=str(settings_path), status_path=str(status_path),
-            )
-
-        self.assertEqual(status["state"], "attention")
-        self.assertEqual(
-            status["message"],
-            "The installed Linux update helper is unavailable. Reinstall Token Meter to repair automatic updates.",
-        )
-        self.assertNotIn(tmp, json.dumps(status))
-
-    def test_explicit_install_starts_only_the_bounded_detached_helper(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            meter._persist_update_status({
-                "phase": "available",
-                "current_revision": "a" * 40,
-                "latest_revision": "b" * 40,
-                "checked_at": 1234,
-                "available": True,
-                "can_update": True,
-                "ahead": 0,
-                "behind": 1,
-                "dirty": False,
-            }, str(status_path))
-            popen = mock.Mock()
-            macos = meter.platform_services("darwin", environment={}, home=tmp)
-            with (mock.patch.object(meter, "source_checkout_path", return_value=tmp),
-                  mock.patch.object(meter, "_PLATFORM_SERVICES", macos),
-                  mock.patch.object(meter.os.path, "isfile", return_value=True),
-                  mock.patch.object(meter.os, "access", return_value=True)):
-                result = meter.start_software_update(
-                    popen=popen,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-            command = popen.call_args.args[0]
-            kwargs = popen.call_args.kwargs
-        self.assertTrue(result["ok"])
-        self.assertTrue(command[0].endswith("/scripts/update"))
-        self.assertEqual(command[1:], [tmp, str(status_path)])
-        self.assertTrue(kwargs["start_new_session"])
-        self.assertTrue(kwargs["close_fds"])
-        self.assertNotIn("cwd", kwargs)
-        self.assertNotIn(tmp, json.dumps(result))
-
-    def test_windows_install_starts_the_helper_outside_the_runtime_it_replaces(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            checkout = os.path.join(tmp, "source")
-            os.mkdir(checkout)
-            meter._persist_update_status({
-                "phase": "available",
-                "current_revision": "a" * 40,
-                "latest_revision": "b" * 40,
-                "checked_at": 1234,
-                "available": True,
-                "can_update": True,
-                "ahead": 0,
-                "behind": 1,
-                "dirty": False,
-            }, str(status_path))
-            popen = mock.Mock()
-            windows = meter.platform_services("windows", environment={}, home=tmp)
-            with (mock.patch.object(meter, "source_checkout_path", return_value=checkout),
-                  mock.patch.object(meter, "_PLATFORM_SERVICES", windows),
-                  mock.patch.object(meter.os.path, "isfile", return_value=True)):
-                result = meter.start_software_update(
-                    popen=popen,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-            command = popen.call_args.args[0]
-            kwargs = popen.call_args.kwargs
-        self.assertTrue(result["ok"])
-        self.assertEqual(command[0], "powershell.exe")
-        self.assertEqual(command[-2:], [checkout, str(status_path)])
-        self.assertEqual(kwargs["cwd"], checkout)
-        # CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP; DETACHED_PROCESS stops
-        # Windows PowerShell before the helper runs.
-        self.assertEqual(kwargs["creationflags"], 0x08000200)
-
-    def test_windows_install_refuses_a_checkout_that_disappeared(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            meter._persist_update_status({
-                "phase": "available",
-                "current_revision": "a" * 40,
-                "latest_revision": "b" * 40,
-                "checked_at": 1234,
-                "available": True,
-                "can_update": True,
-                "ahead": 0,
-                "behind": 1,
-                "dirty": False,
-            }, str(status_path))
-            popen = mock.Mock()
-            windows = meter.platform_services("windows", environment={}, home=tmp)
-            with (mock.patch.object(meter, "source_checkout_path",
-                                    return_value=os.path.join(tmp, "missing")),
-                  mock.patch.object(meter, "_PLATFORM_SERVICES", windows),
-                  mock.patch.object(meter.os.path, "isfile", return_value=True)):
-                result = meter.start_software_update(
-                    popen=popen,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-            phase = meter._update_status_record(str(status_path)).get("phase")
-        self.assertFalse(result["ok"])
-        self.assertEqual(result["error"], "The installed updater is unavailable.")
-        popen.assert_not_called()
-        self.assertEqual(phase, "available")
-
-    def test_linux_install_launches_the_helper_as_a_transient_user_unit(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            target = "b" * 40
-            meter._persist_update_status({
-                "phase": "failed",
-                "error_code": "update_interrupted",
-                "current_revision": "a" * 40,
-                "latest_revision": target,
-                "failed_revision": target,
-                "checked_at": 1234,
-                "available": True,
-                "can_update": False,
-            }, str(status_path))
-            popen = mock.Mock()
-            linux = meter.platform_services(
-                "linux", environment={"INVOCATION_ID": "a" * 32}, home=tmp,
-            )
-            with (mock.patch.object(meter, "source_checkout_path", return_value=tmp),
-                  mock.patch.object(meter, "_PLATFORM_SERVICES", linux),
-                  mock.patch("token_meter.platforms.linux.shutil.which",
-                             return_value="/usr/bin/systemd-run"),
-                  mock.patch.object(meter.os.path, "isfile", return_value=True),
-                  mock.patch.object(meter.os, "access", return_value=True)):
-                result = meter.start_software_update(
-                    popen=popen,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-            command = popen.call_args.args[0]
-        self.assertTrue(result["ok"])
-        self.assertEqual(command[:2], ["/usr/bin/systemd-run", "--user"])
-        self.assertIn("--setenv=TOKEN_METER_UPDATE_RETRY_REVISION=" + target, command)
-        separator = command.index("--")
-        self.assertTrue(command[separator + 1].endswith("/scripts/update"))
-        self.assertEqual(command[separator + 2:], [tmp, str(status_path)])
-
-    def test_stale_in_progress_update_becomes_a_retryable_interruption(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            target = "b" * 40
-            record = {
-                "phase": "installing",
-                "current_revision": target,
-                "latest_revision": target,
-                "previous_revision": "a" * 40,
-                "checked_at": 1000,
-                "started_at": 1001,
-                "available": True,
-                "can_update": False,
-            }
-            meter._persist_update_status(record, str(status_path))
-            fresh = meter._recover_stale_update(
-                record, now=1001 + meter.UPDATE_STALE_AFTER_S - 1,
-                status_path=str(status_path),
-            )
-            still_installing = json.loads(status_path.read_text())["phase"]
-            recovered = meter._recover_stale_update(
-                record, now=1001 + meter.UPDATE_STALE_AFTER_S,
-                status_path=str(status_path),
-            )
-            stored = json.loads(status_path.read_text())
-            status = meter.software_update_status(
-                settings_path=str(settings_path), status_path=str(status_path),
-            )
-        self.assertFalse(fresh)
-        self.assertEqual(still_installing, "installing")
-        self.assertTrue(recovered)
-        self.assertEqual(stored["phase"], "failed")
-        self.assertEqual(stored["error_code"], "update_interrupted")
-        self.assertEqual(stored["failed_revision"], target)
-        self.assertEqual(stored["previous_revision"], "a" * 40)
-        self.assertEqual(status["state"], "attention")
-        self.assertIn("stopped before it finished", status["message"])
-
-    def test_stale_check_falls_back_to_checked_at_and_needs_a_timestamp(self):
-        """The Windows helper writes in-progress records without started_at."""
-        with tempfile.TemporaryDirectory() as tmp:
-            status_path = str(Path(tmp) / "update-status.json")
-            windows_record = {
-                "phase": "installing", "checked_at": 1000, "latest_revision": "b" * 40,
-            }
-            meter._persist_update_status(windows_record, status_path)
-            fresh = meter._recover_stale_update(
-                windows_record, now=1005, status_path=status_path,
-            )
-            undated = meter._recover_stale_update(
-                {"phase": "fetching"}, now=10 ** 9, status_path=status_path,
-            )
-            still_installing = json.loads(Path(status_path).read_text())["phase"]
-            stale = meter._recover_stale_update(
-                windows_record, now=1000 + meter.UPDATE_STALE_AFTER_S,
-                status_path=status_path,
-            )
-            stored = json.loads(Path(status_path).read_text())
-        self.assertFalse(fresh)
-        self.assertFalse(undated)
-        self.assertEqual(still_installing, "installing")
-        self.assertTrue(stale)
-        self.assertEqual(stored["error_code"], "update_interrupted")
-
-    def test_update_watcher_waits_on_a_fresh_in_progress_update(self):
-        wake = mock.Mock()
-        wake.wait.side_effect = [None, RuntimeError("stop watcher")]
-        fresh = {"phase": "installing", "started_at": int(time.time())}
-        with (mock.patch.object(meter, "_update_wake", wake),
-              mock.patch.object(
-                  meter, "update_settings",
-                  return_value={"enabled": True, "auto_install": False},
-              ),
-              mock.patch.object(meter, "_update_status_record", return_value=fresh),
-              mock.patch.object(meter, "_persist_update_status") as persist,
-              mock.patch.object(meter, "check_for_software_update") as check):
-            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
-                meter.software_update_watcher()
-        persist.assert_not_called()
-        self.assertEqual(wake.wait.call_args_list, [mock.call(5), mock.call(5)])
-        check.assert_not_called()
-
-    def test_update_watcher_recovers_a_stale_in_progress_update(self):
-        wake = mock.Mock()
-        wake.wait.side_effect = [RuntimeError("stop watcher")]
-        stale = {"phase": "installing", "started_at": 1}
-        with (mock.patch.object(meter, "_update_wake", wake),
-              mock.patch.object(
-                  meter, "update_settings",
-                  return_value={"enabled": True, "auto_install": False},
-              ),
-              mock.patch.object(
-                  meter, "_update_status_record",
-                  side_effect=[stale, {"phase": "failed"}],
-              ),
-              mock.patch.object(meter, "_persist_update_status", return_value=True) as persist,
-              mock.patch.object(meter, "check_for_software_update") as check):
-            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
-                meter.software_update_watcher()
-        self.assertEqual(persist.call_args.args[0]["error_code"], "update_interrupted")
-        self.assertEqual(wake.wait.call_args_list, [mock.call(meter.UPDATE_CHECK_INTERVAL_S)])
-        check.assert_not_called()
-
-    def test_explicit_install_retries_a_failed_current_revision(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            target = "b" * 40
-            meter._persist_update_status({
-                "phase": "failed",
-                "error_code": "install_failed",
-                "current_revision": target,
-                "latest_revision": target,
-                "previous_revision": "a" * 40,
-                "failed_revision": target,
-                "checked_at": 1234,
-                "available": False,
-                "can_update": False,
-            }, str(status_path))
-            popen = mock.Mock()
-            with (mock.patch.object(meter, "source_checkout_path", return_value=tmp),
-                  mock.patch.object(meter.os.path, "isfile", return_value=True),
-                  mock.patch.object(meter.os, "access", return_value=True)):
-                result = meter.start_software_update(
-                    popen=popen,
-                    settings_path=str(settings_path),
-                    status_path=str(status_path),
-                )
-            retry_environment = popen.call_args.kwargs["env"]
-        self.assertTrue(result["ok"])
-        self.assertEqual(
-            retry_environment["TOKEN_METER_UPDATE_RETRY_REVISION"], target
-        )
-
-    def test_manual_check_cannot_overwrite_an_install_in_progress(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            settings_path = self.enabled_settings(tmp)
-            status_path = Path(tmp) / "update-status.json"
-            meter._persist_update_status({
-                "phase": "installing",
-                "current_revision": "b" * 40,
-                "latest_revision": "b" * 40,
-                "available": True,
-                "can_update": False,
-            }, str(status_path))
-            result = meter.trigger_software_update_check(
-                settings_path=str(settings_path),
-                status_path=str(status_path),
-            )
-            stored = json.loads(status_path.read_text())
-        self.assertFalse(result["ok"])
-        self.assertIn("already in progress", result["error"])
-        self.assertEqual(stored["phase"], "installing")
-
-
-class InstallationTests(unittest.TestCase):
-    def test_menu_bar_launcher_builds_a_stable_background_app_bundle(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "run-menubar").read_text()
-        info = plistlib.loads((root / "menubar" / "Info.plist").read_bytes())
-        self.assertIn('APP="$ROOT/.build/Token Meter Menu Bar.app"', script)
-        self.assertIn('ditto "$ROOT/menubar/Info.plist" "$INFO"', script)
-        self.assertIn('exec "$BIN"', script)
-        self.assertEqual(info["CFBundleIdentifier"], "com.token-meter.menubar")
-        self.assertEqual(info["CFBundleExecutable"], "token-meter-menubar")
-        self.assertTrue(info["LSUIElement"])
-
-    def test_user_installer_waits_for_both_supervised_runtime_jobs_and_returns_control(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "install").read_text()
-        manifest = (root / "runtime-manifest.txt").read_text()
-        server_start = script.index(
-            '"$INSTALL_ROOT/scripts/install-launch-agent" server-only'
-        )
-        readiness_check = script.index('"state_ready": true')
-        menubar_start = script.index(
-            '"$INSTALL_ROOT/scripts/install-launch-agent" menubar-only'
-        )
-        self.assertLess(server_start, readiness_check)
-        self.assertLess(readiness_check, menubar_start)
-        self.assertIn('$HOME/Library/Application Support/Token Meter/runtime', script)
-        self.assertIn('TOKEN_METER_READINESS_TIMEOUT_SECONDS:-600', script)
-        self.assertIn('curl -fsS --max-time 5 "$HEALTH_URL"', script)
-        self.assertNotIn('curl -fsS --max-time 1 "$HEALTH_URL"', script)
-        self.assertIn('launchctl print "gui/$UID/$SERVER_LABEL"', script)
-        self.assertIn('launchctl print "gui/$UID/$MENUBAR_LABEL"', script)
-        self.assertIn('"$INSTALL_ROOT/meter.py"', script)
-        self.assertIn('"$INSTALL_ROOT/scripts/run-menubar"', script)
-        self.assertIn('ditto "$source_path" "$install_path"', script)
-        self.assertIn('python3 -m token_meter.packaging parity', script)
-        self.assertIn('assets/brand/logo-splunk-by-cisco-rgb-w.png', manifest)
-        self.assertIn('menubar/Info.plist', manifest)
-        self.assertIn(
-            'printf \'%s\\n\' "$UPDATE_SOURCE_ROOT" > "$INSTALL_ROOT/SOURCE_CHECKOUT"',
-            script,
-        )
-        self.assertIn('git clone --quiet --no-local "$SOURCE_ROOT"', script)
-        self.assertIn(
-            'git -C "$MANAGED_SOURCE_ROOT" fetch --quiet --no-tags',
-            script,
-        )
-        self.assertIn(
-            'git -C "$MANAGED_SOURCE_ROOT" merge --quiet --ff-only FETCH_HEAD',
-            script,
-        )
-        self.assertIn('remote set-url origin "$source_remote_url"', script)
-        self.assertIn('"branch.$managed_branch.merge" "refs/heads/$source_branch"', script)
-        self.assertIn('source_slug=', script)
-        self.assertIn('source_slug="${source_slug%.git}"', script)
-        self.assertIn('MANAGED_SOURCE_ROOT="$INSTALL_PARENT/source-$source_slug"', script)
-        self.assertIn('Preserving the existing managed checkout at:', script)
-        self.assertIn("Token Meter installation complete.", script)
-        self.assertNotIn('exec "$INSTALL_ROOT/scripts/install-launch-agent"', script)
-
-    def test_installers_show_progress_during_long_waits_and_always_clean_up(self):
-        root = Path(__file__).resolve().parents[1]
-        for name in ("install", "install-linux"):
-            with self.subTest(installer=name):
-                script = (root / "scripts" / name).read_text()
-                intro = script.index(
-                    'echo "Indexing local agent history (first run can take a few minutes)\u2026"'
-                )
-                start = script.index('progress_start "Indexing local agent history" "Still indexing\u2026"')
-                readiness = script.index('readiness_deadline=$((SECONDS + READINESS_TIMEOUT_SECONDS))')
-                done = script.index('progress_done "Server ready"')
-                self.assertLess(intro, start)
-                self.assertLess(start, readiness)
-                self.assertLess(readiness, done)
-                self.assertIn("if [ -t 1 ]; then", script)
-                self.assertIn("frames=(\u280b \u2819 \u2839 \u2838 \u283c \u2834 \u2826 \u2827 \u2807 \u280f)", script)
-                self.assertIn('while kill -0 "$parent" 2>/dev/null; do', script)
-                # The macOS installer also stops its background menu bar build.
-                cleanup = "install_cleanup" if name == "install" else "progress_stop"
-                self.assertIn(f"trap {cleanup} EXIT", script)
-                self.assertIn(f"trap '{cleanup}; trap - INT; kill -INT $$' INT", script)
-                self.assertIn(f"trap '{cleanup}; trap - TERM; kill -TERM $$' TERM", script)
-                self.assertIn('fail() {\n  progress_stop\n  echo "Token Meter installation failed: $*" >&2', script)
-                self.assertNotIn("\\033", script)
-                self.assertIn("the local server did not finish indexing within ${READINESS_TIMEOUT_SECONDS}s at $HEALTH_URL.", script)
-        mac = (root / "scripts" / "install").read_text()
-        self.assertIn('install_cleanup() {\n  progress_stop\n  stop_menubar_build\n}', mac)
-        # The companion compiles in the background while the server indexes,
-        # but only when a toolchain is already installed: probing goes through
-        # `xcode-select -p`, which never opens Apple's install dialog.
-        self.assertIn('developer_dir="$(xcode-select -p 2>/dev/null)" || return 1', mac)
-        readiness = mac.index("readiness_deadline=$((SECONDS + READINESS_TIMEOUT_SECONDS))")
-        early_start = mac.index("  if swift_toolchain_installed; then\n    start_menubar_build\n  fi")
-        self.assertLess(early_start, readiness)
-        self.assertNotIn("swiftc", mac[mac.index("install_cleanup() {"):readiness])
-        build_check = mac.index('"$INSTALL_ROOT/scripts/run-menubar" --check')
-        self.assertIn('MENUBAR_BUILD_PID=$!', mac[build_check:build_check + 200])
-        build_intro = mac.index(
-            'echo "Building the menu bar companion (first build compiles Swift, ~1 min)\u2026"'
-        )
-        build_start = mac.index('progress_start "Building the menu bar companion" "Still building\u2026"')
-        build_wait = mac.index('wait "$MENUBAR_BUILD_PID" || menubar_check_status=$?')
-        build_stop = mac.index("progress_stop", build_wait)
-        self.assertLess(build_start, build_wait)
-        build_fail = mac.index(
-            'fail "the native companion cannot build with the installed Swift toolchain and macOS SDKs."'
-        )
-        build_done = mac.index('progress_done "Menu bar companion ready"')
-        self.assertLess(build_intro, build_start)
-        self.assertLess(build_wait, build_stop)
-        self.assertLess(build_stop, build_fail)
-        self.assertLess(build_fail, build_done)
-
-    def test_update_helper_requires_clean_fast_forward_then_reuses_installer(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "update").read_text()
-        self.assertIn("git -C \"$SOURCE_ROOT\" fetch --quiet --prune --no-tags", script)
-        self.assertIn("git -C \"$SOURCE_ROOT\" status --porcelain", script)
-        self.assertIn("git -C \"$SOURCE_ROOT\" merge --ff-only '@{upstream}'", script)
-        self.assertIn('branch="$(git -C "$SOURCE_ROOT" rev-parse --abbrev-ref HEAD', script)
-        self.assertIn('[[ "$branch" != "main" || "${upstream##*/}" != "main" ]]', script)
-        self.assertIn('TOKEN_METER_UPDATE_RETRY_REVISION', script)
-        self.assertIn('record["failed_revision"]', script)
-        self.assertIn('INSTALL_SCRIPT="$SOURCE_ROOT/scripts/install"', script)
-        self.assertIn('INSTALL_SCRIPT="$SOURCE_ROOT/scripts/install-linux"', script)
-        self.assertIn('TOKEN_METER_INSTALL_ROOT="$RUNTIME_ROOT" "$INSTALL_SCRIPT"', script)
-        self.assertNotIn("reset --hard", script)
-        self.assertNotIn("sudo ", script)
-
-    def test_update_entrypoint_dispatches_linux_to_linux_helper(self):
-        root = Path(__file__).resolve().parents[1]
-        entrypoint = (root / "scripts" / "update").read_text()
-        linux_helper = (root / "scripts" / "update-linux").read_text()
-        manifest = (root / "runtime-manifest.txt").read_text()
-
-        self.assertIn('case "$(uname -s)" in', entrypoint)
-        self.assertIn('LINUX_HELPER="$ENTRYPOINT_ROOT/scripts/update-linux"', entrypoint)
-        self.assertIn('[[ ! -x "$LINUX_HELPER" ]]', entrypoint)
-        self.assertIn('"error_code": "linux_helper_unavailable"', entrypoint)
-        self.assertIn('exec env TOKEN_METER_UPDATE_LINUX_HELPER=1 "$LINUX_HELPER" "$@"', entrypoint)
-        self.assertIn('Darwin)', entrypoint)
-        self.assertIn('supported platforms are macOS and Linux.', entrypoint)
-        self.assertIn('[[ "$(uname -s)" == "Linux" ]]', linux_helper)
-        self.assertIn(
-            'exec env TOKEN_METER_UPDATE_LINUX_HELPER=1 "$ENTRYPOINT_ROOT/scripts/update" "$@"',
-            linux_helper,
-        )
-        self.assertNotIn('git -C "$SOURCE_ROOT"', linux_helper)
-        self.assertIn('required scripts/update-linux', manifest)
-
-    def test_windows_update_helper_requires_main_and_supports_failed_retry(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "update-windows.ps1").read_text()
-        self.assertIn('$Branch = (Get-GitText @("-C", $SourceRoot, "rev-parse", "--abbrev-ref", "HEAD"))', script)
-        self.assertIn('$Branch -ne "main"', script)
-        self.assertIn('$env:TOKEN_METER_UPDATE_RETRY_REVISION', script)
-        self.assertIn('failed_revision =', script)
-
-    def test_launch_agents_supervise_server_and_menu_bar_independently(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "install-launch-agent").read_text()
-        self.assertIn('SERVER_LABEL="com.token-meter.server"', script)
-        self.assertIn('MENUBAR_LABEL="com.token-meter.menubar"', script)
-        self.assertIn("<string>$SERVER_PROGRAM</string>", script)
-        self.assertIn("<string>$MENUBAR_PROGRAM</string>", script)
-        self.assertIn("Verify the replacement survives that", script)
-        self.assertGreaterEqual(
-            script.count('launchctl print "gui/$UID/$label"'), 3,
-        )
-        self.assertEqual(script.count("<key>KeepAlive</key>"), 2)
-        self.assertEqual(script.count("<key>SuccessfulExit</key>"), 1)
-        self.assertEqual(script.count("<key>SuccessfulExit</key>\n    <false/>"), 1)
-        self.assertNotIn("start-token-meter", script)
-        self.assertIn("all|server-only|menubar-only", script)
-        self.assertIn("server-only)", script)
-        self.assertIn("menubar-only)", script)
-        self.assertNotIn("kickstart -k", script)
-        self.assertIn("attempt <= 10", script)
-        self.assertIn('launchctl print "gui/$UID/$label"', script)
-        self.assertIn("sleep 0.2", script)
-        for label in ("SERVER_LABEL", "MENUBAR_LABEL"):
-            self.assertIn(f'launchctl bootout "gui/$UID/${label}"', script)
-
-    def test_foreground_launcher_waits_for_indexing_before_starting_menubar(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "start-token-meter").read_text()
-        readiness_check = script.index('"state_ready": true')
-        menubar_start = script.index('exec "$ROOT/scripts/run-menubar"')
-        self.assertLess(readiness_check, menubar_start)
-        self.assertIn('TOKEN_METER_READINESS_TIMEOUT_SECONDS:-600', script)
-        self.assertIn('curl -fsS --max-time 5 "$HEALTH_URL"', script)
-        self.assertNotIn('curl -fsS --max-time 1 "$HEALTH_URL"', script)
-
-    def test_uninstaller_removes_both_supervised_jobs(self):
-        root = Path(__file__).resolve().parents[1]
-        script = (root / "scripts" / "uninstall-launch-agent").read_text()
-        self.assertIn('launchctl bootout "gui/$UID/$SERVER_LABEL"', script)
-        self.assertIn('launchctl bootout "gui/$UID/$MENUBAR_LABEL"', script)
-        self.assertIn('rm -f "$MENUBAR_PLIST" "$SERVER_PLIST"', script)
-
-    def test_linux_installer_uses_xdg_runtime_systemd_and_appindicator_tray(self):
-        root = Path(__file__).resolve().parents[1]
-        entrypoint = (root / "scripts" / "install").read_text()
-        installer = (root / "scripts" / "install-linux").read_text()
-        systemd = (root / "scripts" / "install-systemd-user").read_text()
-        runner = (root / "scripts" / "run-menubar").read_text()
-        tray = (root / "menubar" / "token_meter_tray.py").read_text()
-        self.assertIn('exec "$SOURCE_ROOT/scripts/install-linux" "$@"', entrypoint)
-        self.assertNotIn("install-systemd-user", entrypoint)
-        self.assertNotIn("launchctl", installer)
-        self.assertNotIn("install-launch-agent", installer)
-        self.assertIn("XDG_DATA_HOME", installer)
-        self.assertIn("install-systemd-user", installer)
-        self.assertIn('"$INSTALL_ROOT/scripts/install-systemd-user" server-only', installer)
-        self.assertIn('"$INSTALL_ROOT/scripts/install-systemd-user" menubar-only', installer)
-        self.assertIn("systemctl --user is-active", installer)
-        self.assertIn("token-meter-server.service", systemd)
-        self.assertIn("token-meter-tray.service", systemd)
-        self.assertIn("all|server-only|menubar-only", systemd)
-        self.assertEqual(systemd.count("Restart=on-failure"), 2)
-        self.assertIn("Linux)", runner)
-        self.assertIn("AyatanaAppIndicator3", tray)
-        self.assertIn("AppIndicator3", tray)
-        self.assertIn("XDG_CONFIG_HOME", tray)
-        self.assertIn("refresh_menu_content", tray)
-        self.assertIn("self.indicator.set_menu(self.menu)", tray)
-        self.assertNotIn("self.indicator.set_menu(menu)", tray)
-        self.assertIn("Recent sessions", tray)
-        self.assertIn("Provider limits", tray)
-        self.assertIn("Open Budget Settings", tray)
-        self.assertIn("Menu bar title", tray)
-        self.assertIn("def open_dashboard(self):", tray)
-
-    def test_linux_runtime_uses_xdg_desktop_and_trash_paths(self):
-        if not meter.IS_LINUX:
-            self.skipTest("Linux-specific default paths")
-        self.assertTrue(meter.CURSOR_STATE_DB.startswith(meter.XDG_CONFIG_HOME))
-        self.assertTrue(all(path.startswith(meter.XDG_CONFIG_HOME)
-                            for path in meter.CLAUDE_DESKTOP_DATA_ROOTS))
-        self.assertEqual(meter.session_action_capability()["destination"], "Trash")
-
-
-class RemovedAgentDefaultsEndpointTests(unittest.TestCase):
-    def test_removed_agent_defaults_endpoint_returns_not_found(self):
-        for method in ("do_GET", "do_POST"):
-            with self.subTest(method=method):
-                handler = object.__new__(meter.H)
-                handler.path = "/settings/agent-defaults"
-                errors, responses = [], []
-                handler.send_error = lambda status: errors.append(status)
-                handler._send = lambda *args, **kwargs: responses.append((args, kwargs))
-                handler.headers = {"Host": "127.0.0.1:8722"}
-                getattr(handler, method)()
-                self.assertEqual(errors, [404])
-                self.assertEqual(responses, [])
-
-
-@unittest.skip("Agent defaults feature removed")
-class AgentDefaultSettingsTests(unittest.TestCase):
-    def test_agent_default_status_does_not_project_model_configuration(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text(
-                'model = "existing-codex-model"\nmodel_reasoning_effort = "high"\n'
-            )
-            claude_path.write_text(json.dumps({
-                "model": "existing-claude-model",
-                "modelOverrides": {"alias": "existing-provider-model"},
-                "effortLevel": "high",
-            }))
-
-            status = meter.agent_default_settings(
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-
-        serialized = json.dumps(status)
-        for client in status["clients"]:
-            self.assertNotIn("model", client["defaults"])
-            self.assertNotIn("hidden_model", client)
-        for configured_model in (
-            "existing-codex-model", "existing-claude-model", "existing-provider-model",
-        ):
-            self.assertNotIn(configured_model, serialized)
-
-    def test_saving_agent_behavior_defaults_preserves_existing_model_configuration(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text(
-                'model = "existing-codex-model"\nmodel_reasoning_effort = "low"\n'
-            )
-            claude_path.write_text(json.dumps({
-                "model": "existing-claude-model",
-                "modelOverrides": {"alias": "existing-provider-model"},
-                "effortLevel": "low",
-            }))
-
-            codex = meter.set_agent_default_settings(
-                "codex", {
-                    "model": "legacy-request-model", "preserve_model": False,
-                    "reasoning_effort": "high", "context_limit": 128000,
-                },
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            claude = meter.set_agent_default_settings(
-                "claude", {
-                    "model": "legacy-request-model", "preserve_model": False,
-                    "reasoning_effort": "xhigh", "context_limit": 500000,
-                },
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            codex_text = codex_path.read_text()
-            claude_json = json.loads(claude_path.read_text())
-
-        self.assertIn('model = "existing-codex-model"', codex_text)
-        self.assertEqual(claude_json["model"], "existing-claude-model")
-        self.assertEqual(
-            claude_json["modelOverrides"], {"alias": "existing-provider-model"},
-        )
-        self.assertNotIn("model", codex["defaults"])
-        self.assertNotIn("model", claude["defaults"])
-
-    def test_agent_default_save_rejects_concurrent_model_changes_without_overwriting(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text(
-                'model = "initial-codex-model"\nmodel_reasoning_effort = "low"\n'
-            )
-            claude_path.write_text(json.dumps({
-                "model": "initial-claude-model",
-                "modelOverrides": {"alias": "initial-provider-model"},
-                "effortLevel": "low",
-            }))
-            original_write = meter.atomic_write_text
-
-            def concurrent_codex_write(path, text, *args, **kwargs):
-                codex_path.write_text(
-                    codex_path.read_text().replace(
-                        "initial-codex-model", "concurrent-codex-model",
-                    )
-                )
-                return original_write(path, text, *args, **kwargs)
-
-            with mock.patch.object(
-                    meter, "atomic_write_text", side_effect=concurrent_codex_write):
-                codex = meter.set_agent_default_settings(
-                    "codex", {"reasoning_effort": "high", "context_limit": 128000},
-                    codex_config=str(codex_path), claude_settings=str(claude_path),
-                )
-
-            def concurrent_claude_write(path, text, *args, **kwargs):
-                concurrent = json.loads(claude_path.read_text())
-                concurrent["model"] = "concurrent-claude-model"
-                concurrent["modelOverrides"] = {"alias": "concurrent-provider-model"}
-                claude_path.write_text(json.dumps(concurrent))
-                return original_write(path, text, *args, **kwargs)
-
-            with mock.patch.object(
-                    meter, "atomic_write_text", side_effect=concurrent_claude_write):
-                claude = meter.set_agent_default_settings(
-                    "claude", {"reasoning_effort": "xhigh", "context_limit": 500000},
-                    codex_config=str(codex_path), claude_settings=str(claude_path),
-                )
-
-            codex_text = codex_path.read_text()
-            claude_json = json.loads(claude_path.read_text())
-
-        self.assertFalse(codex["ok"])
-        self.assertFalse(claude["ok"])
-        self.assertIn('model = "concurrent-codex-model"', codex_text)
-        self.assertEqual(claude_json["model"], "concurrent-claude-model")
-        self.assertEqual(
-            claude_json["modelOverrides"], {"alias": "concurrent-provider-model"},
-        )
-        for secret in (
-            "concurrent-codex-model", "concurrent-claude-model",
-            "concurrent-provider-model",
-        ):
-            self.assertNotIn(secret, json.dumps({"codex": codex, "claude": claude}))
-
-    def test_codex_defaults_report_cli_scope(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text('model = "gpt-5.6-terra"\n')
-            claude_path.write_text("{}\n")
-
-            status = meter.agent_default_settings(
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            saved = meter.set_agent_default_settings(
-                "codex", {"reasoning_effort": "high", "context_limit": 128000},
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-
-        codex = status["clients"][0]
-        self.assertEqual(codex["scope"], "cli")
-        self.assertEqual(codex["label"], "Codex CLI")
-        self.assertEqual(saved["scope"], "cli")
-        self.assertIn("Codex CLI defaults saved", saved["message"])
-        self.assertNotIn("Desktop", saved["message"])
-
-    def test_agent_default_settings_update_only_the_supported_client_fields(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text(
-                '# Keep this comment.\nmodel = "old-model"\n'
-                'model_reasoning_effort = "low"\n\n'
-                '[mcp_servers.local]\ncommand = "keep-me"\n'
-            )
-            claude_path.write_text(json.dumps({
-                "model": "old-model",
-                "effortLevel": "low",
-                "env": {"KEEP": "value"},
-                "enabledPlugins": {"keep@personal": True},
-            }))
-
-            codex = meter.set_agent_default_settings(
-                "codex", {"reasoning_effort": "high", "context_limit": 128000},
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            claude = meter.set_agent_default_settings(
-                "claude", {"reasoning_effort": "xhigh", "context_limit": 500000},
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            codex_text = codex_path.read_text()
-            claude_json = json.loads(claude_path.read_text())
-
-        self.assertTrue(codex["ok"])
-        self.assertTrue(codex["verified"])
-        self.assertTrue(claude["ok"])
-        self.assertTrue(claude["verified"])
-        self.assertIn('model = "old-model"', codex_text)
-        self.assertIn('model_reasoning_effort = "high"', codex_text)
-        self.assertIn("model_context_window = 128000", codex_text)
-        self.assertIn('[mcp_servers.local]\ncommand = "keep-me"', codex_text)
-        self.assertEqual(claude_json["model"], "old-model")
-        self.assertEqual(claude_json["effortLevel"], "xhigh")
-        self.assertEqual(claude_json["env"], {
-            "KEEP": "value", "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "500000",
-        })
-        self.assertEqual(claude_json["enabledPlugins"], {"keep@personal": True})
-
-    def test_clearing_agent_default_settings_removes_only_the_saved_overrides(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text(
-                'model = "gpt-5.6-terra"\nmodel_reasoning_effort = "high"\n'
-                'model_context_window = 256000\n[features]\nskills = true\n'
-            )
-            claude_path.write_text(json.dumps({
-                "model": "claude-sonnet-4-6", "effortLevel": "high",
-                "env": {"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "256000", "KEEP": "value"},
-            }))
-
-            codex = meter.set_agent_default_settings(
-                "codex", {"reasoning_effort": "", "context_limit": None},
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            claude = meter.set_agent_default_settings(
-                "claude", {"reasoning_effort": "", "context_limit": None},
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-            codex_text = codex_path.read_text()
-            claude_json = json.loads(claude_path.read_text())
-
-        self.assertTrue(codex["ok"])
-        self.assertTrue(claude["ok"])
-        self.assertIn('model = "gpt-5.6-terra"', codex_text)
-        self.assertNotIn("model_reasoning_effort", codex_text)
-        self.assertNotIn("model_context_window", codex_text)
-        self.assertIn("[features]\nskills = true", codex_text)
-        self.assertEqual(claude_json["model"], "claude-sonnet-4-6")
-        self.assertNotIn("effortLevel", claude_json)
-        self.assertEqual(claude_json["env"], {"KEEP": "value"})
-
-    def test_agent_default_settings_reject_an_invalid_context_limit_without_writing(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text('model = "keep"\n')
-            claude_path.write_text(json.dumps({"model": "keep"}))
-
-            result = meter.set_agent_default_settings(
-                "claude", {"reasoning_effort": "high", "context_limit": 99999},
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-
-            codex_text = codex_path.read_text()
-            claude_json = json.loads(claude_path.read_text())
-
-        self.assertFalse(result["ok"])
-        self.assertIn("Context limit", result["error"])
-        self.assertEqual(codex_text, 'model = "keep"\n')
-        self.assertEqual(claude_json, {"model": "keep"})
-
-    def test_agent_default_settings_reject_a_fractional_context_limit_without_writing(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_path = Path(tmp) / "settings.json"
-            claude_path.write_text(json.dumps({"model": "keep"}))
-
-            result = meter.set_agent_default_settings(
-                "claude", {"reasoning_effort": "high", "context_limit": 128000.5},
-                claude_settings=str(claude_path),
-            )
-
-            claude_json = json.loads(claude_path.read_text())
-
-        self.assertFalse(result["ok"])
-        self.assertIn("whole number", result["error"])
-        self.assertEqual(claude_json, {"model": "keep"})
-
-    def test_agent_defaults_accept_only_documented_persistent_reasoning_efforts(self):
-        for effort in ("minimal", "low", "medium", "high", "xhigh"):
-            with self.subTest(effort=effort):
-                defaults = meter.normalize_agent_default_settings(
-                    "codex", {"reasoning_effort": effort, "context_limit": 128000},
-                )
-                self.assertEqual(defaults["reasoning_effort"], effort)
-        for client, efforts in (("codex", ("none", "max", "ultra")),
-                                ("claude", ("minimal", "none", "max", "ultra"))):
-            for effort in efforts:
-                with self.subTest(client=client, effort=effort):
-                    with self.assertRaisesRegex(ValueError, "not supported"):
-                        meter.normalize_agent_default_settings(
-                            client, {"reasoning_effort": effort, "context_limit": 128000},
-                        )
-
-    def test_codex_agent_defaults_preserve_triple_quoted_root_content_and_hashes(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            codex_path.write_text(
-                'developer_instructions = """\n[keep this literal instruction]\n"""\n'
-                'model = "gpt#old"\n[features]\nskills = true\n'
-            )
-
-            result = meter.set_agent_default_settings(
-                "codex", {"reasoning_effort": "minimal", "context_limit": 128000},
-                codex_config=str(codex_path),
-            )
-            text = codex_path.read_text()
-
-        self.assertTrue(result["ok"])
-        self.assertIn('developer_instructions = """\n[keep this literal instruction]\n"""', text)
-        self.assertIn('model = "gpt#old"', text)
-        self.assertLess(text.index("model_context_window = 128000"), text.index("[features]"))
-        self.assertIn("[features]\nskills = true", text)
-
-    def test_codex_agent_defaults_preserve_multiline_arrays_before_tables(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            codex_path.write_text('matrix = [\n  [1, 2]\n]\n[features]\nskills = true\n')
-
-            result = meter.set_agent_default_settings(
-                "codex", {"reasoning_effort": "minimal", "context_limit": 128000},
-                codex_config=str(codex_path),
-            )
-            text = codex_path.read_text()
-
-        self.assertTrue(result["ok"])
-        self.assertIn("matrix = [\n  [1, 2]\n]\n", text)
-        self.assertLess(text.index("model_context_window = 128000"), text.index("[features]"))
-        self.assertIn("[features]\nskills = true", text)
-
-    def test_agent_default_status_redacts_unvalidated_or_sensitive_config_values(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            codex_path = Path(tmp) / "config.toml"
-            claude_path = Path(tmp) / "settings.json"
-            codex_path.write_text('model = "/very/secret/path"\nmodel_reasoning_effort = "secret"\n')
-            claude_path.write_text(json.dumps({
-                "model": "arn:aws:bedrock:private-account:application/profile",
-                "effortLevel": "super-secret-token",
-                "env": {"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "999999999999999999999"},
-            }))
-
-            status = meter.agent_default_settings(
-                codex_config=str(codex_path), claude_settings=str(claude_path),
-            )
-
-        serialized = json.dumps(status)
-        self.assertEqual(status["clients"][0]["defaults"], {
-            "reasoning_effort": None, "context_limit": None,
-        })
-        self.assertEqual(status["clients"][1]["defaults"], {
-            "reasoning_effort": None, "context_limit": None,
-        })
-        for secret in ("/very/secret/path", "private-account", "super-secret-token", "999999999999999999999"):
-            self.assertNotIn(secret, serialized)
-
-    def test_legacy_model_fields_are_ignored_when_saving_other_defaults(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_path = Path(tmp) / "settings.json"
-            hidden_model = "arn:aws:bedrock:private-account:application/profile"
-            claude_path.write_text(json.dumps({"model": hidden_model, "effortLevel": "high"}))
-
-            result = meter.set_agent_default_settings(
-                "claude", {"model": "", "preserve_model": True, "reasoning_effort": "xhigh",
-                           "context_limit": 500000},
-                claude_settings=str(claude_path),
-            )
-            saved = json.loads(claude_path.read_text())
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(saved["model"], hidden_model)
-        self.assertEqual(saved["effortLevel"], "xhigh")
-        self.assertNotIn("private-account", json.dumps(result))
-
-
-class AgentAccessTests(unittest.TestCase):
-    _real_app_running = staticmethod(meter.claude_app_running)
-
-    def setUp(self):
-        patcher = mock.patch.object(meter, "claude_app_running", return_value=False)
-        patcher.start()
-        self.addCleanup(patcher.stop)
-
-    def test_client_environment_prepends_wrapper_runtime_directory(self):
-        with mock.patch.dict(meter.os.environ, {"PATH": "/usr/bin:/bin"}, clear=False):
-            env = meter.agent_client_environment("/Users/test/.nvm/versions/node/v24/bin/codex")
-        self.assertEqual(env["PATH"].split(":" )[0], "/Users/test/.nvm/versions/node/v24/bin")
-        self.assertIn("/usr/bin", env["PATH"].split(":"))
-
-    def test_client_environment_keeps_symlink_directory_for_sibling_node(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            wrapper_dir = Path(tmp) / "node" / "bin"
-            target_dir = Path(tmp) / "package" / "bin"
-            wrapper_dir.mkdir(parents=True)
-            target_dir.mkdir(parents=True)
-            target = target_dir / "codex.js"
-            target.write_text("#!/usr/bin/env node\n")
-            wrapper = wrapper_dir / "codex"
-            wrapper.symlink_to(target)
-            env = meter.agent_client_environment(str(wrapper))
-        self.assertEqual(env["PATH"].split(":")[0], str(wrapper_dir))
-
-    def test_client_discovery_checks_user_bin_when_service_path_is_minimal(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            binary = Path(tmp) / ".local" / "bin" / "claude"
-            binary.parent.mkdir(parents=True)
-            binary.write_text("#!/bin/sh\n")
-            binary.chmod(0o755)
-            with mock.patch.object(meter.os.path, "expanduser",
-                                   side_effect=lambda value: tmp if value == "~" else value):
-                found = meter.agent_client_executable("claude", which=lambda name: None)
-        self.assertEqual(found, str(binary))
-
-    def test_connection_commands_use_fixed_vectors_and_user_scope(self):
-        launcher = "/Applications/Token Meter/bin/token-meter-mcp"
-        codex = meter.agent_access_command("codex", True, launcher=launcher, cli_path="/usr/bin/codex")
-        claude = meter.agent_access_command("claude", True, launcher=launcher, cli_path="/usr/bin/claude")
-        self.assertEqual(codex, ["/usr/bin/codex", "mcp", "add", "--env",
-                                "TOKEN_METER_CALLER=codex", "tokenmeter", "--", launcher])
-        self.assertEqual(claude, ["/usr/bin/claude", "mcp", "add", "--transport", "stdio",
-                                 "--scope", "user", "tokenmeter", "--env",
-                                 "TOKEN_METER_CALLER=claude", "--", launcher])
-
-    def test_codex_status_requires_exact_launcher_and_caller_environment(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher = Path(tmp) / "token-meter-mcp"
-            launcher.write_text("#!/bin/sh\n")
-            launcher.chmod(0o755)
-
-            class Completed:
-                returncode = 0
-                stdout = json.dumps({"enabled": True, "transport": {
-                    "type": "stdio", "command": str(launcher), "args": [],
-                    "env": {"TOKEN_METER_CALLER": "codex"},
-                }})
-                stderr = ""
-
-            status = meter.agent_access_client_status(
-                "codex", launcher=str(launcher), runner=lambda *a, **k: Completed(),
-                which=lambda name: f"/usr/bin/{name}")
-        self.assertTrue(status["connected"])
-        self.assertFalse(status["conflict"])
-        self.assertNotIn("/usr/bin/codex", status["connect_command"])
-
-    def test_windows_codex_status_check_does_not_create_a_console_window(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher = Path(tmp) / "token-meter-mcp"
-            launcher.write_text("#!/bin/sh\n")
-            launcher.chmod(0o755)
-            observed = {}
-
-            def runner(command, **kwargs):
-                observed.update(kwargs)
-                return meter.subprocess.CompletedProcess(command, 1, "", "missing")
-
-            windows = meter.platform_services(
-                "windows", environment={"USERPROFILE": r"C:\Users\example"},
-                home=r"C:\Users\example",
-            )
-            with mock.patch.object(meter, "_PLATFORM_SERVICES", windows):
-                meter.agent_access_client_status(
-                    "codex", launcher=str(launcher), runner=runner,
-                    which=lambda name: fr"C:\Tools\{name}.exe",
-                )
-
-        self.assertEqual(observed["creationflags"], 0x08000000)
-        self.assertTrue(observed["close_fds"])
-
-    def test_windows_connection_change_does_not_create_a_console_window(self):
-        before = {"label": "Codex", "detected": True, "available": True,
-                  "configured": False, "connected": False, "conflict": False}
-        after = {**before, "configured": True, "connected": True}
-        states = iter((before, after))
-        observed = {}
-
-        def runner(command, **kwargs):
-            observed.update(kwargs)
-            return meter.subprocess.CompletedProcess(command, 0, "", "")
-
-        windows = meter.platform_services(
-            "windows", environment={"USERPROFILE": r"C:\Users\example"},
-            home=r"C:\Users\example",
-        )
-        with mock.patch.object(meter, "_PLATFORM_SERVICES", windows), \
-                mock.patch.object(meter, "agent_access_launcher",
-                                  return_value=r"C:\Token Meter\token-meter-mcp.cmd"), \
-                mock.patch.object(meter, "agent_client_executable",
-                                  return_value=r"C:\Tools\codex.exe"):
-            result = meter.set_agent_access(
-                "codex", True, runner=runner,
-                status_getter=lambda client: next(states),
-            )
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(observed["creationflags"], 0x08000000)
-        self.assertTrue(observed["close_fds"])
-
-    def test_claude_status_reads_only_the_user_scope_entry(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher = Path(tmp) / "token-meter-mcp"
-            launcher.write_text("#!/bin/sh\n")
-            launcher.chmod(0o755)
-            config = Path(tmp) / ".claude.json"
-            config.write_text(json.dumps({"mcpServers": {"tokenmeter": {
-                "type": "stdio", "command": str(launcher), "args": [],
-                "env": {"TOKEN_METER_CALLER": "claude"},
-            }}}))
-            status = meter.agent_access_client_status(
-                "claude", launcher=str(launcher), claude_config_path=str(config),
-                which=lambda name: f"/usr/bin/{name}", claude_desktop_config_paths=[])
-        self.assertTrue(status["connected"])
-        self.assertEqual(status["label"], "Claude")
-        self.assertEqual(status["status"], "Connected to Claude Code")
-
-    def test_different_existing_entry_is_reported_as_conflict(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher = Path(tmp) / "token-meter-mcp"
-            launcher.write_text("#!/bin/sh\n")
-            launcher.chmod(0o755)
-            config = Path(tmp) / ".claude.json"
-            config.write_text(json.dumps({"mcpServers": {"tokenmeter": {
-                "type": "stdio", "command": "/tmp/different", "args": [], "env": {},
-            }}}))
-            status = meter.agent_access_client_status(
-                "claude", launcher=str(launcher), claude_config_path=str(config),
-                which=lambda name: f"/usr/bin/{name}", claude_desktop_config_paths=[])
-        self.assertFalse(status["connected"])
-        self.assertTrue(status["conflict"])
-        self.assertEqual(status["status"], "Existing entry differs from this install")
-
-    def test_conflicting_entry_requires_explicit_repair_confirmation(self):
-        before = {"label": "Codex", "detected": True, "available": True,
-                  "configured": True, "connected": False, "conflict": True}
-        runner = mock.Mock()
-        result = meter.set_agent_access("codex", True, runner=runner,
-                                        status_getter=lambda client: before)
-        self.assertFalse(result["ok"])
-        self.assertTrue(result["conflict"])
-        self.assertIn("Confirm repair", result["error"])
-        runner.assert_not_called()
-
-    def test_repair_replaces_only_named_entry_and_verifies_connection(self):
-        before = {"label": "Codex", "detected": True, "available": True,
-                  "configured": True, "connected": False, "conflict": True}
-        after = {**before, "configured": True, "connected": True, "conflict": False}
-        states = iter((before, after))
-        commands = []
-
-        class Completed:
-            returncode = 0
-            stdout = ""
-            stderr = ""
-
-        def runner(argv, **kwargs):
-            commands.append(argv)
-            self.assertNotIn("shell", kwargs)
-            return Completed()
-
-        with mock.patch.object(meter, "agent_access_launcher", return_value="/tmp/token-meter-mcp"), \
-                mock.patch.object(meter, "agent_client_executable", return_value="/usr/bin/codex"):
-            result = meter.set_agent_access("codex", True, repair=True, runner=runner,
-                                            status_getter=lambda client: next(states))
-        self.assertTrue(result["ok"])
-        self.assertTrue(result["repaired"])
-        self.assertTrue(result["restart_required"])
-        self.assertEqual(commands, [
-            ["/usr/bin/codex", "mcp", "remove", "tokenmeter"],
-            ["/usr/bin/codex", "mcp", "add", "--env", "TOKEN_METER_CALLER=codex",
-             "tokenmeter", "--", "/tmp/token-meter-mcp"],
-        ])
-
-    def test_repair_stops_when_existing_entry_cannot_be_removed(self):
-        before = {"label": "Claude Code", "detected": True, "available": True,
-                  "configured": True, "connected": False, "conflict": True}
-
-        class Completed:
-            returncode = 1
-            stdout = ""
-            stderr = "entry is locked\n"
-
-        runner = mock.Mock(return_value=Completed())
-        absent = {"label": "Claude app", "detected": False}
-        with mock.patch.object(meter, "agent_client_executable", return_value="/usr/bin/claude"):
-            result = meter.set_agent_access("claude", True, repair=True, runner=runner,
-                                            status_getter=lambda client: absent if client == "claude_desktop" else before)
-        self.assertFalse(result["ok"])
-        self.assertTrue(result["conflict"])
-        self.assertIn("remove the existing tokenmeter entry", result["error"])
-        self.assertIn("entry is locked", result["error"])
-        runner.assert_called_once()
-
-    def test_connection_change_is_verified_after_cli_success(self):
-        before = {"label": "Codex", "detected": True, "available": True,
-                  "configured": False, "connected": False, "conflict": False}
-        after = {**before, "configured": True, "connected": True}
-        states = iter((before, after))
-        observed = {}
-
-        class Completed:
-            returncode = 0
-            stdout = ""
-            stderr = ""
-
-        def runner(argv, **kwargs):
-            observed["argv"] = argv
-            observed["kwargs"] = kwargs
-            return Completed()
-
-        with mock.patch.object(meter, "agent_access_launcher", return_value="/tmp/token-meter-mcp"):
-            result = meter.set_agent_access("codex", True, runner=runner,
-                                            status_getter=lambda client: next(states))
-        self.assertTrue(result["ok"])
-        self.assertTrue(result["restart_required"])
-        self.assertEqual(observed["argv"][-3:], ["tokenmeter", "--", "/tmp/token-meter-mcp"])
-        self.assertNotIn("shell", observed["kwargs"])
-
-    def test_connection_failure_includes_bounded_cli_reason(self):
-        before = {"label": "Codex", "detected": True, "available": True,
-                  "configured": False, "connected": False, "conflict": False}
-
-        class Completed:
-            returncode = 127
-            stdout = ""
-            stderr = "env: node: No such file or directory\n"
-
-        with mock.patch.object(meter, "agent_access_launcher", return_value="/tmp/token-meter-mcp"), \
-                mock.patch.object(meter, "agent_client_executable", return_value="/tmp/codex"):
-            result = meter.set_agent_access("codex", True, runner=lambda *a, **k: Completed(),
-                                            status_getter=lambda client: before)
-        self.assertFalse(result["ok"])
-        self.assertIn("env: node", result["error"])
-
-    def _desktop_fixture(self, tmp, config=None, root_name="Claude"):
-        launcher = Path(tmp) / "token-meter-mcp"
-        if not launcher.exists():
-            launcher.write_text("#!/bin/sh\n")
-            launcher.chmod(0o755)
-        root = Path(tmp) / root_name
-        root.mkdir()
-        path = root / "claude_desktop_config.json"
-        if isinstance(config, bytes):
-            path.write_bytes(config)
-        elif config is not None:
-            path.write_text(config if isinstance(config, str) else json.dumps(config, indent=2))
-        return str(launcher), path
-
-    def _desktop_toggle(self, launcher, paths, enabled, repair=False):
-        paths = [str(path) for path in paths]
-        status_getter = lambda client: meter.claude_desktop_access_status(launcher, paths)
-        with mock.patch.object(meter, "CLAUDE_DESKTOP_CONFIGS", paths), \
-                mock.patch.object(meter, "agent_access_launcher", return_value=launcher):
-            return meter._set_agent_access_part("claude_desktop", enabled, repair,
-                                                mock.Mock(side_effect=AssertionError("no subprocess")),
-                                                status_getter)
-
-    def test_status_lists_the_claude_app_beside_cli_clients(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp)
-            status = meter.agent_access_status(
-                launcher=launcher, which=lambda name: None,
-                claude_config_path=str(Path(tmp) / ".claude.json"),
-                claude_desktop_config_paths=[str(path)])
-        self.assertEqual([row["id"] for row in status["clients"]], ["codex", "claude"])
-        claude = status["clients"][1]
-        self.assertEqual(claude["label"], "Claude")
-        self.assertTrue(claude["detected"])
-        self.assertTrue(claude["available"])
-        self.assertFalse(claude["configured"])
-        self.assertEqual(claude["status"], "Ready to connect")
-        self.assertTrue(status["any_detected"])
-
-    def test_claude_app_missing_is_not_detected(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            status = meter.claude_desktop_access_status(
-                str(Path(tmp) / "launcher"), [str(Path(tmp) / "absent" / "claude_desktop_config.json")])
-        self.assertFalse(status["detected"])
-        self.assertFalse(status["available"])
-        self.assertEqual(status["status"], "App not found")
-
-    def test_claude_app_connect_changes_only_the_tokenmeter_entry(self):
-        existing = {"preferences": {"sidebarMode": "chat", "name": "caf\u00e9"},
-                    "mcpServers": {"other": {"command": "/bin/other", "args": ["x"], "env": {"K": "v"}}}}
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp, existing)
-            path.chmod(0o600)
-            result = self._desktop_toggle(launcher, [path], True)
-            saved = json.loads(path.read_text(encoding="utf-8"))
-            mode = path.stat().st_mode & 0o777
-        self.assertTrue(result["ok"])
-        self.assertTrue(result["client"]["connected"])
-        self.assertIn("Quit and reopen the Claude app", result["message"])
-        self.assertEqual(saved["preferences"], existing["preferences"])
-        self.assertEqual(saved["mcpServers"]["other"], existing["mcpServers"]["other"])
-        self.assertEqual(saved["mcpServers"]["tokenmeter"], {
-            "command": launcher, "args": [], "env": {"TOKEN_METER_CALLER": "claude"}})
-        self.assertEqual(mode, 0o600)
-
-    def test_claude_app_connect_writes_every_app_config_including_third_party_mode(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, first = self._desktop_fixture(tmp, {"preferences": {}})
-            _, third_party = self._desktop_fixture(tmp, {"deploymentMode": "3p", "mcpServers": {
-                "other": {"command": "/bin/other"}}}, root_name="Claude-3p")
-            partial = meter.claude_desktop_access_status(launcher, [str(first), str(third_party)])
-            meter.write_claude_desktop_access(True, launcher, [str(first)])
-            half = meter.claude_desktop_access_status(launcher, [str(first), str(third_party)])
-            result = self._desktop_toggle(launcher, [first, third_party], True)
-            saved = [json.loads(path.read_text()) for path in (first, third_party)]
-        self.assertFalse(partial["connected"])
-        self.assertFalse(half["connected"])
-        self.assertEqual(partial["status"], "Ready to connect")
-        self.assertEqual(half["status"], "Connected in only one Claude app config")
-        self.assertTrue(result["ok"])
-        for config in saved:
-            self.assertEqual(config["mcpServers"]["tokenmeter"], meter.claude_desktop_access_entry(launcher))
-        self.assertEqual(saved[1]["deploymentMode"], "3p")
-        self.assertEqual(saved[1]["mcpServers"]["other"], {"command": "/bin/other"})
-
-    def test_claude_app_only_third_party_root_is_detected(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, third_party = self._desktop_fixture(tmp, {}, root_name="Claude-3p")
-            absent = Path(tmp) / "Claude" / "claude_desktop_config.json"
-            result = self._desktop_toggle(launcher, [absent, third_party], True)
-            self.assertFalse(absent.parent.exists())
-            saved = json.loads(third_party.read_text())
-        self.assertTrue(result["ok"])
-        self.assertIn("tokenmeter", saved["mcpServers"])
-
-    def test_claude_app_connect_creates_a_missing_config(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp)
-            self.assertIsNone(meter.write_claude_desktop_access(True, launcher, [str(path)]))
-            status = meter.claude_desktop_access_status(launcher, [str(path)])
-            saved = json.loads(path.read_text())
-        self.assertTrue(status["connected"])
-        self.assertEqual(list(saved), ["mcpServers"])
-
-    def test_claude_app_disconnect_removes_only_the_tokenmeter_entry(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp)
-            path.write_text(json.dumps({"keep": 1, "mcpServers": {
-                "other": {"command": "/bin/other"},
-                "tokenmeter": meter.claude_desktop_access_entry(launcher)}}))
-            result = self._desktop_toggle(launcher, [path], False)
-            saved = json.loads(path.read_text())
-        self.assertTrue(result["ok"])
-        self.assertEqual(saved, {"keep": 1, "mcpServers": {"other": {"command": "/bin/other"}}})
-
-    def test_claude_app_conflict_needs_repair_then_replaces_only_that_entry(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp, {"mcpServers": {
-                "other": {"command": "/bin/other"},
-                "tokenmeter": {"command": "/tmp/different", "args": [], "env": {}}}})
-            refused = self._desktop_toggle(launcher, [path], True)
-            untouched = json.loads(path.read_text())
-            repaired = self._desktop_toggle(launcher, [path], True, repair=True)
-            saved = json.loads(path.read_text())
-        self.assertFalse(refused["ok"])
-        self.assertTrue(refused["conflict"])
-        self.assertEqual(untouched["mcpServers"]["tokenmeter"]["command"], "/tmp/different")
-        self.assertTrue(repaired["ok"])
-        self.assertTrue(repaired["repaired"])
-        self.assertEqual(saved["mcpServers"]["tokenmeter"], meter.claude_desktop_access_entry(launcher))
-        self.assertEqual(saved["mcpServers"]["other"], {"command": "/bin/other"})
-
-    def test_claude_app_config_that_cannot_be_parsed_is_left_unchanged(self):
-        for raw in (b"{not json", b'["list"]', b'{"mcpServers": []}', b"", b'{"a": "\xff\xfe"}'):
-            with self.subTest(raw=raw), tempfile.TemporaryDirectory() as tmp:
-                launcher, path = self._desktop_fixture(tmp, raw)
-                status = meter.claude_desktop_access_status(launcher, [str(path)])
-                error = meter.write_claude_desktop_access(True, launcher, [str(path)])
-                toggled = self._desktop_toggle(launcher, [path], True)
-                self.assertEqual(status["status"], "Claude app config could not be read")
-                self.assertTrue(status["unreadable"])
-                self.assertTrue(status["available"])
-                self.assertIn("left", error)
-                self.assertNotIn(tmp, error)
-                self.assertFalse(toggled["ok"])
-                self.assertIn("could not read", toggled["error"])
-                self.assertEqual(path.read_bytes(), raw)
-
-    def _claude_fixture(self, tmp, code_entry=None, app_config=None):
-        launcher, app_path = self._desktop_fixture(tmp, app_config)
-        code_path = Path(tmp) / ".claude.json"
-        code_path.write_text(json.dumps({"mcpServers": {"tokenmeter": code_entry}} if code_entry else {"keep": 1}))
-        calls = []
-
-        def runner(argv, **kwargs):
-            calls.append(argv)
-            data = json.loads(code_path.read_text())
-            servers = data.setdefault("mcpServers", {})
-            if argv[1:3] == ["mcp", "add"]:
-                servers["tokenmeter"] = {"type": "stdio", "command": argv[-1], "args": [],
-                                         "env": {"TOKEN_METER_CALLER": "claude"}}
-            elif argv[1:3] == ["mcp", "remove"]:
-                servers.pop("tokenmeter", None)
-            code_path.write_text(json.dumps(data))
-            return meter.subprocess.CompletedProcess(argv, 0, "", "")
-
-        def status_getter(client):
-            return meter.agent_access_client_status(
-                client, launcher=launcher, which=lambda name: f"/usr/bin/{name}",
-                claude_config_path=str(code_path), claude_desktop_config_paths=[str(app_path)])
-
-        return launcher, code_path, app_path, runner, calls, status_getter
-
-    def _claude_toggle(self, launcher, app_path, runner, status_getter, enabled, repair=False):
-        with mock.patch.object(meter, "CLAUDE_DESKTOP_CONFIGS", [str(app_path)]), \
-                mock.patch.object(meter, "agent_access_launcher", return_value=launcher), \
-                mock.patch.object(meter, "agent_client_executable", return_value="/usr/bin/claude"):
-            return meter.set_agent_access("claude", enabled, repair=repair, runner=runner,
-                                          status_getter=status_getter)
-
-    def test_one_claude_connect_sets_up_claude_code_and_the_claude_app(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={"keep": 2})
-            before = getter("claude")
-            result = self._claude_toggle(launcher, app_path, runner, getter, True)
-            app = json.loads(app_path.read_text())
-            code = json.loads(code_path.read_text())
-        self.assertEqual(before["status"], "Ready to connect")
-        self.assertEqual(before["connect_command"].count("\n"), 1)
-        self.assertTrue(result["ok"], result)
-        self.assertTrue(result["client"]["connected"])
-        self.assertEqual(result["client"]["status"], "Connected to Claude Code and the Claude app")
-        self.assertEqual(result["message"],
-                         "Claude connected. Start a new Claude Code session and reopen the Claude app.")
-        self.assertEqual([argv[1:3] for argv in calls], [["mcp", "add"]])
-        self.assertEqual(app["keep"], 2)
-        self.assertEqual(app["mcpServers"]["tokenmeter"], meter.claude_desktop_access_entry(launcher))
-        self.assertEqual(code["mcpServers"]["tokenmeter"]["command"], launcher)
-
-    def test_one_claude_disconnect_removes_both(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
-            self._claude_toggle(launcher, app_path, runner, getter, True)
-            result = self._claude_toggle(launcher, app_path, runner, getter, False)
-            app = json.loads(app_path.read_text())
-            code = json.loads(code_path.read_text())
-        self.assertTrue(result["ok"], result)
-        self.assertFalse(result["client"]["configured"])
-        self.assertNotIn("tokenmeter", app["mcpServers"])
-        self.assertNotIn("tokenmeter", code["mcpServers"])
-
-    def test_running_claude_app_is_skipped_but_claude_code_still_connects(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
-            with mock.patch.object(meter, "claude_app_running", return_value=True):
-                status = getter("claude")
-                result = self._claude_toggle(launcher, app_path, runner, getter, True)
-            app = json.loads(app_path.read_text())
-            code = json.loads(code_path.read_text())
-        self.assertFalse(status["blocked"])
-        self.assertEqual(status["status"], "Ready to connect. Quit the Claude app to change its connection")
-        self.assertTrue(result["ok"], result)
-        self.assertTrue(result["partial"])
-        self.assertIn("Quit the Claude app first", result["message"])
-        self.assertIn("click Connect again", result["message"])
-        self.assertEqual(result["client"]["status"],
-                         "Connected to Claude Code only. Quit the Claude app to change its connection")
-        self.assertTrue(result["client"]["blocked"])
-        self.assertEqual(app, {})
-        self.assertIn("tokenmeter", code["mcpServers"])
-
-    def test_running_claude_app_blocks_when_only_the_app_is_left(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
-            self._claude_toggle(launcher, app_path, runner, getter, True)
-            app_before = app_path.read_bytes()
-            code_before = code_path.read_bytes()
-            calls.clear()
-            with mock.patch.object(meter, "claude_app_running", return_value=True):
-                status = getter("claude")
-                result = self._claude_toggle(launcher, app_path, runner, getter, False)
-            self.assertEqual(code_path.read_bytes(), code_before)
-            self.assertEqual(app_path.read_bytes(), app_before)
-        self.assertTrue(status["connected"])
-        self.assertTrue(status["blocked"])
-        self.assertFalse(result["ok"])
-        self.assertIn("Quit the Claude app first", result["error"])
-        self.assertEqual(calls, [])
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, _, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={})
-            with mock.patch.object(meter, "claude_app_running", return_value=True):
-                meter.write_claude_desktop_access(False, launcher, [str(app_path)])
-                self._claude_toggle(launcher, app_path, runner, getter, True)
-                calls.clear()
-                refused = self._claude_toggle(launcher, app_path, runner, getter, True)
-                blocked = getter("claude")
-        self.assertFalse(refused["ok"])
-        self.assertIn("Quit the Claude app first", refused["error"])
-        self.assertEqual(calls, [])
-        self.assertTrue(blocked["blocked"])
-
-    def test_unreadable_claude_app_config_does_not_stop_claude_code(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config=b"{bad")
-            result = self._claude_toggle(launcher, app_path, runner, getter, True)
-            self.assertEqual(app_path.read_bytes(), b"{bad")
-        self.assertTrue(result["ok"], result)
-        self.assertTrue(result["partial"])
-        self.assertIn("could not read", result["message"])
-        self.assertEqual(result["client"]["status"],
-                         "Connected to Claude Code only. The Claude app config could not be read")
-        self.assertTrue(result["client"]["blocked"])
-
-    def test_running_claude_app_does_not_block_finishing_claude_code(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, _, app_path, runner, calls, getter = self._claude_fixture(tmp)
-            meter.write_claude_desktop_access(True, launcher, [str(app_path)])
-            with mock.patch.object(meter, "claude_app_running", return_value=True):
-                partial = getter("claude")
-                result = self._claude_toggle(launcher, app_path, runner, getter, True)
-        self.assertEqual(partial["status"], "Connected to the Claude app only")
-        self.assertFalse(partial["blocked"])
-        self.assertTrue(result["ok"], result)
-        self.assertEqual([argv[1:3] for argv in calls], [["mcp", "add"]])
-
-    def test_claude_code_only_machine_still_connects_with_one_button(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, _, runner, calls, _ = self._claude_fixture(tmp)
-            getter = lambda client: meter.agent_access_client_status(
-                client, launcher=launcher, which=lambda name: f"/usr/bin/{name}",
-                claude_config_path=str(code_path), claude_desktop_config_paths=[])
-            result = self._claude_toggle(launcher, Path(tmp) / "absent" / "c.json", runner, getter, True)
-        self.assertTrue(result["ok"], result)
-        self.assertEqual(result["message"], "Claude connected. Start a new Claude Code session.")
-
-    def test_claude_app_running_is_checked_only_where_the_host_can_tell(self):
-        seen = []
-
-        def runner(argv, **kwargs):
-            seen.append(argv)
-            self.assertNotIn("shell", kwargs)
-            return meter.subprocess.CompletedProcess(argv, self._pgrep_code, "", "")
-
-        for platform_id, code, expected in (("macos", 0, True), ("macos", 1, False),
-                                            ("windows", 0, None), ("linux", 0, None)):
-            self._pgrep_code = code
-            with self.subTest(platform_id=platform_id, code=code), \
-                    mock.patch.object(meter._PLATFORM_SERVICES, "platform_id", platform_id):
-                self.assertEqual(self._real_app_running(runner), expected)
-        self.assertEqual(seen, [["pgrep", "-a", "-x", "Claude"]] * 2)
-
-    def test_disconnect_is_refused_while_a_claude_app_config_is_unreadable(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, code_path, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config=b"{bad")
-            self._claude_toggle(launcher, app_path, runner, getter, True)
-            code_before = code_path.read_bytes()
-            calls.clear()
-            result = self._claude_toggle(launcher, app_path, runner, getter, False)
-            self.assertEqual(code_path.read_bytes(), code_before)
-            self.assertEqual(app_path.read_bytes(), b"{bad")
-        self.assertFalse(result["ok"])
-        self.assertIn("could not read", result["error"])
-        self.assertEqual(calls, [])
-
-    def test_repair_message_reflects_whether_anything_was_repaired(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, _, app_path, runner, calls, getter = self._claude_fixture(tmp, app_config={"mcpServers": {
-                "tokenmeter": {"command": "/tmp/different", "args": [], "env": {}}}})
-            with mock.patch.object(meter, "claude_app_running", return_value=True):
-                result = self._claude_toggle(launcher, app_path, runner, getter, True, repair=True)
-        self.assertTrue(result["ok"], result)
-        self.assertFalse(result["repaired"])
-        self.assertTrue(result["message"].startswith("Claude Code connected."))
-
-    def test_malformed_tokenmeter_entries_are_conflicts_not_crashes(self):
-        for entry in ({"command": "c", "env": "x"}, {"command": "c", "args": 5, "env": {}},
-                      "oops", None, ["list"], {"env": {"TOKEN_METER_CALLER": "claude"}, "args": "x"}):
-            with self.subTest(entry=entry), tempfile.TemporaryDirectory() as tmp:
-                launcher, path = self._desktop_fixture(tmp, {"mcpServers": {"tokenmeter": entry}})
-                before = path.read_bytes()
-                status = meter.agent_access_status(
-                    launcher=launcher, which=lambda name: None,
-                    claude_config_path=str(Path(tmp) / ".claude.json"),
-                    claude_desktop_config_paths=[str(path)])["clients"][1]
-                refused = self._desktop_toggle(launcher, [path], True)
-                self.assertTrue(status["conflict"])
-                self.assertFalse(status["connected"])
-                self.assertFalse(refused["ok"])
-                self.assertEqual(path.read_bytes(), before)
-
-    def test_unreadable_config_wins_over_a_conflict_in_another_config(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, conflicting = self._desktop_fixture(tmp, {"mcpServers": {
-                "tokenmeter": {"command": "/tmp/different", "args": [], "env": {}}}})
-            _, unreadable = self._desktop_fixture(tmp, b"{bad", root_name="Claude-3p")
-            status = meter.claude_desktop_access_status(launcher, [str(conflicting), str(unreadable)])
-            toggled = self._desktop_toggle(launcher, [conflicting, unreadable], True, repair=True)
-            saved = json.loads(conflicting.read_text())
-        self.assertEqual(status["status"], "Claude app config could not be read")
-        self.assertFalse(toggled["ok"])
-        self.assertIn("could not read", toggled["error"])
-        self.assertEqual(saved["mcpServers"]["tokenmeter"]["command"], "/tmp/different")
-
-    def test_settings_row_shows_unreadable_claude_app_config_instead_of_launcher_error(self):
-        page = Path(DASHBOARD_PAGE).read_text()
-        self.assertIn("const disabled=!row.connected&&!row.available;", page)
-        self.assertIn("try{refreshed=await loadAgentAccess();}finally{agentAccessRechecking=false;}", page)
-        self.assertIn("if(!button||button.disabled)return;", page)
-        self.assertIn("title:'Quit the Claude app first'", page)
-        self.assertIn("title:'Claude app settings could not be read'", page)
-        self.assertIn("const action=row.connected?'Disconnect':row.conflict?'Repair':'Connect';", page)
-        self.assertIn("if(row)openAgentAccessDialog(client,!row.connected);", page)
-        self.assertIn("!row.detected?(row.id==='claude'?row.status:'CLI not found'):"
-                      "!row.available?'Token Meter launcher unavailable':row.status", page)
-
-    def test_unreadable_claude_app_config_does_not_break_other_clients(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp, b"\xff\xfe\x00")
-            status = meter.agent_access_status(
-                launcher=launcher, which=lambda name: None,
-                claude_config_path=str(Path(tmp) / ".claude.json"),
-                claude_desktop_config_paths=[str(path)])
-        self.assertTrue(status["ok"])
-        self.assertIn("The Claude app config could not be read", status["clients"][1]["status"])
-        self.assertEqual(status["clients"][0]["id"], "codex")
-
-    def test_claude_app_write_keeps_a_symlinked_config_linked(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp)
-            real = Path(tmp) / "dotfiles.json"
-            real.write_text(json.dumps({"keep": True}))
-            path.symlink_to(real)
-            self.assertIsNone(meter.write_claude_desktop_access(True, launcher, [str(path)]))
-            self.assertTrue(path.is_symlink())
-            saved = json.loads(real.read_text())
-        self.assertTrue(saved["keep"])
-        self.assertIn("tokenmeter", saved["mcpServers"])
-
-    def test_claude_app_refuses_to_overwrite_a_config_changed_mid_save(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            launcher, path = self._desktop_fixture(tmp, {"preferences": {"v": 1}})
-            original = meter._read_claude_desktop_config
-
-            def app_writes_during_read(target):
-                result = original(target)
-                Path(target).write_text(json.dumps({"preferences": {"v": 2}, "extra": "app"}))
-                return result
-
-            with mock.patch.object(meter, "_read_claude_desktop_config", side_effect=app_writes_during_read):
-                error = meter.write_claude_desktop_access(True, launcher, [str(path)])
-            saved = json.loads(path.read_text())
-        self.assertIn("changed its config", error)
-        self.assertEqual(saved, {"preferences": {"v": 2}, "extra": "app"})
-
-    def test_windows_claude_app_entry_runs_cmd_launcher_through_cmd_exe(self):
-        launcher = r"C:\Token Meter\scripts\run-token-meter-mcp.cmd"
-        entry = meter.claude_desktop_access_entry(launcher)
-        self.assertEqual(entry["command"], "cmd.exe")
-        self.assertEqual(entry["args"], ["/c", launcher])
-        self.assertTrue(meter._claude_desktop_entry_matches(entry, launcher))
-        self.assertFalse(meter._claude_desktop_entry_matches(
-            {"command": launcher, "args": [], "env": {"TOKEN_METER_CALLER": "claude"}}, launcher))
-
-
-class CapabilityConfigTests(unittest.TestCase):
-    def test_skill_catalog_cache_avoids_rescanning_but_refreshes_usage(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            skill = Path(tmp) / "custom" / "SKILL.md"
-            skill.parent.mkdir()
-            skill.write_text("---\nname: custom\n---\n")
-            codex_pattern = os.path.join(
-                os.path.expanduser("~/.codex/skills"), "**", "SKILL.md",
-            )
-
-            def matching_glob(pattern, recursive=False):
-                del recursive
-                return [str(skill)] if pattern == codex_pattern else []
-
-            meter.invalidate_discovered_skill_cache()
-            try:
-                with mock.patch.object(meter.glob, "glob", side_effect=matching_glob), \
-                        mock.patch.object(
-                            meter, "_skill_measurability", return_value="unknown",
-                        ) as measurability:
-                    first = meter.discovered_skills([{
-                        "name": "custom", "providers": ["codex"],
-                        "activations": 1, "sessions_used": 1,
-                        "last_used": "2026-08-18",
-                    }])
-                    second = meter.discovered_skills([{
-                        "name": "custom", "providers": ["codex"],
-                        "activations": 2, "sessions_used": 2,
-                        "last_used": "2026-08-19",
-                    }])
-            finally:
-                meter.invalidate_discovered_skill_cache()
-
-        self.assertEqual(measurability.call_count, 1)
-        self.assertEqual(first[0]["activations"], 1)
-        self.assertEqual(second[0]["activations"], 2)
-        self.assertEqual(second[0]["measurement"], "measurable")
-
-    def scan_claude_skill_rows(self, root, sources):
-        projects = root / "claude-projects"
-        meter.invalidate_discovered_skill_cache()
-        try:
-            with mock.patch.object(meter, "CLAUDE_USER_SKILLS", str(root / "user-skills")), \
-                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(projects)), \
-                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
-                    mock.patch.object(meter, "claude_plugin_installations", return_value={}), \
-                    mock.patch.object(meter, "source_inventory_snapshot",
-                                      return_value={"sources": tuple(sources)}):
-                rows = meter.discovered_skills()
-        finally:
-            meter.invalidate_discovered_skill_cache()
-        return [row for row in rows if row["runtime"] == "Claude"]
-
-    def test_inventory_lists_personal_and_session_project_claude_skills(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            for skill_dir in (root / "user-skills" / "personal-helper",
-                              root / "repo" / ".claude" / "skills" / "repo-review",
-                              root / "codex-repo" / ".claude" / "skills" / "not-claude"):
-                skill_dir.mkdir(parents=True)
-                (skill_dir / "SKILL.md").write_text("---\nname: x\n---\n")
-            session = str(root / "claude-projects" / "p" / "s.jsonl")
-            rows = self.scan_claude_skill_rows(root, [
-                {"provider": "claude", "path": session, "project": str(root / "repo")},
-                {"provider": "claude", "path": session, "project": str(root / "repo")},
-                {"provider": "claude", "path": session, "project": "local"},
-                {"provider": "codex", "path": "/tmp/c.jsonl", "project": str(root / "codex-repo")},
-            ])
-
-        by_name = {row["name"]: row for row in rows}
-        self.assertEqual(set(by_name), {"personal-helper", "repo-review"})
-        self.assertEqual(by_name["personal-helper"]["source"], "Personal")
-        self.assertEqual(by_name["repo-review"]["source"], "Project")
-        self.assertEqual(by_name["repo-review"]["origin_id"], "claude:project")
-        self.assertTrue(by_name["repo-review"]["enabled"])
-        self.assertFalse(by_name["repo-review"]["mutable"])
-
-    def test_project_skill_roots_are_bounded(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            session = os.path.join(tmp, "claude-projects", "p", "s.jsonl")
-            sources = [
-                {"provider": "claude", "path": session, "project": f"/work/repo-{index}"}
-                for index in range(meter.MAX_PROJECT_SKILL_ROOTS + 10)
-            ]
-            with mock.patch.object(meter, "CLAUDE_PROJECTS", os.path.join(tmp, "claude-projects")), \
-                    mock.patch.object(meter, "source_inventory_snapshot",
-                                      return_value={"sources": tuple(sources)}):
-                roots = meter.claude_project_skill_roots()
-        self.assertEqual(len(roots), meter.MAX_PROJECT_SKILL_ROOTS)
-
-    def test_personal_skill_wins_name_clash_and_first_project_wins(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            for skill_dir in (root / "user-skills" / "review",
-                              root / "a" / ".claude" / "skills" / "review",
-                              root / "a" / ".claude" / "skills" / "deploy",
-                              root / "b" / ".claude" / "skills" / "deploy"):
-                skill_dir.mkdir(parents=True)
-                (skill_dir / "SKILL.md").write_text("---\nname: x\n---\n")
-            session = str(root / "claude-projects" / "p" / "s.jsonl")
-            rows = self.scan_claude_skill_rows(root, [
-                {"provider": "claude", "path": session, "project": str(root / "a")},
-                {"provider": "claude", "path": session, "project": str(root / "b")},
-            ])
-
-        self.assertEqual(sorted((row["name"], row["source"]) for row in rows),
-                         [("deploy", "Project"), ("review", "Personal")])
-        deploy = next(row for row in rows if row["name"] == "deploy")
-        self.assertIn(os.path.join("a", ".claude", "skills", "deploy"), deploy["path"])
-
-    def test_skill_catalog_rescans_once_session_inventory_is_ready(self):
-        snapshot = {"ready": False, "sources": ()}
-        meter.invalidate_discovered_skill_cache()
-        try:
-            with mock.patch.object(meter, "source_inventory_snapshot", side_effect=lambda: snapshot), \
-                    mock.patch.object(meter, "_scan_discovered_skills", return_value=[]) as scan:
-                meter.discovered_skills()
-                meter.discovered_skills()
-                snapshot = {"ready": True, "sources": ()}
-                meter.discovered_skills()
-                meter.discovered_skills()
-        finally:
-            meter.invalidate_discovered_skill_cache()
-        self.assertEqual(scan.call_count, 2)
-
-    def test_only_native_skill_tool_calls_count_as_native_activations(self):
-        evidence = meter.summarize_tool_evidence([
-            {**meter.tool_identity("Skill"), "output_tokens": 0, "ts": 100,
-             "args_fingerprint": "a", "error": False, "skills": ["repo-review"]},
-            {**meter.tool_identity("Read"), "output_tokens": 0, "ts": 101,
-             "args_fingerprint": "b", "error": False,
-             "skills": meter.skill_names_from_value(
-                 {"file_path": "/r/.agents/skills/adapter-only/SKILL.md"}, "Read")},
-        ])
-        session = os.path.join(meter.CLAUDE_PROJECTS, "p", "s.jsonl")
-        waste = meter.global_tool_waste([{
-            "id": "s", "provider": "claude", "project": "/r", "path": session,
-            "_tool_evidence": evidence,
-        }])
-        hosts = {row["name"]: row["hosts"]["Claude"] for row in waste["skills"]}
-        self.assertEqual(hosts["repo-review"]["native_activations"], 1)
-        self.assertEqual(hosts["adapter-only"]["activations"], 1)
-        self.assertEqual(hosts["adapter-only"]["native_activations"], 0)
-
-        meter.invalidate_discovered_skill_cache()
-        try:
-            with mock.patch.object(meter, "_scan_discovered_skills", return_value=[]):
-                rows = meter.discovered_skills(waste["skills"])
-        finally:
-            meter.invalidate_discovered_skill_cache()
-        self.assertEqual([row["name"] for row in rows], ["repo-review"])
-
-    def test_unlisted_claude_skill_activations_become_observed_rows(self):
-        inventory = [{"name": "known", "runtime": "Claude", "measurement": "unknown"}]
-        usage = [
-            {"name": "known", "hosts": {"Claude": {"activations": 2, "native_activations": 2}}},
-            {"name": "repo-only", "hosts": {"Claude": {
-                "activations": 3, "native_activations": 3,
-                "sessions_used": 2, "last_used": "2026-10-27",
-            }}},
-            {"name": "path-only", "hosts": {"Claude": {"activations": 2, "native_activations": 0}}},
-            {"name": "codex-only", "hosts": {"Codex": {"activations": 4, "native_activations": 4}}},
-            {"name": "legacy", "providers": ["claude"], "activations": 1},
-            {"name": "${name}", "hosts": {"Claude": {"activations": 1, "native_activations": 1}}},
-        ]
-        meter.invalidate_discovered_skill_cache()
-        try:
-            with mock.patch.object(meter, "_scan_discovered_skills", return_value=inventory):
-                rows = meter.discovered_skills(usage)
-        finally:
-            meter.invalidate_discovered_skill_cache()
-
-        by_name = {row["name"]: row for row in rows}
-        self.assertEqual(set(by_name), {"known", "repo-only"})
-        self.assertEqual(by_name["known"]["activations"], 2)
-        observed = by_name["repo-only"]
-        self.assertEqual(observed["source"], "Observed in traces")
-        self.assertEqual(observed["configuration"], "Not in config")
-        self.assertIsNone(observed["enabled"])
-        self.assertEqual((observed["activations"], observed["sessions_used"]), (3, 2))
-        self.assertEqual(observed["last_used"], "2026-10-27")
-        self.assertEqual(observed["measurement"], "measurable")
-        self.assertEqual(observed["id"], "skill:claude:claude:observed:repo-only")
-
-    def test_skill_identity_separates_runtime_origin_and_plugin(self):
-        identities = {
-            meter.skill_identity("Codex", "browser", "codex:built-in"),
-            meter.skill_identity("Codex", "browser", "codex:user"),
-            meter.skill_identity("Codex", "browser", "codex:plugin:openai-bundled", "browser@openai-bundled"),
-            meter.skill_identity("Claude", "browser", "claude:plugin:skills-marketplace", "browser@skills-marketplace"),
-        }
-        self.assertEqual(len(identities), 4)
-
-    def test_optional_summary_counts_only_mutable_skill_packs(self):
-        mcp_items = [
-            {"name": "context7", "mutable": True, "enabled": True, "used": False,
-             "codex_enabled": True, "claude_enabled": False},
-            {"name": "core", "mutable": False, "enabled": True, "used": False},
-        ]
-        skill_items = [
-            {"name": "browser", "runtime": "Codex", "plugin_id": "browser@bundled",
-             "mutable": True, "enabled": True, "used": True, "activations": 2},
-            {"name": "local", "runtime": "Codex", "plugin_id": "",
-             "mutable": False, "enabled": True, "used": False},
-        ]
-        groups = meter.capability_control_groups(mcp_items, skill_items)
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(summary["enabled"], 1)
-        self.assertEqual(summary["used"], 1)
-        self.assertEqual(summary["unused"], 0)
-        self.assertEqual(summary["mcp_enabled"], 0)
-        self.assertEqual(summary["skill_packs_enabled"], 1)
-
-    def test_runtime_skill_packs_are_not_review_candidates(self):
-        skill_items = [
-            {"id": "runtime-skill", "name": "browser", "runtime": "Codex",
-             "plugin_id": "browser@openai-bundled", "mutable": True, "enabled": True,
-             "used": False, "reviewable": False, "origin": "runtime_pack"},
-            {"id": "user-skill", "name": "custom", "runtime": "Codex",
-             "plugin_id": "custom@personal", "mutable": True, "enabled": True,
-             "used": False, "reviewable": True, "origin": "user_plugin"},
-        ]
-        groups = meter.capability_control_groups([], skill_items)
-        summary = meter.optional_capability_summary(groups)
-        self.assertEqual(summary["enabled"], 1)
-        self.assertEqual(summary["review_candidates"], ["skill_pack:Codex:custom@personal"])
-
-    def test_observed_tools_do_not_claim_configuration_enabled(self):
-        waste = {"inventory_tools": [{
-            "id": "codex::exec", "name": "exec", "display": "exec",
-            "kind": "tool", "runtime": "Codex", "namespace": "shell",
-            "calls": 2, "output_tokens": 120, "last_used": "2026-08-10",
-            "advertised_sessions": 0, "eager_sessions": 0, "deferred_sessions": 0,
-        }]}
-        with mock.patch.object(meter, "codex_mcp_states", return_value={}), \
-                mock.patch.object(meter, "claude_mcp_states", return_value={}), \
-                mock.patch.object(meter, "discovered_skills", return_value=[]), \
-                mock.patch.object(meter, "claude_desktop_index", return_value={}), \
-                mock.patch.object(meter, "claude_local_agent_sources", return_value=[]):
-            capabilities = meter.capability_inventory(waste)
-        row = capabilities["items"][0]
-        self.assertIsNone(row["enabled"])
-        self.assertEqual(row["configuration"], "Unknown")
-        self.assertEqual(row["state"], "Observed only")
-        self.assertIsNone(capabilities["summary"]["tools"]["enabled"])
-        self.assertEqual(capabilities["summary"]["tools"]["observed"], 1)
-
-    def test_capability_revisions_are_stable_across_generation_time(self):
-        waste = {"inventory_tools": [{
-            "id": "codex::exec", "name": "exec", "display": "exec",
-            "kind": "tool", "runtime": "Codex", "namespace": "shell",
-            "calls": 2, "output_tokens": 120, "last_used": "2026-08-10",
-            "advertised_sessions": 1, "eager_sessions": 1, "deferred_sessions": 0,
-        }]}
-        with mock.patch.object(meter, "codex_mcp_states", return_value={}), \
-                mock.patch.object(meter, "claude_mcp_states", return_value={}), \
-                mock.patch.object(meter, "discovered_skills", return_value=[]), \
-                mock.patch.object(meter, "claude_desktop_index", return_value={}), \
-                mock.patch.object(meter, "claude_local_agent_sources", return_value=[]), \
-                mock.patch.object(meter.time, "time", side_effect=[100, 200, 300]):
-            first = meter.capability_inventory(waste)
-            second = meter.capability_inventory(waste)
-            changed = meter.capability_inventory({
-                **waste,
-                "inventory_tools": [{**waste["inventory_tools"][0], "calls": 3}],
-            })
-        self.assertNotEqual(first["generated_at"], second["generated_at"])
-        self.assertEqual(first["review_revision"], second["review_revision"])
-        self.assertEqual(first["inventory_revision"], second["inventory_revision"])
-        self.assertEqual(first["revision"], second["revision"])
-        self.assertNotEqual(second["inventory_revision"], changed["inventory_revision"])
-        self.assertNotEqual(second["revision"], changed["revision"])
-
-    def test_dashboard_state_omits_heavy_capability_rows_and_tool_waste(self):
-        capabilities = {
-            "items": [{"id": "tool:exec"}],
-            "summary": {"tools": {"available": 1}},
-            "control_groups": [], "inventory_revision": "inventory-a",
-        }
-        state = {"xsession": {
-            "capabilities": capabilities,
-            "tool_waste": {"inventory_tools": [{"private": "trace detail"}]},
-            "total_sessions": 2,
-        }}
-        payload = meter.dashboard_state_payload(state)
-        public_capabilities = payload["xsession"]["capabilities"]
-        self.assertNotIn("items", public_capabilities)
-        self.assertEqual(public_capabilities["inventory_count"], 1)
-        self.assertNotIn("tool_waste", payload["xsession"])
-        self.assertIn("items", state["xsession"]["capabilities"])
-        self.assertIn("tool_waste", state["xsession"])
-        self.assertIn(
-            'elif req_path == "/capabilities/inventory":',
-            Path(meter.IMPLEMENTATION_FILE).read_text(),
-        )
-
-    def test_pack_without_runtime_logs_is_not_a_review_candidate(self):
-        base = {
-            "id": "skill_pack:Claude:custom@personal", "name": "custom@personal",
-            "control_type": "skill_pack", "enabled": True, "used": False,
-            "mutable": True, "reviewable": True, "unmeasurable": False,
-        }
-        unscanned = meter.optional_capability_summary([{**base, "scanned_sessions": 0}])
-        scanned = meter.optional_capability_summary([{**base, "scanned_sessions": 3}])
-        self.assertEqual(unscanned["review_candidates"], [])
-        self.assertEqual(unscanned["unscanned_packs"], 1)
-        self.assertEqual(scanned["review_candidates"], [base["id"]])
-        self.assertEqual(scanned["unscanned_packs"], 0)
-
-    def test_claude_desktop_and_3p_logs_do_not_cover_claude_code_packs(self):
-        skill = {
-            "id": "skill:claude:custom@personal:custom", "name": "custom",
-            "runtime": "Claude", "source": "User-installed plugin",
-            "plugin_id": "custom@personal", "mutable": True, "enabled": True,
-            "used": False, "reviewable": True, "measurement": "measurable",
-            "unmeasurable": False, "activations": 0, "last_used": "Never",
-            "setting_path": "~/.claude/settings.json",
-        }
-        for runtime in ("Claude Desktop", "Claude-3P"):
-            with self.subTest(runtime=runtime):
-                waste = meter.global_tool_waste([{
-                    "id": runtime, "provider": "claude", "runtime": runtime,
-                    "project": "/repo", "_tool_evidence": {},
-                }])
-                with mock.patch.object(meter, "codex_mcp_states", return_value={}), \
-                        mock.patch.object(meter, "claude_mcp_states", return_value={}), \
-                        mock.patch.object(meter, "discovered_skills", return_value=[skill]), \
-                        mock.patch.object(meter, "claude_desktop_index", return_value={}), \
-                        mock.patch.object(meter, "claude_local_agent_sources", return_value=[]):
-                    capabilities = meter.capability_inventory(waste)
-                self.assertEqual(capabilities["control_groups"][0]["scanned_sessions"], 0)
-                self.assertEqual(
-                    capabilities["summary"]["optional"]["review_candidates"], []
-                )
-
-    def test_bulk_disable_accepts_only_exact_review_candidates(self):
-        capabilities = {
-            "summary": {"optional": {"review_candidates": ["skill_pack:Claude:custom@personal"]}},
-            "control_groups": [
-                {"id": "skill_pack:Claude:custom@personal", "name": "custom@personal",
-                 "control_type": "skill_pack", "enabled": True, "used": False,
-                 "mutable": True, "reviewable": True},
-                {"id": "skill_pack:Codex:browser@openai-bundled", "name": "browser@openai-bundled",
-                 "control_type": "skill_pack", "enabled": True, "used": False,
-                 "mutable": True, "reviewable": False},
-            ],
-        }
-        changed = []
-
-        def fake_setter(control, enabled):
-            changed.append((control["id"], enabled))
-            return {"ok": True, "verified": True}
-
-        result = meter.disable_capability_controls(
-            ["skill_pack:Claude:custom@personal"], capabilities, fake_setter)
-        rejected = meter.disable_capability_controls(
-            ["skill_pack:Codex:browser@openai-bundled"], capabilities, fake_setter)
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["changed"], 1)
-        self.assertEqual(changed, [("skill_pack:Claude:custom@personal", False)])
-        self.assertFalse(rejected["ok"])
-        self.assertEqual(rejected["invalid_control_ids"], ["skill_pack:Codex:browser@openai-bundled"])
-
-    def test_session_optional_summary_excludes_mcp_and_default_activity(self):
-        capabilities = {"control_groups": [
-            {"id": "skill_pack:Codex:browser@bundled", "control_type": "skill_pack",
-             "name": "browser@bundled", "runtime": "Codex", "enabled": True,
-             "mutable": True, "members": ["browser"]},
-        ], "summary": {"optional": {"review_candidate_names": []}}}
-        state = {"provider": "codex", "tools": {
-            "by_name": [
-                {"name": "exec", "namespace": "exec", "kind": "tool", "calls": 3},
-                {"name": "mcp__context7__query", "namespace": "context7", "kind": "mcp", "calls": 1},
-            ],
-            "skills": [{"name": "browser", "activations": 1}],
-        }}
-        summary = meter.session_optional_capabilities(state, capabilities)
-        self.assertEqual(summary["enabled"], 1)
-        self.assertEqual(summary["used"], 1)
-        self.assertEqual(summary["mcp_enabled"], 0)
-        self.assertEqual(summary["avoidable_eager_definition_tokens"], 0)
-        self.assertNotIn("context7", [row["name"] for row in summary["groups"]])
-
-    def test_mcp_parser_ignores_nested_env_section(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "config.toml"
-            path.write_text("[mcp_servers.node_repl]\nenabled = false\n[mcp_servers.node_repl.env]\nTOKEN = 'x'\n")
-            rows = meter.toml_named_sections(str(path), "mcp_servers")
-        self.assertEqual(list(rows), ["node_repl"])
-
-    def test_codex_plugin_toggle_changes_only_enabled_state(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "config.toml"
-            path.write_text('[plugins."docs@runtime"]\nenabled = true\nsource = "keep"\n[features]\nskills = true\n')
-            with mock.patch.object(meter, "CODEX_CONFIG", str(path)):
-                result = meter.set_codex_plugin_enabled("docs@runtime", False)
-            text = path.read_text()
-        self.assertTrue(result["ok"])
-        self.assertTrue(result["verified"])
-        self.assertIn("enabled = false", text)
-        self.assertIn('source = "keep"', text)
-
-    def test_claude_plugin_toggle_verifies_written_setting(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"enabledPlugins": {"docs@personal": True}}))
-            with (mock.patch.object(meter, "CLAUDE_SETTINGS", str(path)),
-                  mock.patch.object(meter, "claude_plugin_installations",
-                                    return_value={"docs@personal": {"installPath": tmp}})):
-                result = meter.set_claude_plugin_enabled("docs@personal", False)
-            written = json.loads(path.read_text())
-        self.assertTrue(result["ok"])
-        self.assertTrue(result["verified"])
-        self.assertFalse(written["enabledPlugins"]["docs@personal"])
-
-
-class DailySummaryTests(unittest.TestCase):
-    def test_compare_sessions_state_projects_selected_sessions_without_content(self):
-        from token_meter.domain.compare import trace_key
-        pool = [
-            {"id": "one", "path": "/private/traces/ws/one/messages.jsonl", "provider": "kiro"},
-            {"id": "two", "path": "/private/traces/ws/two/messages.jsonl", "provider": "kiro"},
-            {"id": "root", "path": "/private/traces/rollout-9-root.jsonl", "provider": "codex"},
-        ]
-        key = {source["id"]: trace_key(source) for source in pool}
-
-        def summary(source):
-            return {
-                "id": source["id"], "path": source["path"], "title": "Same prompt",
-                "label": "Kiro", "provider": source["provider"], "models": ["m"],
-                "usage_basis": "reported", "availability": {"cost": True},
-            }
-
-        def state(source):
-            cost = 1.0 if source["id"] == "one" else 2.5
-            return {
-                "availability": {"cost": True, "tokens": True},
-                "total_cost": cost, "turns": 4, "total_tokens": 1000,
-                "timing": {"duration_s": 60, "duration_available": True},
-                "series": [{"i": 1, "cost": cost, "in": 10, "out": 5,
-                            "user_message": "PRIVATE PROMPT TEXT"}],
-                "source": {"path": source["path"]},
-            }
-
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["sessions"] = [
-                {"id": "one", "title": "Same prompt", "path": pool[0]["path"]},
-                {"id": "root", "title": "same prompt", "mtime": 5, "cost": 0.4, "path": pool[2]["path"]},
-                {"id": "four", "title": "Different", "path": "/private/traces/four.jsonl"},
-            ]
-            with mock.patch.object(meter, "cached_session_sources", return_value=(pool, True)), \
-                    mock.patch.object(meter, "session_summary", side_effect=summary), \
-                    mock.patch.object(meter, "cached_session_state", side_effect=state):
-                payload, status = meter.compare_sessions_state(f"{key['one']},{key['two']},tgone")
-                single, single_status = meter.compare_sessions_state(key["one"])
-                empty, empty_status = meter.compare_sessions_state("")
-                missing, missing_status = meter.compare_sessions_state("tgone,talsogone")
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(status, 200)
-        self.assertTrue(payload["ok"])
-        self.assertEqual([row["letter"] for row in payload["sessions"]], ["A", "B"])
-        self.assertEqual([row["id"] for row in payload["sessions"]], ["one", "two"])
-        # Repeated file names fall back to the session id; unique stems open the exact trace.
-        self.assertEqual([row["open_id"] for row in payload["sessions"]], ["one", "two"])
-        self.assertEqual(payload["missing"], ["tgone"])
-        self.assertTrue(payload["same_title"])
-        self.assertEqual(payload["best"]["cost"], key["one"])
-        self.assertEqual([row["key"] for row in payload["matches"]], [key["root"]])
-        self.assertEqual(payload["matches"][0]["open_id"], "rollout-9-root")
-        encoded = json.dumps(payload)
-        self.assertNotIn("PRIVATE PROMPT TEXT", encoded)
-        self.assertNotIn("/private/traces", encoded)
-        self.assertEqual(single_status, 200)
-        self.assertNotIn("insights", single)
-        self.assertNotIn("insights", payload)
-        self.assertEqual((empty_status, empty["ok"]), (400, False))
-        self.assertEqual((missing_status, missing["ok"]), (404, False))
-        self.assertIn(
-            'elif req_path == "/session/compare":',
-            Path(meter.IMPLEMENTATION_FILE).read_text(),
-        )
-        self.assertFalse(meter.is_dashboard_page_path("/session/compare"))
-
-    def test_spend_logs_state_validates_and_returns_full_range(self):
-        sessions = (
-            {
-                "id": "multi-day", "title": "Multi day", "project": "/repo/a",
-                "provider": "codex", "label": "Codex",
-                "availability": {"cost": True},
-                "input_tokens": 12000, "output_tokens": 600, "turns": 6,
-                "duration_s": 420, "duration_available": True,
-                "duration_basis": "observed", "token_estimate": True,
-                "_day_cost": {
-                    "2026-08-01": 1.25,
-                    "2026-08-02": 2.75,
-                    "2026-08-03": 8.0,
-                },
-            },
-            {
-                "id": "second", "title": "Second", "project": "/repo/b",
-                "provider": "claude", "label": "Claude",
-                "availability": {"cost": True},
-                "_day_cost": {"2026-08-02": 2.0},
-            },
-        )
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess["internal_rows"] = sessions
-            with mock.patch.object(
-                meter, "cross_session", return_value={"generated_at": 123},
-            ):
-                payload, status = meter.spend_logs_state(
-                    "2026-08-01", "2026-08-02",
-                )
-                missing, missing_status = meter.spend_logs_state("", "2026-08-02")
-                malformed, malformed_status = meter.spend_logs_state(
-                    "2026-08-01", "not-a-date",
-                )
-                reversed_range, reversed_status = meter.spend_logs_state(
-                    "2026-08-03", "2026-08-02",
-                )
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-
-        self.assertEqual(status, 200)
-        self.assertTrue(payload["ok"])
-        self.assertEqual(payload["generated_at"], 123)
-        self.assertEqual(payload["from"], "2026-08-01")
-        self.assertEqual(payload["to"], "2026-08-02")
-        self.assertEqual(payload["total_sessions"], 2)
-        self.assertEqual(payload["total_cost"], 6.0)
-        self.assertEqual(payload["sessions"][0]["id"], "multi-day")
-        self.assertEqual(payload["sessions"][0]["input_tokens"], 12000)
-        self.assertEqual(payload["sessions"][0]["output_tokens"], 600)
-        self.assertEqual(payload["sessions"][0]["turns"], 6)
-        self.assertEqual(payload["sessions"][0]["duration_s"], 420)
-        self.assertTrue(payload["sessions"][0]["duration_available"])
-        self.assertEqual(payload["sessions"][0]["duration_basis"], "observed")
-        self.assertEqual(payload["sessions"][0]["usage_basis"], "local_estimate")
-        for error, error_status in (
-            (missing, missing_status),
-            (malformed, malformed_status),
-            (reversed_range, reversed_status),
-        ):
-            self.assertEqual(error_status, 400)
-            self.assertFalse(error["ok"])
-        self.assertIn(
-            'elif req_path == "/spend/logs":',
-            Path(meter.IMPLEMENTATION_FILE).read_text(),
-        )
-
-    def test_aggregates_daily_spend_providers_and_logs(self):
-        sessions = [
-            {"id": "one", "title": "One", "project": "/repo/a", "provider": "codex",
-             "label": "Codex", "_day_cost": {"2026-07-01": 1.25},
-             "_wait_samples": [
-                 {"day": "2026-07-01", "duration_s": 20},
-                 {"day": "2026-07-01", "duration_s": 40},
-             ]},
-            {"id": "two", "title": "Two", "project": "/repo/b", "provider": "claude",
-             "label": "Claude Code", "_day_cost": {"2026-07-01": 0.75, "2026-06-30": 0.5},
-             "_wait_samples": [{"day": "2026-07-01", "duration_s": 30}]},
-        ]
-        days = meter.daily_summaries(sessions)
-        self.assertEqual(days[0]["day"], "2026-07-01")
-        self.assertEqual(days[0]["cost"], 2.0)
-        self.assertEqual(days[0]["sessions"], 2)
-        self.assertEqual(days[0]["projects"], 2)
-        self.assertNotIn("tool_tokens", days[0])
-        self.assertNotIn("flagged_tokens", days[0])
-        provider = days[0]["providers"][0]
-        self.assertEqual(provider["provider"], "codex")
-        self.assertEqual(provider["cost"], 1.25)
-        self.assertEqual(provider["wait_s"], 60.0)
-        self.assertEqual(provider["wait_samples"], 2)
-        self.assertEqual(provider["usage_basis"], "reported")
-        self.assertEqual(days[0]["wait_time"]["total_s"], 90)
-        self.assertEqual(days[0]["wait_time"]["avg_s"], 30)
-        self.assertEqual(days[0]["wait_time"]["max_s"], 40)
-
-    def test_unbounded_daily_history_has_compact_spend_projection(self):
-        sessions = [{
-            "id": "one", "title": "Private title", "project": "/private/repo",
-            "provider": "codex", "label": "Codex",
-            "_day_cost": {
-                f"2026-07-{day:02d}": float(day) for day in range(1, 32)
-            },
-        }]
-        legacy = meter.daily_summaries(sessions)
-        complete = meter.daily_summaries(sessions, limit=None)
-        spend = meter.spend_projection(complete)
-        self.assertEqual(len(legacy), 30)
-        self.assertEqual(len(complete), 31)
-        self.assertEqual(spend[0]["day"], "2026-07-31")
-        self.assertEqual(spend[0]["providers"][0]["provider"], "codex")
-        self.assertEqual(spend[0]["providers"][0]["cost"], 31.0)
-        self.assertEqual(
-            set(spend[0]),
-            {"day", "cost", "providers", "coverage", "provenance",
-             "usage_basis", "availability"},
-        )
-        serialized = json.dumps(spend)
-        self.assertNotIn("Private title", serialized)
-        self.assertNotIn("/private/repo", serialized)
-        self.assertNotIn("top_sessions", serialized)
-
-    def test_cross_session_publishes_spend_history_and_keeps_daily(self):
-        saved_cache = dict(meter._xsess)
-        try:
-            meter._xsess.update({"data": None, "at": 0, "sessions": []})
-            result = meter.cross_session(sources=[])
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved_cache)
-        self.assertEqual(result["spend"], {"days": []})
-        self.assertEqual(result["daily"], [])
-
-
-class MonthlyBudgetTests(unittest.TestCase):
-    def test_budget_settings_persist_session_overrides_without_changing_defaults(self):
-        """A session cap survives settings writes and remains distinct from its default."""
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            result = meter.set_budget_settings({
-                "default_session_budget": 10,
-                "session_budgets": {"session-1": 25.5},
-                "allocations": {},
-                "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            }, str(path))
-            stored = json.loads(path.read_text())
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["budgets"].get("default_session_budget"), 10.0)
-        self.assertEqual(result["budgets"].get("session_budgets"), {"session-1": 25.5})
-        self.assertEqual(stored["budgets"].get("session_budgets"), {"session-1": 25.5})
-
-    def test_general_budget_save_preserves_existing_session_overrides(self):
-        """The Settings form must not erase caps it does not display or submit."""
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            meter.set_session_budget_override("session-1", 25, path=str(path))
-            result = meter.set_budget_settings({
-                "default_session_budget": 12,
-                "allocations": {},
-                "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            }, str(path))
-            stored = json.loads(path.read_text())
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(stored["budgets"]["default_session_budget"], 12.0)
-        self.assertEqual(stored["budgets"]["session_budgets"], {"session-1": 25.0})
-
-    def test_concurrent_session_compare_and_set_allows_one_writer(self):
-        """Competing confirmed writes must serialize to success plus stale response."""
-        with tempfile.TemporaryDirectory() as tmp:
-            path = str(Path(tmp) / "settings.json")
-            ready = threading.Barrier(2)
-            results = []
-
-            def change(budget):
-                ready.wait()
-                results.append(meter.set_session_budget_override(
-                    "session-1", budget, expected_current_budget_usd=10, path=path,
-                ))
-
-            first = threading.Thread(target=change, args=(12,))
-            second = threading.Thread(target=change, args=(15,))
-            first.start()
-            second.start()
-            first.join()
-            second.join()
-
-        self.assertEqual(sum(result["ok"] for result in results), 1)
-        self.assertEqual(sum("changed" in result.get("error", "") for result in results), 1)
-
-    def test_default_session_budget_compare_and_set_rejects_a_stale_budget(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = str(Path(tmp) / "settings.json")
-            first = meter.set_default_session_budget_value(
-                12, expected_current_budget_usd=10, path=path,
-            )
-            stale = meter.set_default_session_budget_value(
-                15, expected_current_budget_usd=10, path=path,
-            )
-
-        self.assertTrue(first["ok"])
-        self.assertFalse(stale["ok"])
-        self.assertIn("changed", stale["error"])
-
-    def test_agent_budget_projection_excludes_unrequested_global_configuration(self):
-        source = {"id": "session-1", "provider": "codex", "client": "Codex"}
-        state = {"total_cost": 3, "availability": {"cost": True}}
-        settings = meter.normalize_budget_settings({
-            "default_session_budget": 10,
-            "session_budgets": {"session-1": 5},
-            "allocations": {}, "thresholds": [80, 90, 100],
-            "native_notifications": True,
-        })
-        with mock.patch.object(meter, "resolve_agent_source", return_value=(source, "explicit")), \
-                mock.patch.object(meter, "recompute", return_value=state), \
-                mock.patch.object(meter, "budget_settings", return_value=settings):
-            result = meter.agent_budget(session_id="session-1")
-
-        self.assertEqual(result["session"]["budget_usd"], 5)
-        self.assertNotIn("default_session_budget_usd", result)
-        self.assertNotIn("session_budget_overrides", result)
-        self.assertNotIn("lower bound", result["caveat"])
-
-    def test_agent_budget_caveat_marks_partial_family_spend_as_lower_bound(self):
-        source = {"id": "ses_root", "provider": "opencode", "client": "OpenCode"}
-        state = {"total_cost": 1.0, "availability": {"cost": True}}
-        family = [
-            {"id": "ses_root", "provider": "opencode", "cost": 1.0,
-             "availability": {"cost": True}},
-            {"id": "ses_child", "provider": "opencode", "cost": 0.0,
-             "is_child_session": True, "root_session_id": "ses_root",
-             "availability": {"cost": False}},
-        ]
-        settings = meter.normalize_budget_settings({})
-        with mock.patch.object(meter, "resolve_agent_source", return_value=(source, "explicit")), \
-                mock.patch.object(meter, "recompute", return_value=state), \
-                mock.patch.object(meter, "budget_settings", return_value=settings), \
-                mock.patch.dict(meter._xsess, {"sessions": family}):
-            result = meter.agent_budget(session_id="ses_root")
-
-        self.assertTrue(result["session"]["cost_partial"])
-        self.assertIn("Spend is a lower bound", result["caveat"])
-
-    def test_session_override_compare_and_set_rejects_a_stale_budget(self):
-        """A delayed agent must not silently replace a newer session cap."""
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            first = meter.set_session_budget_override(
-                "session-1", 12, expected_current_budget_usd=10, path=str(path),
-            )
-            stale = meter.set_session_budget_override(
-                "session-1", 15, expected_current_budget_usd=10, path=str(path),
-            )
-            effective, source = meter.effective_session_budget(
-                "session-1", meter.budget_settings(str(path)),
-            )
-
-        self.assertTrue(first["ok"])
-        self.assertFalse(stale["ok"])
-        self.assertIn("changed", stale["error"])
-        self.assertEqual((effective, source), (12.0, "session_override"))
-
-    def test_missing_default_session_budget_migrates_to_ten(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({
-                "budgets": {
-                    "currency": "USD",
-                    "allocations": {},
-                    "thresholds": [80, 90, 100],
-                    "native_notifications": True,
-                },
-            }))
-
-            loaded = meter.budget_settings(str(path))
-
-        self.assertEqual(loaded.get("default_session_budget"), 10)
-
-    def test_default_session_budget_is_validated_and_persisted(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"model_pricing": {"claude": {}}}))
-            too_small = meter.set_budget_settings({
-                "default_session_budget": 0,
-                "allocations": {},
-                "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            }, str(path))
-            result = meter.set_budget_settings({
-                "default_session_budget": 25.5,
-                "allocations": {},
-                "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            }, str(path))
-            stored = json.loads(path.read_text())
-
-        self.assertFalse(too_small["ok"])
-        self.assertIn("Default session budget", too_small["error"])
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["budgets"]["default_session_budget"], 25.5)
-        self.assertEqual(stored["budgets"]["default_session_budget"], 25.5)
-        self.assertIn("model_pricing", stored)
-
-    def test_settings_derive_total_from_allocations_and_preserve_other_machine_settings(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"model_pricing": {"claude": {}}}))
-            invalid = meter.set_budget_settings({
-                "allocations": {"claude": 60_000_000, "codex": 50_000_000},
-                "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            }, str(path))
-            result = meter.set_budget_settings({
-                "allocations": {"claude": 50, "codex": 30, "cursor": 0},
-                "thresholds": [75, 90, 100],
-                "native_notifications": False,
-            }, str(path))
-            stored = json.loads(path.read_text())
-        self.assertFalse(invalid["ok"])
-        self.assertTrue(result["ok"])
-        self.assertEqual(stored["budgets"]["monthly_total"], 80)
-        self.assertEqual(
-            stored["budgets"]["allocations"],
-            {"claude": 50, "codex": 30, "cursor": 0, "opencode": 0, "kiro": 0, "pi": 0, "hermes": 0, "agy": 0},
-        )
-        self.assertIn("model_pricing", stored)
-
-    def test_missing_runtime_budgets_default_to_zero_and_explicit_values_are_preserved(self):
-        legacy = {
-            "currency": "USD",
-            "monthly_total": 100,
-            "allocations": {},
-            "thresholds": [80, 90, 100],
-            "native_notifications": True,
-        }
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "settings.json"
-            path.write_text(json.dumps({"budgets": legacy}))
-            loaded = meter.budget_settings(str(path))
-            saved = meter.set_budget_settings({
-                "allocations": {"claude": 0, "codex": 1490, "cursor": 0},
-                "thresholds": [80, 90, 100],
-                "native_notifications": True,
-            }, str(path))
-        self.assertEqual(loaded["monthly_total"], 0)
-        self.assertEqual(
-            loaded["allocations"],
-            {"claude": 0, "codex": 0, "cursor": 0, "opencode": 0, "kiro": 0, "pi": 0, "hermes": 0, "agy": 0},
-        )
-        self.assertTrue(saved["ok"])
-        self.assertEqual(saved["budgets"]["monthly_total"], 1490)
-        self.assertEqual(
-            saved["budgets"]["allocations"],
-            {"claude": 0, "codex": 1490, "cursor": 0, "opencode": 0, "kiro": 0, "pi": 0, "hermes": 0, "agy": 0},
-        )
-
-    def test_monthly_rollup_keeps_runtime_costs_and_partial_coverage(self):
-        sessions = [
-            {
-                "id": "reported", "provider": "claude",
-                "_day_cost": {"2026-07-01": 20, "2026-07-03": 10},
-                "_model_daily": [{"day": "2026-07-01"}],
-                "availability": {"cost": True},
-            },
-            {
-                "id": "estimated", "provider": "cursor", "token_estimate": True,
-                "_day_cost": {"2026-07-02": 5},
-                "_model_daily": [{"day": "2026-07-02"}],
-                "availability": {"cost": True},
-            },
-            {
-                "id": "missing", "provider": "codex",
-                "_model_daily": [{"day": "2026-07-04"}],
-                "availability": {"cost": False},
-            },
-        ]
-        rows = meter.monthly_summaries(sessions)
-        self.assertEqual(rows[0]["month"], "2026-07")
-        self.assertEqual(rows[0]["cost"], 35)
-        self.assertEqual(rows[0]["active_days"], 3)
-        self.assertEqual(rows[0]["sessions"], 3)
-        self.assertFalse(rows[0]["coverage"]["cost"]["complete"])
-        self.assertEqual(rows[0]["provenance"]["estimated_cost"], 5)
-        self.assertEqual(
-            {row["provider"]: row["cost"] for row in rows[0]["providers"]},
-            {"claude": 30, "cursor": 5, "codex": 0},
-        )
-
-    def test_budget_status_projects_after_three_spend_days_and_marks_lower_bound(self):
-        months = [{
-            "month": "2026-07", "cost": 60, "active_days": 3, "observed_days": 4,
-            "providers": [
-                {"provider": "claude", "cost": 40},
-                {"provider": "codex", "cost": 20},
-            ],
-            "coverage": {"cost": {
-                "covered_sessions": 2, "total_sessions": 3, "complete": False,
-            }},
-            "provenance": {
-                "estimated_sessions": 0, "estimated_cost": 0,
-                "usage_basis": "reported",
-            },
-        }]
-        status = meter.monthly_budget_status(months, {
-            "allocations": {"claude": 50, "codex": 30, "cursor": 0},
-            "thresholds": [50, 80, 100],
-            "native_notifications": True,
-        }, now=meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc))
-        self.assertEqual(status["spend"], 60)
-        self.assertEqual(status["budget"], 80)
-        self.assertEqual(status["remaining"], 20)
-        self.assertEqual(status["unallocated"], 0)
-        self.assertAlmostEqual(status["projected_spend"], 186)
-        self.assertTrue(status["lower_bound"])
-        self.assertEqual(status["thresholds_crossed"], [50])
-        self.assertEqual(status["next_threshold"], 80)
-        claude = next(row for row in status["runtimes"] if row["provider"] == "claude")
-        self.assertEqual(claude["percent"], 0.8)
-
-    def test_antigravity_character_estimates_are_shown_but_do_not_drive_alerts(self):
-        def month(agy_estimated_cost):
-            return [{
-                "month": "2026-07", "cost": 110, "active_days": 4,
-                "providers": [
-                    {"provider": "agy", "cost": 90,
-                     "provenance": {"estimated_sessions": 1, "estimated_cost": agy_estimated_cost}},
-                    {"provider": "codex", "cost": 20, "provenance": {"estimated_sessions": 0}},
-                ],
-                "coverage": {"cost": {"covered_sessions": 2, "total_sessions": 2, "complete": True}},
-                "provenance": {"estimated_sessions": 1},
-            }]
-
-        settings = {
-            "allocations": {"agy": 50, "codex": 50},
-            "thresholds": [50, 80, 100],
-            "native_notifications": True,
-        }
-        now = meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc)
-        estimated = meter.monthly_budget_status(month(80), settings, now=now)
-        measured = meter.monthly_budget_status(month(0), settings, now=now)
-
-        # The budget card shows the full spend, estimates included.
-        self.assertEqual(estimated["spend"], 110)
-        self.assertAlmostEqual(estimated["percent"], 1.1)
-        agy = next(row for row in estimated["runtimes"] if row["provider"] == "agy")
-        self.assertEqual(agy["spend"], 90)
-        # Alerts are measured without the character estimates.
-        self.assertEqual(estimated["alert_excluded_spend"], 80)
-        self.assertAlmostEqual(estimated["alert_percent"], 0.3)
-        self.assertAlmostEqual(agy["alert_percent"], 0.2)
-        self.assertEqual(estimated["thresholds_crossed"], [])
-        # Everything on the card follows the full spend shown.
-        self.assertEqual(estimated["state"], "over")
-        self.assertIsNone(estimated["next_threshold"])
-        self.assertEqual([row["provider"] for row in estimated["exceeded_runtimes"]], ["agy"])
-        self.assertEqual(measured["alert_excluded_spend"], 0)
-        self.assertAlmostEqual(measured["alert_percent"], 1.1)
-        self.assertEqual(measured["thresholds_crossed"], [50, 80, 100])
-
-    def test_shown_spend_drives_the_warning_state_while_notifications_wait(self):
-        months = [{
-            "month": "2026-07", "cost": 60, "active_days": 4,
-            "providers": [
-                {"provider": "agy", "cost": 40,
-                 "provenance": {"estimated_sessions": 1, "estimated_cost": 40}},
-                {"provider": "codex", "cost": 20, "provenance": {"estimated_sessions": 0}},
-            ],
-            "coverage": {"cost": {"covered_sessions": 2, "total_sessions": 2, "complete": True}},
-            "provenance": {"estimated_sessions": 1},
-        }]
-        status = meter.monthly_budget_status(months, {
-            "allocations": {"agy": 50, "codex": 50},
-            "thresholds": [50, 80, 100],
-            "native_notifications": True,
-        }, now=meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc))
-
-        self.assertEqual(status["state"], "warning")
-        self.assertEqual(status["thresholds_crossed"], [])
-        self.assertEqual(status["next_threshold"], 80)
-
-    def test_runtime_overrun_is_reported_while_overall_budget_is_on_track(self):
-        months = [{
-            "month": "2026-07", "cost": 1501, "active_days": 4,
-            "providers": [{"provider": "codex", "cost": 1501}],
-            "coverage": {"cost": {
-                "covered_sessions": 1, "total_sessions": 1, "complete": True,
-            }},
-            "provenance": {"estimated_sessions": 0},
-        }]
-        status = meter.monthly_budget_status(months, {
-            "allocations": {"claude": 1000, "codex": 1490, "cursor": 1000},
-            "thresholds": [80, 90, 100],
-            "native_notifications": True,
-        }, now=meter.datetime.datetime(2026, 7, 10, tzinfo=meter.datetime.timezone.utc))
-        self.assertEqual(status["state"], "on_track")
-        self.assertTrue(status["runtime_exceeded"])
-        self.assertTrue(status["attention"])
-        self.assertEqual(len(status["exceeded_runtimes"]), 1)
-        self.assertEqual(status["exceeded_runtimes"][0]["provider"], "codex")
-        self.assertEqual(status["exceeded_runtimes"][0]["over_by"], 11)
-        codex = next(row for row in status["runtimes"] if row["provider"] == "codex")
-        self.assertTrue(codex["exceeded"])
-
-
-class McpDocumentationContractTests(unittest.TestCase):
-    def test_maintained_docs_describe_the_read_only_query_surface(self):
-        root = Path(__file__).resolve().parents[1]
-        documents = {
-            path: (root / path).read_text()
-            for path in (
-                "README.md",
-                "specs/USER_GUIDE.md",
-                "specs/ARCHITECTURE.md",
-                "specs/SECURITY.md",
-            )
-        }
-        for path, content in documents.items():
-            with self.subTest(path=path):
-                self.assertIn("read-only", content.lower())
-                for tool in ("sessions", "trace", "stats", "schema"):
-                    self.assertIn(tool, content)
-                self.assertIn("not raw trace content", content.lower())
-
-        combined = "\n".join(documents.values()).lower()
-        for prohibited_claim in (
-            "returns raw prompts",
-            "returns raw responses",
-            "raw tool payloads are available",
-            "trace paths are available",
-        ):
-            self.assertNotIn(prohibited_claim, combined)
-
-
-class PiDocumentationTests(unittest.TestCase):
-    def test_docs_explain_pi_evidence_and_privacy_boundaries(self):
-        root = Path(__file__).resolve().parents[1]
-        guide = (root / "specs/USER_GUIDE.md").read_text()
-        architecture = (root / "specs/ARCHITECTURE.md").read_text()
-        security = (root / "specs/SECURITY.md").read_text()
-
-        self.assertIn("PI_CODING_AGENT_DIR", guide)
-        self.assertIn("Pi coding-agent sessions", guide)
-        self.assertIn("does not import cloud transcripts", guide)
-        guide_copy = " ".join(guide.split())
-        self.assertIn("Wait is inferred from the user-to-assistant timestamps", guide_copy)
-        self.assertIn("semantic token classification remain unavailable", guide_copy)
-        self.assertIn("Pi adapter", architecture)
-        self.assertIn("application-profile", architecture)
-        self.assertIn("application-profile", security)
-
-
-class PiRuntimeTests(unittest.TestCase):
-    """Pi sessions are local JSONL records with no content projection."""
-
-    def _write_session(self, agent_root, *, legacy=False, provider="anthropic",
-                       model="claude-test", result_error=False, reasoning_tokens=None):
-        directory = Path(agent_root) if legacy else (
-            Path(agent_root) / "sessions" / "--repo--"
-        )
-        directory.mkdir(parents=True)
-        path = directory / "pi-session.jsonl"
-        rows = [
-            {"type": "session", "version": 1, "id": "pi-session",
-             "timestamp": "2026-09-04T10:00:00Z", "cwd": "/repo"},
-            {"type": "model_change", "id": "model-change", "parentId": None,
-             "timestamp": "2026-09-04T10:00:01Z", "provider": provider,
-             "modelId": model},
-            {"type": "message", "id": "user", "parentId": "model-change",
-             "timestamp": "2026-09-04T10:00:02Z",
-             "message": {"role": "user", "content": []}},
-            {"type": "message", "id": "assistant", "parentId": "user",
-             "timestamp": "2026-09-04T10:00:05Z", "message": {
-                "role": "assistant", "model": model, "provider": provider,
-                 "content": [{"type": "toolCall", "id": "call", "name": "read",
-                              "arguments": {}}],
-                 "usage": {"input": 100, "output": 20, "cacheRead": 10,
-                           "cacheWrite": 5, "totalTokens": 135,
-                           "cost": {"input": 0.001, "output": 0.002,
-                                    "cacheRead": 0.0001, "cacheWrite": 0.0002}},
-             }},
-            {"type": "message", "id": "result", "parentId": "assistant",
-             "timestamp": "2026-09-04T10:00:06Z",
-             "message": {"role": "toolResult", "toolCallId": "call", "toolName": "read",
-                         **({"isError": True} if result_error else {})},
-             },
-        ]
-        if reasoning_tokens is not None:
-            rows[3]["message"]["usage"]["reasoning"] = reasoning_tokens
-        path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-        return path
-
-    def test_discovers_and_projects_pi_usage_as_a_local_cost_estimate(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                sources = meter.pi_session_sources()
-                state = meter.recompute(sources[0])
-                summary = meter.pi_summary(sources[0])
-
-        self.assertEqual(len(sources), 1)
-        self.assertEqual(sources[0]["provider"], "pi")
-        self.assertEqual(sources[0]["model"], "claude-test")
-        self.assertEqual(sources[0]["model_provider"], "anthropic")
-        self.assertEqual(sources[0]["project"], "/repo")
-        self.assertEqual(sources[0]["title"], "Pi session")
-        self.assertEqual(state["tokens"], {
-            "input": 100, "cache_write": 5, "cache_read": 10, "output": 20,
-        })
-        self.assertEqual(state["total_tokens"], 135)
-        self.assertAlmostEqual(state["total_cost"], 0.0033)
-        self.assertTrue(state["cost_approx"])
-        self.assertTrue(state["availability"]["cost"])
-        self.assertFalse(state["semantic_available"])
-        self.assertEqual(state["semantic"], {
-            "reasoning": 0, "output": 0, "retrieval": 0, "coordination": 0,
-        })
-        self.assertFalse(state["cache"]["savings_available"])
-        self.assertIsNone(state["cache"]["saved"])
-        self.assertIsNone(state["cache_saved"])
-        self.assertTrue(state["wait_time"]["available"])
-        self.assertEqual(state["executions"][0]["tools"][0]["name"], "read")
-        self.assertEqual(state["executions"][0]["context_tokens"], 115)
-        self.assertEqual(state["context"]["latest"], 115)
-        self.assertTrue(state["availability"]["context"])
-        self.assertTrue(state["availability"]["throughput"])
-        self.assertTrue(state["throughput"]["available"])
-        self.assertEqual(state["throughput"]["basis"], "end_to_end")
-        self.assertAlmostEqual(state["throughput"]["output_tps"], 20 / 3)
-        self.assertEqual(summary["context"]["latest"], 115)
-        self.assertEqual(summary["_context_samples"], [115])
-        self.assertTrue(summary["throughput"]["available"])
-        self.assertNotIn("arguments", json.dumps(state))
-
-    def test_redacts_pi_bedrock_application_profile_without_inferring_a_model(self):
-        raw_profile = (
-            "arn:aws:bedrock:us-west-2:123456789012:"
-            "application-inference-profile/private-profile"
-        )
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root, provider="amazon-bedrock", model=raw_profile)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                source = meter.pi_session_sources()[0]
-                state = meter.recompute(source)
-                summary = meter.pi_summary(source)
-
-        self.assertEqual(source["model"], "aws-bedrock-profile")
-        self.assertEqual(source["model_provider"], "amazon")
-        public = json.dumps({"source": source, "state": state, "summary": summary})
-        self.assertNotIn(raw_profile, public)
-        self.assertNotIn("123456789012", public)
-        self.assertTrue(state["cost_approx"])
-        self.assertTrue(summary["wait_time"]["available"])
-
-    def test_keeps_pi_cache_savings_unavailable_without_a_price_lookup(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                source = meter.pi_session_sources()[0]
-                with mock.patch.object(
-                    meter, "price_for",
-                    side_effect=AssertionError("Pi must not infer cache savings from pricing"),
-                ):
-                    state = meter.recompute(source)
-
-        self.assertFalse(state["cache"]["savings_available"])
-        self.assertIsNone(state["cache"]["saved"])
-
-    def test_discovers_legacy_pi_sessions_at_the_agent_root(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root, legacy=True)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}):
-                sources = meter.pi_session_sources()
-
-        self.assertEqual([source["id"] for source in sources], ["pi-session"])
-
-    def test_ignores_non_pi_jsonl_without_poisoning_discovery_cache(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            root.mkdir()
-            (root / "not-a-pi-session.jsonl").write_text("{}\n")
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}):
-                self.assertEqual(meter.pi_session_sources(), [])
-                self.assertEqual(meter.pi_session_sources(), [])
-
-    def test_records_pi_tool_result_errors_instead_of_successes(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root, result_error=True)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                source = meter.pi_session_sources()[0]
-                state = meter.recompute(source)
-                native = meter._pi_native_adapter().discover(None)[0]
-                session = meter._pi_native_adapter().load(native, meter.DetailLevel.FULL)
-
-        self.assertTrue(state["executions"][0]["tools"][0]["error"])
-        self.assertTrue(state["tools"]["total_errors"])
-        self.assertEqual(state["executions"][0]["tools"][0]["result_available"], True)
-        self.assertEqual(session.tools[0].status, "error")
-        self.assertEqual(
-            [event["severity"] for event in state["trace"] if event["kind"] == "tool_call"],
-            ["warn"],
-        )
-
-    def test_keeps_successful_pi_tool_results_as_successes(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                source = meter.pi_session_sources()[0]
-                state = meter.recompute(source)
-                native = meter._pi_native_adapter().discover(None)[0]
-                session = meter._pi_native_adapter().load(native, meter.DetailLevel.FULL)
-
-        self.assertFalse(state["executions"][0]["tools"][0]["error"])
-        self.assertFalse(state["tools"]["total_errors"])
-        self.assertEqual(session.tools[0].status, "success")
-
-    def test_projects_pi_reasoning_tokens_as_an_output_subset(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root, reasoning_tokens=12)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                source = meter.pi_session_sources()[0]
-                state = meter.recompute(source)
-
-        execution = state["executions"][0]
-        self.assertEqual(execution["reasoning_tokens"], 12)
-        self.assertEqual(state["series"][0]["reasoning"], 12)
-        self.assertTrue(state["series"][0]["think"])
-        # Reasoning is a reported subset of output, never an extra bucket.
-        self.assertEqual(state["total_tokens"], 135)
-        self.assertEqual(state["tokens"], {
-            "input": 100, "cache_write": 5, "cache_read": 10, "output": 20,
-        })
-
-    def test_clamps_pi_reasoning_tokens_to_reported_output(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_session(root, reasoning_tokens=999)
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                state = meter.recompute(meter.pi_session_sources()[0])
-
-        self.assertEqual(state["executions"][0]["reasoning_tokens"], 20)
-        self.assertTrue(state["series"][0]["think"])
-
-    def test_keeps_pi_context_and_pace_unavailable_without_usage(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            path = self._write_session(root)
-            rows = [json.loads(line) for line in path.read_text().splitlines()]
-            del rows[3]["message"]["usage"]
-            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                source = meter.pi_session_sources()[0]
-                state = meter.recompute(source)
-                summary = meter.pi_summary(source)
-
-        self.assertEqual(state["context"]["latest"], 0)
-        self.assertFalse(state["availability"]["context"])
-        self.assertFalse(state["throughput"]["available"])
-        self.assertFalse(state["availability"]["throughput"])
-        self.assertEqual(summary["context"]["latest"], 0)
-        self.assertFalse(summary["throughput"]["available"])
-
-    def test_keeps_cost_unavailable_when_a_pi_turn_lacks_its_local_estimate(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            path = self._write_session(root)
-            rows = [json.loads(line) for line in path.read_text().splitlines()]
-            del rows[3]["message"]["usage"]["cost"]
-            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-                state = meter.recompute(meter.pi_session_sources()[0])
-
-        self.assertFalse(state["availability"]["cost"])
-        self.assertEqual(state["total_cost"], 0)
-
-
-class PiSubagentTests(unittest.TestCase):
-    """Pi child runs live inside the parent transcript and must be accounted."""
-
-    CONTENT_CANARY = "PI-CONTENT-CANARY-7731"
-
-    @staticmethod
-    def _child_usage(input_tokens=1000, output_tokens=100, cache_read=0,
-                     cache_write=0, cost=0.25, turns=2, breakdown=False):
-        # The shipped subagent tool reports a scalar cost, so that is the
-        # default shape; breakdown=True is the documented Pi Usage object.
-        usage = {
-            "input": input_tokens,
-            "output": output_tokens,
-            "cacheRead": cache_read,
-            "cacheWrite": cache_write,
-            "cost": cost,
-            "contextTokens": input_tokens + cache_read + cache_write,
-            "turns": turns,
-        }
-        if breakdown:
-            usage["cost"] = {
-                "input": cost, "output": 0.0, "cacheRead": 0.0,
-                "cacheWrite": 0.0, "total": cost,
-            }
-        return usage
-
-    def _child_result(self, agent="probe", *, usage=None, exit_code=0,
-                      stop_reason="stop", model="opencode-go/deepseek-v4.1-flash",
-                      step=None):
-        result = {
-            "agent": agent,
-            "agentSource": "user",
-            "task": self.CONTENT_CANARY + "-task",
-            "exitCode": exit_code,
-            "messages": [{
-                "role": "assistant",
-                "content": [{"type": "text", "text": self.CONTENT_CANARY}],
-            }],
-            "stderr": self.CONTENT_CANARY + "-stderr",
-            "stopReason": stop_reason,
-            "model": model,
-        }
-        if usage is not None:
-            result["usage"] = usage
-        if step is not None:
-            result["step"] = step
-        return result
-
-    def _write_subagent_session(self, agent_root, *, results=None,
-                                top_usage=None, include_result=True,
-                                arguments=None, tool_name="subagent",
-                                mode="single", recent_seconds=None,
-                                stop_reason="stop", final_turn_usage=None):
-        directory = Path(agent_root) / "sessions" / "--repo--"
-        directory.mkdir(parents=True)
-        path = directory / "pi-subagent-session.jsonl"
-        if recent_seconds is None:
-            stamps = [
-                "2026-09-04T10:00:00Z", "2026-09-04T10:00:01Z",
-                "2026-09-04T10:00:02Z", "2026-09-04T10:00:05Z",
-                "2026-09-04T10:00:09Z", "2026-09-04T10:00:12Z",
-            ]
-        else:
-            base = (
-                datetime.datetime.now(datetime.timezone.utc)
-                - datetime.timedelta(seconds=recent_seconds)
-            )
-            stamps = [
-                (base + datetime.timedelta(seconds=offset)).isoformat()
-                .replace("+00:00", "Z")
-                for offset in (0, 1, 2, 5, 9, 12)
-            ]
-        tool_call = {
-            "type": "toolCall", "id": "call-subagent", "name": tool_name,
-            "arguments": arguments or {"agent": "probe", "task": self.CONTENT_CANARY},
-        }
-        assistant_message = {
-            "role": "assistant", "model": "claude-test", "provider": "anthropic",
-            "content": [tool_call],
-            "usage": {"input": 100, "output": 20, "cacheRead": 10,
-                      "cacheWrite": 5, "totalTokens": 135,
-                      "cost": {"input": 0.001, "output": 0.002,
-                               "cacheRead": 0.0001, "cacheWrite": 0.0002}},
-        }
-        if stop_reason is not None:
-            assistant_message["stopReason"] = stop_reason
-        rows = [
-            {"type": "session", "version": 3, "id": "pi-session",
-             "timestamp": stamps[0], "cwd": "/repo"},
-            {"type": "model_change", "id": "model-change", "parentId": None,
-             "timestamp": stamps[1], "provider": "anthropic",
-             "modelId": "claude-test"},
-            {"type": "message", "id": "user", "parentId": "model-change",
-             "timestamp": stamps[2],
-             "message": {"role": "user", "content": []}},
-            {"type": "message", "id": "assistant", "parentId": "user",
-             "timestamp": stamps[3], "message": assistant_message},
-        ]
-        if include_result:
-            message = {
-                "role": "toolResult", "toolCallId": "call-subagent",
-                "toolName": tool_name,
-                "content": [{"type": "text", "text": self.CONTENT_CANARY}],
-                "details": {
-                    "mode": mode, "agentScope": "user", "projectAgentsDir": None,
-                    "results": list(results if results is not None else []),
-                },
-            }
-            if top_usage is not None:
-                message["usage"] = top_usage
-            rows.append({
-                "type": "message", "id": "result", "parentId": "assistant",
-                "timestamp": stamps[4], "message": message,
-            })
-        if final_turn_usage is not None:
-            rows.append({
-                "type": "message", "id": "assistant-final",
-                "parentId": "result", "timestamp": stamps[5],
-                "message": {
-                    "role": "assistant", "model": "claude-test",
-                    "provider": "anthropic", "content": [],
-                    "stopReason": "stop", "usage": final_turn_usage,
-                },
-            })
-        path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-        return path
-
-    def _load(self, root):
-        with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                mock.patch.object(meter, "_pi_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            source = meter.pi_session_sources()[0]
-            return source, meter.recompute(source), meter.pi_summary(source)
-
-    def _records(self, summary):
-        return {record["kind"]: record for record in summary["_agent_records"]}
-
-    def test_single_child_run_adds_spend_and_emits_root_and_spawned_records(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=self._child_usage())],
-            )
-            source, state, summary = self._load(root)
-
-        # Parent turn 100/20/10/5 plus child 1000/100/0/0.
-        self.assertEqual(state["tokens"], {
-            "input": 1100, "output": 120, "cache_read": 10, "cache_write": 5,
-        })
-        self.assertEqual(state["total_tokens"], 1235)
-        self.assertAlmostEqual(state["total_cost"], 0.2533)
-        # Child work is not presented as a parent model call.
-        self.assertEqual(len(state["executions"]), 1)
-        self.assertEqual(summary["turns"], 1)
-
-        records = self._records(summary)
-        self.assertEqual(set(records), {"root", "spawned"})
-        root_record, child = records["root"], records["spawned"]
-        self.assertEqual(root_record["session_id"], source["id"])
-        self.assertEqual(root_record["tokens"], 135)
-        self.assertAlmostEqual(root_record["cost"], 0.0033)
-        self.assertTrue(root_record["tokens_available"])
-        self.assertEqual(child["parent_id"], root_record["id"])
-        self.assertEqual(child["depth"], 1)
-        self.assertEqual(child["role"], "probe")
-        self.assertEqual(child["model"], "opencode-go/deepseek-v4.1-flash")
-        self.assertEqual(child["tokens"], 1100)
-        self.assertAlmostEqual(child["cost"], 0.25)
-        self.assertTrue(child["tokens_available"])
-        self.assertTrue(child["cost_available"])
-        self.assertEqual(child["executions"], 2)
-        self.assertEqual(child["activity_state"], "complete")
-        self.assertEqual(child["started_at"], state["executions"][0]["ts"])
-        self.assertEqual(child["session_id"], None)
-        self.assertTrue(child["id"].startswith("pi-agent-"))
-        self.assertNotIn(source["id"], child["id"])
-        # Root plus child equals the session headline exactly.
-        self.assertEqual(
-            root_record["tokens"] + child["tokens"], state["total_tokens"],
-        )
-        self.assertAlmostEqual(
-            root_record["cost"] + child["cost"], state["total_cost"], places=9,
-        )
-
-    def test_shipped_extension_scalar_cost_shape_is_measured(self):
-        for reported in (0.0, 0.42):
-            with self.subTest(cost=reported), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                # Exact usage shape persisted by the shipped subagent example.
-                usage = {
-                    "input": 1461, "output": 27, "cacheRead": 0,
-                    "cacheWrite": 0, "cost": reported,
-                    "contextTokens": 1488, "turns": 1,
-                }
-                self._write_subagent_session(
-                    root, results=[self._child_result(usage=usage)],
-                )
-                _source, state, summary = self._load(root)
-
-                child = self._records(summary)["spawned"]
-                self.assertTrue(child["cost_available"])
-                self.assertEqual(child["cost"], reported)
-                self.assertTrue(state["availability"]["cost"])
-                self.assertAlmostEqual(
-                    state["total_cost"], 0.0033 + reported, places=6,
-                )
-
-    def test_reported_cost_breakdown_shape_is_still_supported(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, results=[
-                self._child_result(
-                    usage=self._child_usage(cost=0.25, breakdown=True),
-                ),
-            ])
-            _source, state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertTrue(child["cost_available"])
-        self.assertAlmostEqual(child["cost"], 0.25)
-        self.assertAlmostEqual(state["total_cost"], 0.2533)
-
-    def test_child_output_does_not_change_parent_pace_coverage(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=self._child_usage())],
-            )
-            _source, state, summary = self._load(root)
-
-        self.assertTrue(summary["throughput"]["available"])
-        self.assertAlmostEqual(
-            summary["throughput"]["timing_coverage"], 1.0,
-        )
-        self.assertAlmostEqual(summary["throughput"]["output_tps"], 20 / 3)
-        self.assertAlmostEqual(state["throughput"]["timing_coverage"], 1.0)
-
-    def test_parallel_child_results_each_emit_a_record_and_sum_once(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, mode="parallel", results=[
-                self._child_result("scout", usage=self._child_usage(600, 60, cost=0.1)),
-                self._child_result("reviewer", usage=self._child_usage(400, 40, cost=0.2)),
-            ])
-            _source, state, summary = self._load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertEqual(sorted(record["role"] for record in children),
-                         ["reviewer", "scout"])
-        self.assertEqual(sum(record["tokens"] for record in children), 1100)
-        self.assertAlmostEqual(sum(record["cost"] for record in children), 0.3)
-        self.assertEqual(state["total_tokens"], 1235)
-        self.assertAlmostEqual(state["total_cost"], 0.3033)
-        self.assertEqual(len({record["id"] for record in children}), 2)
-
-    def test_top_level_result_usage_without_details_emits_one_aggregate_run(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[], top_usage=self._child_usage(500, 50, cost=0.3),
-            )
-            _source, state, summary = self._load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertEqual(len(children), 1)
-        self.assertEqual(children[0]["role"], "probe")
-        self.assertEqual(children[0]["tokens"], 550)
-        self.assertAlmostEqual(children[0]["cost"], 0.3)
-        self.assertEqual(state["total_tokens"], 685)
-
-    def test_top_level_breakdown_usage_emits_aggregate_run(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[],
-                top_usage=self._child_usage(500, 50, cost=0.3, breakdown=True),
-            )
-            _source, state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertTrue(child["cost_available"])
-        self.assertAlmostEqual(child["cost"], 0.3)
-        self.assertEqual(state["total_tokens"], 685)
-
-    def test_reconciling_details_and_top_level_usage_count_spend_once(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, mode="parallel",
-                results=[
-                    self._child_result("scout", usage=self._child_usage(300, 30, cost=0.1)),
-                    self._child_result("worker", usage=self._child_usage(200, 20, cost=0.2)),
-                ],
-                top_usage=self._child_usage(500, 50, cost=0.3),
-            )
-            _source, state, summary = self._load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertEqual(sorted(record["role"] for record in children),
-                         ["scout", "worker"])
-        self.assertEqual(sum(record["tokens"] for record in children), 550)
-        self.assertEqual(state["total_tokens"], 685)
-        self.assertAlmostEqual(state["total_cost"], 0.3033)
-
-    def test_unreconciled_details_fall_back_to_one_aggregate_run(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, mode="parallel",
-                arguments={"tasks": [
-                    {"agent": "scout", "task": self.CONTENT_CANARY},
-                    {"agent": "worker", "task": self.CONTENT_CANARY},
-                ]},
-                results=[
-                    self._child_result("scout", usage=self._child_usage(300, 30, cost=0.1)),
-                    self._child_result("worker", usage=self._child_usage(200, 20, cost=0.2)),
-                ],
-                top_usage=self._child_usage(900, 90, cost=0.9),
-            )
-            _source, state, summary = self._load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertEqual(len(children), 1)
-        self.assertIsNone(children[0]["role"])
-        self.assertEqual(children[0]["tokens"], 990)
-        self.assertEqual(state["total_tokens"], 1125)
-        self.assertAlmostEqual(state["total_cost"], 0.9033)
-
-    def test_run_without_usage_reports_unavailable_not_zero(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, results=[self._child_result()])
-            _source, state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertFalse(child["tokens_available"])
-        self.assertFalse(child["cost_available"])
-        self.assertIsNone(child["tokens"])
-        self.assertIsNone(child["cost"])
-        self.assertFalse(summary["availability"]["cost"])
-        self.assertFalse(summary["availability"]["tokens"])
-        self.assertFalse(state["availability"]["cost"])
-        self.assertFalse(state["availability"]["tokens"])
-        self.assertEqual(state["total_tokens"], 135)
-
-    def test_failed_child_run_marks_incomplete_and_keeps_role(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, results=[
-                self._child_result("reviewer", usage=self._child_usage(cost=0.05),
-                                   exit_code=1, stop_reason="error"),
-            ])
-            _source, _state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertEqual(child["role"], "reviewer")
-        self.assertEqual(child["activity_state"], "incomplete")
-        self.assertEqual(child["failed_attempts"], 1)
-        self.assertIsNone(child["ended_at"])
-
-    def test_partial_failure_keeps_successful_sibling_complete(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            path = self._write_subagent_session(root, mode="parallel", results=[
-                self._child_result("scout", usage=self._child_usage(cost=0.1)),
-                self._child_result("worker", usage=self._child_usage(cost=0.0),
-                                   exit_code=1, stop_reason="error"),
-            ])
-            rows = [json.loads(line) for line in path.read_text().splitlines()]
-            rows[-1]["message"]["isError"] = True
-            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-            _source, _state, summary = self._load(root)
-
-        children = {
-            record["role"]: record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        }
-        self.assertEqual(children["scout"]["activity_state"], "complete")
-        self.assertEqual(children["worker"]["activity_state"], "incomplete")
-        self.assertEqual(children["worker"]["failed_attempts"], 1)
-
-    def test_zero_cost_child_is_a_measured_zero(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=self._child_usage(cost=0.0))],
-            )
-            _source, _state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertTrue(child["cost_available"])
-        self.assertEqual(child["cost"], 0.0)
-        self.assertTrue(summary["availability"]["cost"])
-
-    def test_unfinished_child_call_is_incomplete_without_invented_spend(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, include_result=False)
-            _source, state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertEqual(child["activity_state"], "incomplete")
-        self.assertEqual(child["failed_attempts"], 0)
-        self.assertFalse(child["tokens_available"])
-        self.assertFalse(child["cost_available"])
-        self.assertEqual(state["total_tokens"], 135)
-        self.assertEqual(state["total_cost"], 0.0033)
-
-    def test_fresh_unfinished_child_call_is_working(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, include_result=False, recent_seconds=10,
-            )
-            _source, _state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertEqual(child["activity_state"], "working")
-        self.assertEqual(child["failed_attempts"], 0)
-
-    def test_finished_session_root_reports_complete(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=self._child_usage())],
-            )
-            _source, _state, summary = self._load(root)
-
-        # Session-row liveness is intentionally unchanged for this PR.
-        self.assertFalse(summary["terminal"])
-        root_record = self._records(summary)["root"]
-        self.assertEqual(root_record["activity_state"], "complete")
-        self.assertEqual(
-            root_record["ended_at"], root_record["last_activity_at"],
-        )
-
-    def test_realistic_tool_use_then_stop_marks_root_complete(self):
-        final_usage = {
-            "input": 50, "output": 10, "cacheRead": 0, "cacheWrite": 0,
-            "totalTokens": 60,
-            "cost": {"input": 0.0005, "output": 0.0005,
-                     "cacheRead": 0.0, "cacheWrite": 0.0},
-        }
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, stop_reason="toolUse",
-                results=[self._child_result(usage=self._child_usage())],
-                final_turn_usage=final_usage,
-            )
-            _source, state, summary = self._load(root)
-
-        self.assertEqual(summary["turns"], 2)
-        self.assertEqual(
-            self._records(summary)["root"]["activity_state"], "complete",
-        )
-        self.assertAlmostEqual(state["total_cost"], 0.2543)
-
-    def test_nonterminal_session_root_stays_incomplete(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, stop_reason="toolUse",
-                results=[self._child_result(usage=self._child_usage())],
-            )
-            _source, _state, summary = self._load(root)
-
-        self.assertFalse(summary["terminal"])
-        root_record = self._records(summary)["root"]
-        self.assertEqual(root_record["activity_state"], "incomplete")
-        self.assertIsNone(root_record["ended_at"])
-
-    def test_empty_results_run_emits_no_agent_records(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, results=[])
-            _source, _state, summary = self._load(root)
-
-        self.assertNotIn("_agent_records", summary)
-
-    def test_child_role_rejects_paths_urls_credentials_and_prose(self):
-        bad_roles = [
-            "/Users/henry/agents/secret.md",
-            "https://example.test/agent",
-            "bearer abcdef",
-            "api_key=abcdef",
-            "a" * 80,
-            "two words here",
-            "scout\x00hidden",
-        ]
-        for bad in bad_roles:
-            with self.subTest(bad=bad), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                self._write_subagent_session(
-                    root, results=[self._child_result(bad, usage=self._child_usage())],
-                )
-                _source, state, summary = self._load(root)
-                child = self._records(summary)["spawned"]
-                self.assertIsNone(child["role"])
-                encoded = json.dumps({"summary": summary, "state": state})
-                self.assertNotIn(bad, encoded)
-
-    def test_child_model_rejects_credential_and_path_shapes(self):
-        for bad in ("sk-secret-value", "bearer abc", "/Users/henry/model",
-                    "https://example.test/model", "model with space",
-                    "probe?x=1", "models/llama-3.gguf",
-                    "Users/henry/.ssh/id_rsa", "a/../../etc/passwd",
-                    "example.com/secret", "localhost:8080/model",
-                    "home/henry/model", "C:/Users/henry/model",
-                    "example.com:8080/secret", "127.0.0.1:8000/model",
-                    "my-server.internal:8000/model", "10.0.0.5:9000/model"):
-            with self.subTest(model=bad), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                self._write_subagent_session(root, results=[
-                    self._child_result(
-                        usage=self._child_usage(), model=bad,
-                    ),
-                ])
-                _source, state, summary = self._load(root)
-
-                child = self._records(summary)["spawned"]
-                self.assertEqual(child["model"], "unknown-model")
-                encoded = json.dumps({"summary": summary, "state": state})
-                self.assertNotIn(bad, encoded)
-
-    def test_child_model_accepts_provider_prefixed_ids(self):
-        good_models = (
-            "@cf/meta/llama-3.1-8b-instruct",
-            "opencode-go/deepseek-v4.1-flash",
-            "anthropic/claude-opus-4-8",
-            "meta-llama/Llama-3.1-70B-Instruct",
-            "accounts/fireworks/models/llama-v3p1-70b-instruct",
-            "qwen2.5-coder:32b",
-            "amazon.nova-pro-v1:0",
-        )
-        for good in good_models:
-            with self.subTest(model=good), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                self._write_subagent_session(root, results=[
-                    self._child_result(usage=self._child_usage(), model=good),
-                ])
-                _source, _state, summary = self._load(root)
-
-                child = self._records(summary)["spawned"]
-                self.assertEqual(child["model"], good.lower())
-
-    def test_unreported_child_model_is_unknown_not_the_parent(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(root, results=[
-                self._child_result(usage=self._child_usage(), model=""),
-            ])
-            _source, state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertEqual(child["model"], "unknown-model")
-        self.assertEqual(summary["primary_model"], "claude-test")
-        self.assertEqual(summary["_model_cost"]["unknown-model"], 0.25)
-        self.assertAlmostEqual(summary["_model_cost"]["claude-test"], 0.0033)
-        mix = {row["model"]: row["cost"] for row in state["analyses"]["model_mix"]}
-        self.assertEqual(mix["unknown-model"], 0.25)
-        self.assertAlmostEqual(mix["claude-test"], 0.0033)
-
-    def test_child_content_never_reaches_summary_state_or_records(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=self._child_usage())],
-            )
-            _source, state, summary = self._load(root)
-
-        # The records must exist for this to be a meaningful negative check.
-        self.assertTrue(summary.get("_agent_records"))
-        encoded = json.dumps({"summary": summary, "state": state})
-        self.assertNotIn(self.CONTENT_CANARY, encoded)
-        self.assertNotIn("stderr", encoded)
-        self.assertNotIn("agentSource", encoded)
-        self.assertNotIn("messages", encoded)
-
-    def test_non_subagent_tool_usage_is_ignored(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, tool_name="summarize",
-                results=[self._child_result(usage=self._child_usage())],
-            )
-            _source, state, summary = self._load(root)
-
-        self.assertEqual(state["total_tokens"], 135)
-        self.assertNotIn("_agent_records", summary)
-        # A non-subagent Pi session keeps its pre-existing session liveness.
-        self.assertFalse(summary["terminal"])
-
-    def _write_many_calls(self, agent_root, call_results, *, extra_rows=()):
-        """Write one parent turn issuing N subagent calls with given results."""
-        directory = Path(agent_root) / "sessions" / "--repo--"
-        directory.mkdir(parents=True)
-        path = directory / "pi-subagent-many.jsonl"
-        calls = [
-            {"type": "toolCall", "id": "call-{}".format(index),
-             "name": "subagent", "arguments": {"agent": "probe"}}
-            for index in range(len(call_results))
-        ]
-        rows = [
-            {"type": "session", "version": 3, "id": "pi-session",
-             "timestamp": "2026-09-04T10:00:00Z", "cwd": "/repo"},
-            {"type": "message", "id": "user", "timestamp": "2026-09-04T10:00:01Z",
-             "message": {"role": "user", "content": []}},
-            {"type": "message", "id": "assistant",
-             "timestamp": "2026-09-04T10:00:02Z",
-             "message": {
-                 "role": "assistant", "model": "claude-test",
-                 "provider": "anthropic", "stopReason": "stop",
-                 "content": calls,
-                 "usage": {"input": 100, "output": 20, "cacheRead": 10,
-                           "cacheWrite": 5,
-                           "cost": {"input": 0.001, "output": 0.002,
-                                    "cacheRead": 0.0001, "cacheWrite": 0.0002}},
-             }},
-        ]
-        for index, results in enumerate(call_results):
-            rows.append({
-                "type": "message", "id": "result-{}".format(index),
-                "timestamp": "2026-09-04T10:00:05Z",
-                "message": {
-                    "role": "toolResult", "toolCallId": "call-{}".format(index),
-                    "toolName": "subagent",
-                    "details": {"mode": "single", "results": results},
-                },
-            })
-        rows.extend(extra_rows)
-        path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-        return path
-
-    def _native_load(self, root):
-        adapter = pi_runtime.PiRuntimeAdapter(root)
-        source = adapter.discover(DiscoveryContext(home="/home/test"))[0]
-        return adapter.load(source, meter.DetailLevel.SUMMARY)
-
-    def test_call_cap_marks_nested_spend_partial_not_complete(self):
-        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(root, [one_cent] * 600)
-            _source, state, summary = self._load(root)
-            loaded = self._native_load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertLessEqual(len(children), pi_runtime.MAX_SUBAGENT_RUNS)
-        for payload in (state, summary):
-            self.assertFalse(payload["availability"]["cost"])
-            self.assertFalse(payload["availability"]["tokens"])
-            self.assertFalse(payload["availability"]["cache"])
-        self.assertIsNone(loaded.usage.cost_usd.value)
-        self.assertIsNone(loaded.usage.input_tokens.value)
-        self.assertIsNone(loaded.usage.cache_read_tokens.value)
-        self.assertIn("history_truncated",
-                      [warning.code for warning in loaded.warnings])
-
-    def test_per_call_details_respect_the_run_cap(self):
-        single = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
-        wide = [
-            self._child_result(usage=self._child_usage(10, 1, cost=0.01))
-            for _ in range(pi_runtime.MAX_SUBAGENT_RUNS)
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(
-                root, [single] * (pi_runtime.MAX_SUBAGENT_RUNS - 1) + [wide],
-            )
-            _source, state, summary = self._load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertEqual(len(children), pi_runtime.MAX_SUBAGENT_RUNS)
-        self.assertFalse(summary["availability"]["cost"])
-        self.assertFalse(state["availability"]["cost"])
-
-    def test_calls_within_the_cap_stay_complete(self):
-        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(root, [one_cent] * 3)
-            _source, state, summary = self._load(root)
-
-        self.assertTrue(summary["availability"]["cost"])
-        self.assertTrue(state["availability"]["cost"])
-        self.assertAlmostEqual(state["total_cost"], 0.0333)
-
-    def test_nonempty_results_without_valid_entries_is_an_unavailable_run(self):
-        for results in (["not-a-dict"], [None, 7], [["nested"]]):
-            with self.subTest(results=results), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                self._write_subagent_session(root, results=results)
-                _source, state, summary = self._load(root)
-
-                children = [
-                    record for record in summary.get("_agent_records", [])
-                    if record["kind"] == "spawned"
-                ]
-                self.assertEqual(len(children), 1)
-                self.assertFalse(children[0]["tokens_available"])
-                self.assertFalse(children[0]["cost_available"])
-                self.assertFalse(summary["availability"]["cost"])
-                self.assertFalse(state["availability"]["cost"])
-
-    def test_non_list_results_without_usage_is_an_unavailable_run(self):
-        for results in ("not-a-list", {"agent": "probe"}, 7):
-            with self.subTest(results=results), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                # Written raw: details.results is the malformed value itself.
-                self._write_many_calls(root, [results])
-                _source, state, summary = self._load(root)
-
-                children = [
-                    record for record in summary.get("_agent_records", [])
-                    if record["kind"] == "spawned"
-                ]
-                self.assertEqual(len(children), 1)
-                self.assertFalse(children[0]["tokens_available"])
-                self.assertFalse(children[0]["cost_available"])
-                self.assertFalse(summary["availability"]["cost"])
-                self.assertFalse(state["availability"]["cost"])
-
-    def test_call_cap_surfaces_in_cross_session_agent_inventory(self):
-        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(root, [one_cent] * 600)
-            _source, _state, summary = self._load(root)
-            cross = self._cross(root)
-
-        self.assertTrue(summary["_agent_records_partial"])
-        self.assertNotIn("_agent_records_truncated", summary)
-        usage = cross["agent_usage"]
-        self.assertEqual(usage["totals"]["agents"], pi_runtime.MAX_SUBAGENT_RUNS)
-        self.assertFalse(usage["totals"]["cost_available"])
-        self.assertFalse(usage["totals"]["tokens_available"])
-        self.assertIsNone(usage["totals"]["cost"])
-        self.assertAlmostEqual(
-            usage["totals"]["known_cost"], 0.01 * pi_runtime.MAX_SUBAGENT_RUNS,
-        )
-        # The run cap is partial coverage, not the inventory display limit.
-        self.assertFalse(usage["inventory_truncated"])
-        for row in usage["roles"] + usage["models"]:
-            self.assertFalse(row["cost_available"], row["id"])
-            self.assertEqual(
-                row["cost_covered_agents"], row["agents"], row["id"],
-            )
-        public = json.dumps(cross, default=str)
-        self.assertNotIn("_agent_records_partial", public)
-        self.assertNotIn("_coverage_partial", public)
-
-    def test_per_call_result_cap_surfaces_in_cross_session_inventory(self):
-        wide = [
-            self._child_result(usage=self._child_usage(10, 1, cost=0.01))
-            for _ in range(pi_runtime.MAX_SUBAGENT_RUNS + 5)
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(root, [wide])
-            cross = self._cross(root)
-
-        usage = cross["agent_usage"]
-        self.assertFalse(usage["inventory_truncated"])
-        self.assertFalse(usage["totals"]["cost_available"])
-        self.assertIsNone(usage["totals"]["cost"])
-        self.assertGreater(usage["totals"]["known_cost"], 0)
-
-    def test_calls_within_the_cap_keep_cross_session_inventory_complete(self):
-        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(root, [one_cent] * 3)
-            _source, _state, summary = self._load(root)
-            cross = self._cross(root)
-
-        self.assertNotIn("_agent_records_truncated", summary)
-        self.assertNotIn("_agent_records_partial", summary)
-        usage = cross["agent_usage"]
-        self.assertEqual(usage["totals"]["agents"], 3)
-        self.assertTrue(usage["totals"]["cost_available"])
-        self.assertTrue(usage["totals"]["tokens_available"])
-        self.assertFalse(usage["inventory_truncated"])
-
-    def test_repeated_call_id_does_not_overwrite_finished_evidence(self):
-        repeat = {
-            "type": "message", "id": "assistant-repeat",
-            "timestamp": "2026-09-04T10:00:09Z",
-            "message": {
-                "role": "assistant", "model": "claude-test",
-                "provider": "anthropic", "stopReason": "stop",
-                "content": [{"type": "toolCall", "id": "call-0",
-                             "name": "subagent",
-                             "arguments": {"agent": "other"}}],
-                "usage": {"input": 1, "output": 1, "cacheRead": 0,
-                          "cacheWrite": 0,
-                          "cost": {"input": 0.0, "output": 0.0,
-                                   "cacheRead": 0.0, "cacheWrite": 0.0}},
-            },
-        }
-        result = [self._child_result(usage=self._child_usage(cost=0.25))]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_many_calls(root, [result], extra_rows=[repeat])
-            _source, state, summary = self._load(root)
-
-        children = [
-            record for record in summary["_agent_records"]
-            if record["kind"] == "spawned"
-        ]
-        self.assertEqual(len(children), 1)
-        self.assertEqual(children[0]["role"], "probe")
-        self.assertEqual(children[0]["activity_state"], "complete")
-        self.assertAlmostEqual(children[0]["cost"], 0.25)
-        self.assertTrue(state["availability"]["cost"])
-        self.assertAlmostEqual(state["total_cost"], 0.2533)
-
-    def test_child_without_cache_keys_is_not_a_complete_token_total(self):
-        usage = self._child_usage()
-        del usage["cacheRead"]
-        del usage["cacheWrite"]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=usage)],
-            )
-            _source, state, summary = self._load(root)
-
-        child = self._records(summary)["spawned"]
-        self.assertFalse(child["cache_available"])
-        self.assertFalse(child["tokens_available"])
-        self.assertIsNone(child["tokens"])
-        self.assertFalse(summary["availability"]["cache"])
-        self.assertFalse(state["availability"]["cache"])
-
-    def _cross(self, root):
-        saved = dict(meter._xsess)
-        try:
-            meter._xsess.update({"data": None, "at": 0, "agent_groups": ()})
-            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                    mock.patch.object(meter, "_pi_native_adapters", {}), \
-                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                return meter.cross_session(sources=meter.pi_session_sources())
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved)
-
-    def test_child_model_sanitizer_table(self):
-        accepted = (
-            "claude-opus-5-5", "anthropic/claude-sonnet-5-5", "openai/gpt-5.6",
-            "gpt-5.6-sol", "grok-4.7", "llama3.1:8b", "qwen2.5-coder:32b",
-            "amazon.nova-pro-v1:0", "claude-opus-4@20250514",
-            "@cf/meta/llama-3.1-8b-instruct",
-            "us.anthropic.claude-sonnet-4-20250514-v1:0",
-            "us.anthropic.claude-opus-5-5-v1:0",
-            "eu.anthropic.claude-sonnet-5-5-v1:0",
-            "meta.llama3-70b-instruct-v1:0", "claude-sonnet-4@20250514",
-            "model@latest", "model@v2.1.0", "model@1.2", "model@v1",
-            "@cf/meta/llama-3-8b", "accounts/fireworks/models/x",
-            "openrouter/anthropic/claude-opus-5-5", "gemini-2.5-pro",
-            "deepseek-r1:70b", "qwen2.5-coder:7b", "gpt-oss:20b",
-            "phi3:3.8b", "model:latest", "hf.co/unsloth/model",
-            "huggingface.co/org/model",
-            # Short vendor prefixes followed by an ordinary word stay names.
-            "xai-researcher", "hf_transformers",
-        )
-        rejected = (
-            "internal.corp.example.com:8443", "10.0.0.5:11434", "10.0.0.5",
-            "localhost:8080", "internal.corp.example.com",
-            "alice@corp.example.com", "user@host", "model@corp.example.com",
-            "sk-proj-abc123", "openai/sk-proj-abc123",
-            "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.c2lnbmF0dXJl",
-            "ghp_abcdefghijklmnop", "gho_abcdefghijklmnop",
-            "github_pat_11ABCDEFG", "xoxb-1234-5678-abcd", "xoxp-1234-5678",
-            "AKIAIOSFODNN7EXAMPLE", "vendor/AKIAIOSFODNN7EXAMPLE",
-            # Host, IP, or host:port in any path segment.
-            "ollama/10.0.0.5:11434", "provider/host.example.com:8443/m",
-            "hf.co/10.0.0.5:8080/model", "vendor/gateway:8080",
-            # Account or host after @ instead of a version.
-            "bob@10.0.0.5", "model@1.2.3.4", "a@1host.corp.com",
-            "ollama@192.168.1.4", "model@2.example.com",
-            # Single-label host with a port-shaped tag.
-            "myhost:11434", "gateway:8080",
-            # Additional vendor credential prefixes, any case.
-            "hf_AbCdEfGhIjKlMnOpQrStUvWx", "HF_AbCdEfGhIjKlMnOpQrStUvWx",
-            "xai-AbCdEfGhIjKlMnOpQrStUv", "AIzaSyA1234567890abcdefghij",
-            "glpat-abcdefgh", "GLPAT-abcdefgh", "npm_AbCdEfGhIjKlMnOpQrStUv",
-            "sk_live_abc123", "sk_test_abc123", "pk_live_abc123",
-            "rk_live_abc123", "akiaiosfodnn7example",
-            "vendor/glpat-abcdefgh",
-        )
-        for value in accepted:
-            self.assertEqual(pi_runtime._subagent_model_id(value), value)
-        for value in rejected:
-            self.assertEqual(pi_runtime._subagent_model_id(value), "", value)
-        for value in rejected:
-            with self.subTest(model=value), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                self._write_subagent_session(root, results=[
-                    self._child_result(usage=self._child_usage(), model=value),
-                ])
-                _source, state, summary = self._load(root)
-                cross = self._cross(root)
-
-                child = self._records(summary)["spawned"]
-                self.assertEqual(child["model"], "unknown-model")
-                encoded = json.dumps(
-                    {"summary": summary, "state": state, "cross": cross},
-                    default=str,
-                )
-                self.assertNotIn(value, encoded)
-                self.assertNotIn(value.lower(), encoded)
-
-    def test_child_role_rejects_secret_token_shapes(self):
-        accepted = (
-            "probe", "scout", "task-runner", "worker_2", "skeptic",
-            # Short prefixes need a 16+ character key-like run to count.
-            "xai-researcher", "hf_helper", "npm_runner", "aizawa",
-        )
-        rejected = (
-            "sk-abcdef", "my-sk-abcdef", "ghp_abcdef", "gho_abcdef",
-            "github_pat_11ABC", "xoxb-1234", "xoxp-1234",
-            "AKIAIOSFODNN7EXAMPLE", "akiaiosfodnn7example",
-            "hf_AbCdEfGhIjKlMnOpQr", "xai-AbCdEfGhIjKlMnOpQr",
-            "npm_AbCdEfGhIjKlMnOpQr", "AIzaSyA1234567890abcdef",
-            "glpat-abcdef", "sk_live_abc", "sk_test_abc", "pk_live_abc",
-            "rk_live_abc", "worker-glpat-x",
-        )
-        for value in accepted:
-            self.assertEqual(pi_runtime._safe_agent_role(value), value)
-        for value in rejected:
-            self.assertEqual(pi_runtime._safe_agent_role(value), "", value)
-        for value in rejected:
-            with self.subTest(role=value), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp) / "agent"
-                self._write_subagent_session(
-                    root, arguments={"agent": value},
-                    results=[self._child_result(value, usage=self._child_usage())],
-                )
-                _source, state, summary = self._load(root)
-                cross = self._cross(root)
-
-                self.assertIsNone(self._records(summary)["spawned"]["role"])
-                encoded = json.dumps(
-                    {"summary": summary, "state": state, "cross": cross},
-                    default=str,
-                )
-                self.assertNotIn(value, encoded)
-
-    def test_canonical_agent_sources_selects_pi_rows(self):
-        source = {
-            "id": "pi-session", "path": "/tmp/pi.jsonl", "provider": "pi",
-            "runtime": "Pi", "label": "Pi", "project": "/repo", "mtime": 1,
-        }
-        other = {
-            "id": "kiro-session", "path": "/tmp/kiro.json",
-            "provider": "kiro", "runtime": "Kiro", "label": "Kiro",
-            "project": "/repo", "mtime": 1,
-        }
-        selected = meter.canonical_agent_sources([source, other])
-        self.assertEqual(selected, [source])
-
-    def test_agent_group_and_inventory_include_pi_children(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp) / "agent"
-            self._write_subagent_session(
-                root, results=[self._child_result(usage=self._child_usage())],
-            )
-            _source, _state, summary = self._load(root)
-
-        groups = meter._domain_build_agent_groups([summary])
-        usage = meter._agent_usage_projection(
-            meter._domain_aggregate_agent_usage(groups)
-        )
-        self.assertEqual(len(groups), 1)
-        self.assertEqual(usage["totals"]["agents"], 1)
-        self.assertAlmostEqual(usage["totals"]["cost"], 0.25)
-        self.assertEqual(usage["inventory"][0]["role"], "probe")
-        self.assertEqual(usage["inventory"][0]["runtime"], "pi")
-        self.assertEqual(
-            usage["models"][0]["id"],
-            "opencode-go/deepseek-v4.1-flash::pi::spawned",
-        )
-
-
-class OpenCodeTests(unittest.TestCase):
-    """OpenCode is discovered from its read-only SQLite database."""
-
-    def test_reported_cost_rejects_unrepresentable_numbers(self):
-        for value in (10 ** 400, float("inf"), float("nan"), -1, True, "1"):
-            self.assertEqual(meter._opencode_reported_cost({"cost": value}), (0.0, False))
-        self.assertEqual(meter._opencode_reported_cost({"cost": 0}), (0.0, True))
-        self.assertEqual(meter._opencode_reported_cost({"cost": 1.25}), (1.25, True))
-
-    def _build_db(self, root):
-        db_path = Path(root) / "opencode.db"
-        conn = sqlite3.connect(db_path)
-        conn.execute("CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, parent_id TEXT, "
-                     "slug TEXT, directory TEXT, title TEXT, version TEXT, time_created INTEGER, "
-                     "time_updated INTEGER, time_archived INTEGER, agent TEXT, model TEXT, cost REAL, "
-                     "tokens_input INTEGER, tokens_output INTEGER, tokens_reasoning INTEGER, "
-                     "tokens_cache_read INTEGER, tokens_cache_write INTEGER)")
-        conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, time_created INTEGER, "
-                     "time_updated INTEGER, data TEXT)")
-        conn.execute("CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, "
-                     "time_created INTEGER, time_updated INTEGER, data TEXT)")
-        conn.execute("CREATE TABLE todo (id TEXT PRIMARY KEY, session_id TEXT)")
-        return conn
-
-    def _session_row(self, sid, directory, title, model, cost, inp, out, rea, cr, cw,
-                     updated, parent_id=None, archived=None, agent="build",
-                     provider_id="opencode-go"):
-        return {
-            "id": sid, "project_id": "proj", "parent_id": parent_id, "slug": sid,
-            "directory": directory, "title": title, "version": "1.18.14",
-            "time_created": updated - 1000, "time_updated": updated,
-            "time_archived": archived, "agent": agent,
-            "model": json.dumps({"id": model, "providerID": provider_id, "variant": "high"}),
-            "cost": cost, "tokens_input": inp, "tokens_output": out,
-            "tokens_reasoning": rea, "tokens_cache_read": cr, "tokens_cache_write": cw,
-        }
-
-    def _message(self, mid, sid, data, created):
-        return (mid, sid, created, created, json.dumps(data))
-
-    def _pricing_state(self, root, model, provider_id, cache_read=5000,
-                       prices=None, cost=0.0123, messages=True):
-        root = Path(root)
-        base = 1_784_548_900_000
-        conn = self._build_db(root)
-        row = self._session_row("ses_priced", "/repo", "Priced", model,
-                                cost, 1000, 200, 0, cache_read, 0,
-                                base, provider_id=provider_id)
-        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                     tuple(row.values()))
-        if messages:
-            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (
-                "msg_priced", "ses_priced", base, base + 500, json.dumps({
-                    "role": "assistant", "modelID": model, "providerID": provider_id,
-                    "time": {"created": base, "completed": base + 500},
-                    "tokens": {"input": 1000, "output": 200, "reasoning": 0,
-                               "cache": {"read": cache_read, "write": 0}},
-                    "cost": cost, "finish": "stop",
-                }),
-            ))
-        conn.commit()
-        conn.close()
-        settings = Path(root) / "settings.json"
-        settings.write_text(json.dumps({"model_pricing": prices or {}}))
-        with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(settings)), \
-                mock.patch.object(meter, "_opencode_native_adapters", {}):
-            source = meter.opencode_session_sources()[0]
-            return meter.recompute_opencode(source)
-
-    def test_anthropic_model_uses_anthropic_rates_for_cache_savings(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state = self._pricing_state(tmp, "claude-sonnet-4-6", "anthropic")
-
-        self.assertEqual(state["executions"][0]["model_provider"], "anthropic")
-        self.assertAlmostEqual(state["total_cost"], 0.0123)
-        self.assertFalse(state["cost_approx"])
-        self.assertTrue(state["cache"]["savings_available"])
-        self.assertAlmostEqual(state["cache"]["saved"], 0.0135)
-        self.assertAlmostEqual(state["cache_saved"], 0.0135)
-        self.assertGreater(state["cache"]["cost"], 0)
-
-    def test_cache_savings_use_session_provider_without_messages(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state = self._pricing_state(
-                tmp, "claude-sonnet-4-6", "anthropic", messages=False,
-            )
-
-        self.assertEqual(state["executions"], [])
-        self.assertTrue(state["cache"]["savings_available"])
-        self.assertAlmostEqual(state["cache"]["saved"], 0.0135)
-
-    def test_cost_unavailable_marks_cache_savings_unavailable(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state = self._pricing_state(
-                tmp, "claude-sonnet-4-6", "anthropic", cost=None,
-            )
-
-        self.assertFalse(state["availability"]["cost"])
-        self.assertFalse(state["cache"]["savings_available"])
-        self.assertIsNone(state["cache"]["saved"])
-
-    def test_openai_model_uses_openai_rates_for_cache_savings(self):
-        for model in ("gpt-6-astra", "openai/gpt-6-astra"):
-            with self.subTest(model=model), tempfile.TemporaryDirectory() as tmp:
-                state = self._pricing_state(tmp, model, "openai")
-
-            self.assertAlmostEqual(state["total_cost"], 0.0123)
-            self.assertTrue(state["cache"]["savings_available"])
-            self.assertAlmostEqual(state["cache"]["saved"], 0.045)
-
-    def test_cursor_model_uses_cursor_rates_for_cache_savings(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state = self._pricing_state(tmp, "claude-opus-5-5", "cursor")
-
-        self.assertAlmostEqual(state["total_cost"], 0.0123)
-        self.assertTrue(state["cache"]["savings_available"])
-        self.assertAlmostEqual(state["cache"]["saved"], 0.019)
-
-    def test_explicit_opencode_price_overrides_upstream_fallback(self):
-        prices = {"opencode": {"claude-sonnet-4-6": {
-            "input": 9.0, "output": 9.0, "cache_write": 9.0, "cache_read": 1.0,
-        }}}
-        with tempfile.TemporaryDirectory() as tmp:
-            state = self._pricing_state(
-                tmp, "claude-sonnet-4-6", "anthropic", prices=prices,
-            )
-
-        self.assertAlmostEqual(state["total_cost"], 0.0123)
-        self.assertTrue(state["cache"]["savings_available"])
-        self.assertAlmostEqual(state["cache"]["saved"], 0.04)
-
-    def test_unpriced_opencode_models_report_unavailable_cache_savings(self):
-        for model, provider_id in (
-            ("mystery-model-9", "unknown-provider"),
-            ("claude-opus-4-8", "opencode"),
-            ("claude-opus-4-8", "opencode-go"),
-            ("claude-opus-4-8", "openrouter"),
-            ("claude-opus-4-8", "amazon-bedrock"),
-        ):
-            with self.subTest(model=model, provider_id=provider_id), \
-                    tempfile.TemporaryDirectory() as tmp:
-                state = self._pricing_state(tmp, model, provider_id)
-
-            self.assertAlmostEqual(state["total_cost"], 0.0123)
-            self.assertIsNone(state["cache"]["saved"])
-            self.assertFalse(state["cache"]["savings_available"])
-            self.assertIsNone(state["cache_saved"])
-            self.assertNotIn(
-                "cache-saved", {row.get("key") for row in state["insights"]},
-            )
-
-    def test_discovery_labels_roots_and_child_sessions_and_filters_archived(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
-                                    0.5, 1000, 200, 50, 300, 0, 1_784_548_900_000)
-            child = self._session_row("ses_child", "/repo", "subagent work", "deepseek-v4-flash",
-                                      0.1, 100, 50, 0, 0, 0, 1_784_548_950_000, parent_id="ses_top")
-            archived = self._session_row("ses_arch", "/repo", "old", "deepseek-v4-pro",
-                                         0.2, 100, 50, 0, 0, 0, 1_784_548_980_000, archived=1_784_549_000_000)
-            for row in (top, child, archived):
-                conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                             (row["id"], row["project_id"], row["parent_id"], row["slug"],
-                              row["directory"], row["title"], row["version"], row["time_created"],
-                              row["time_updated"], row["time_archived"], row["agent"], row["model"],
-                              row["cost"], row["tokens_input"], row["tokens_output"],
-                              row["tokens_reasoning"], row["tokens_cache_read"], row["tokens_cache_write"]))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(db_path := root / "opencode.db")):
-                sources = meter.opencode_session_sources()
-        # Child sessions are discovered so their spend reaches totals, and only
-        # the archived session stays hidden.
-        self.assertEqual(
-            [row["id"] for row in sources], ["ses_child", "ses_top"],
-        )
-        by_id = {row["id"]: row for row in sources}
-        source = by_id["ses_top"]
-        self.assertEqual(source["provider"], "opencode")
-        self.assertEqual(source["label"], "OpenCode")
-        self.assertEqual(source["runtime"], "OpenCode")
-        self.assertEqual(source["model"], "deepseek-v4-pro")
-        self.assertEqual(source["project"], "/repo")
-        self.assertEqual(source["path"], "opencode:ses_top")
-        self.assertAlmostEqual(source["mtime"], 1_784_548_900.0)
-        self.assertEqual(source["signature_mtime"], source["mtime"])
-        self.assertEqual(meter.source_runtime_label(source), "OpenCode")
-
-        # A child records its private parent reference and role, and resolves its
-        # project from the parent root rather than its own agent column.
-        child_source = by_id["ses_child"]
-        self.assertEqual(child_source["agent_parent_id"], "ses_top")
-        self.assertEqual(child_source["agent_depth"], 1)
-        self.assertEqual(child_source["project"], "/repo")
-        self.assertEqual(child_source["path"], "opencode:ses_child")
-        self.assertNotIn("ses_arch", by_id)
-
-    def test_discovery_joins_all_session_sources(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
-                                    0.5, 1000, 200, 50, 300, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
-                          top["directory"], top["title"], top["version"], top["time_created"],
-                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
-                          top["cost"], top["tokens_input"], top["tokens_output"],
-                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
-                    mock.patch.object(meter, "CODEX_SESSIONS", str(root / "no-codex")), \
-                    mock.patch.object(meter, "CODEX_INDEX", str(root / "no-index")), \
-                    mock.patch.object(meter, "CURSOR_PROJECTS", str(root / "no-cursor")), \
-                    mock.patch.object(meter, "KIRO_SESSIONS", str(root / "no-kiro")), \
-                    mock.patch.object(meter, "KIRO_AGENT_STORAGE", str(root / "no-kiro-agent")), \
-                    mock.patch.object(meter, "PI_AGENT_DIR", str(root / "no-pi-agent")), \
-                    mock.patch.object(meter, "HERMES_STATE_DB", str(root / "no-hermes.db")), \
-                    mock.patch.object(meter, "AGY_BRAIN_DIR", str(root / "no-agy-brain")), \
-                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
-                    mock.patch.object(meter, "claude_desktop_index", return_value={}):
-                sources = meter.all_session_sources()
-        self.assertEqual([row["id"] for row in sources], ["ses_top"])
-        found = meter.find_session("ses_top", sources)
-        self.assertEqual(found["path"], "opencode:ses_top")
-
-    def test_discovery_signature_follows_message_and_part_updates(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            top = self._session_row("ses_top", "/repo", "Live", "model-a",
-                                    0, 0, 0, 0, 0, 0, base)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         tuple(top.values()))
-            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)",
-                         ("m1", "ses_top", base, base + 10_000,
-                          json.dumps({"role": "user"})))
-            conn.execute("INSERT INTO part VALUES (?,?,?,?,?,?)",
-                         ("p1", "m1", "ses_top", base, base + 20_000,
-                          json.dumps({"type": "text"})))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                source = meter.opencode_session_sources()[0]
-        self.assertEqual(source["mtime"], base / 1000)
-        self.assertEqual(source["signature_mtime"], (base + 20_000) / 1000)
-
-    def _insert_sessions(self, conn, rows):
-        for row in rows:
-            conn.execute(
-                "INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                (row["id"], row["project_id"], row["parent_id"], row["slug"],
-                 row["directory"], row["title"], row["version"], row["time_created"],
-                 row["time_updated"], row["time_archived"], row["agent"], row["model"],
-                 row["cost"], row["tokens_input"], row["tokens_output"],
-                 row["tokens_reasoning"], row["tokens_cache_read"],
-                 row["tokens_cache_write"]),
-            )
-
-    def _child_agent_row(self, source):
-        """Return the single spawned agent record a child session emits."""
-        meter._opencode_compatibility.cache_clear() \
-            if hasattr(meter._opencode_compatibility, "cache_clear") else None
-        row = meter.session_summary(source)
-        records = row.get("_agent_records") or []
-        self.assertEqual(len(records), 1, records)
-        return records[0]
-
-    def test_child_session_spend_is_additive_and_not_double_counted(self):
-        """Parent cost excludes child cost, so totals gain exactly the children."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            # The parent costs less than its children combined, matching the
-            # observed OpenCode shape where child spend is additive.
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       1.25, 1000, 200, 0, 0, 0, base)
-            child_a = self._session_row("ses_a", "/repo", "Child A", "model-a",
-                                        3.00, 100, 50, 0, 0, 0, base + 1000,
-                                        parent_id="ses_top", agent="gsd-planner")
-            child_b = self._session_row("ses_b", "/repo", "Child B", "model-b",
-                                        4.50, 200, 60, 0, 0, 0, base + 2000,
-                                        parent_id="ses_top", agent="explore")
-            self._insert_sessions(conn, (parent, child_a, child_b))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = meter.opencode_session_sources()
-                by_id = {row["id"]: row for row in sources}
-                meter._summary_cache.clear()
-                costs = {
-                    sid: meter.session_summary(row)["cost"]
-                    for sid, row in sorted(by_id.items())
-                }
-                rows = {sid: meter.session_summary(row) for sid, row in by_id.items()}
-                groups = meter._domain_build_agent_groups([
-                    rows[sid] for sid in sorted(rows)
-                ])
-                public = agent_usage_projection(
-                    meter._domain_aggregate_agent_usage(groups)
-                )
-
-        self.assertEqual(sorted(costs), ["ses_a", "ses_b", "ses_top"])
-        self.assertAlmostEqual(costs["ses_top"], 1.25)
-        self.assertAlmostEqual(costs["ses_a"], 3.00)
-        self.assertAlmostEqual(costs["ses_b"], 4.50)
-        # Additive, never folded into the parent headline.
-        self.assertAlmostEqual(sum(costs.values()), 8.75)
-        self.assertGreater(sum(costs.values()), costs["ses_top"])
-
-        # One group forms, and the subagent rollup counts children only.
-        self.assertEqual(len(groups), 1)
-        group = groups[0]
-        self.assertEqual(len(group["agents"]), 3)
-        self.assertAlmostEqual(group["totals"]["cost"], 8.75)
-        self.assertEqual(public["totals"]["agents"], 2)
-        self.assertAlmostEqual(public["totals"]["cost"], 7.50)
-        self.assertEqual(public["totals"]["parent_sessions"], 1)
-        # The parent's own work is never counted as subagent spend.
-        self.assertLess(
-            public["totals"]["cost"], group["totals"]["cost"],
-        )
-        roles = {row["role"] for row in public["roles"]}
-        self.assertIn("gsd-planner", roles)
-        self.assertIn("explore", roles)
-
-    def test_child_emits_one_spawned_record_with_opaque_identity(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            child = self._session_row("ses_child", "/repo", "Child", "model-a",
-                                      0.75, 300, 60, 0, 0, 0, base + 1000,
-                                      parent_id="ses_top", agent="gsd-executor")
-            self._insert_sessions(conn, (parent, child))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = {row["id"]: row for row in meter.opencode_session_sources()}
-                meter._summary_cache.clear()
-                record = self._child_agent_row(sources["ses_child"])
-
-        self.assertEqual(record["kind"], "spawned")
-        self.assertEqual(record["depth"], 1)
-        self.assertEqual(record["runtime"], "opencode")
-        self.assertEqual(record["role"], "gsd-executor")
-        self.assertTrue(record["id"].startswith("opencode-agent-"))
-        self.assertTrue(record["parent_id"].startswith("opencode-agent-"))
-        # Identity is a digest: neither the child nor the parent session id leaks.
-        self.assertNotIn("ses_child", record["id"])
-        self.assertNotIn("ses_top", record["parent_id"])
-        self.assertEqual(record["cost"], 0.75)
-        self.assertTrue(record["cost_available"])
-        self.assertEqual(record["input_tokens"], 300)
-        self.assertEqual(record["output_tokens"], 60)
-        self.assertEqual(record["tokens"], 360)
-
-    def test_agent_record_never_projects_private_identity_or_content(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/secret/workdir", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            child = self._session_row("ses_child", "/secret/workdir", "Child", "model-a",
-                                      0.75, 300, 60, 0, 0, 0, base + 1000,
-                                      parent_id="ses_top", agent="explore")
-            self._insert_sessions(conn, (parent, child))
-            conn.execute(
-                "INSERT INTO message VALUES (?,?,?,?,?)",
-                ("m1", "ses_child", base, base,
-                 json.dumps({"role": "user", "content": "private prompt text"})),
-            )
-            conn.execute(
-                "INSERT INTO part VALUES (?,?,?,?,?,?)",
-                ("p1", "m1", "ses_child", base, base,
-                 json.dumps({"type": "tool", "tool": "read", "input": "secret arg"})),
-            )
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = {row["id"]: row for row in meter.opencode_session_sources()}
-                meter._summary_cache.clear()
-                record = self._child_agent_row(sources["ses_child"])
-                row = meter.session_summary(sources["ses_child"])
-                public = agent_usage_projection(
-                    meter._domain_aggregate_agent_usage(
-                        meter._domain_build_agent_groups([row])
-                    )
-                )
-
-        serialized = json.dumps({"record": record, "public": public}, default=str)
-        for private in (
-            "/secret/workdir", "private prompt text", "secret arg", "workdir",
-        ):
-            self.assertNotIn(private, serialized)
-        # The agent and parent identities are opaque digests, never raw ids.
-        self.assertNotIn("ses_child", record["id"])
-        self.assertNotIn("ses_top", record["parent_id"])
-        # The established public session id stays, so the row is navigable.
-        self.assertEqual(record["session_id"], "ses_child")
-
-    def test_free_tier_child_reports_measured_zero_not_unavailable(self):
-        """A real free-tier price of zero is measured evidence, not a gap."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            free_model = json.dumps({"id": "space-bunny-free", "providerID": "opencode"})
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            child = self._session_row("ses_child", "/repo", "Child", "model-a",
-                                      0.0, 19084935, 0, 0, 0, 0, base + 1000,
-                                      parent_id="ses_top", agent="space-bunny-free")
-            child["model"] = free_model
-            self._insert_sessions(conn, (parent, child))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = {row["id"]: row for row in meter.opencode_session_sources()}
-                meter._summary_cache.clear()
-                record = self._child_agent_row(sources["ses_child"])
-
-        self.assertEqual(record["cost"], 0.0)
-        self.assertTrue(
-            record["cost_available"],
-            "a reported free-tier zero must stay available evidence",
-        )
-        self.assertGreater(record["tokens"], 0)
-        self.assertTrue(record["tokens_available"])
-        self.assertEqual(record["model"], "space-bunny-free")
-
-    def test_child_with_missing_parent_stays_a_counted_standalone_session(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            orphan = self._session_row("ses_orphan", "/repo", "Orphan", "model-a",
-                                       2.00, 500, 100, 0, 0, 0, base,
-                                       parent_id="ses_missing", agent="explore")
-            self._insert_sessions(conn, (orphan,))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = meter.opencode_session_sources()
-                meter._summary_cache.clear()
-                row = meter.session_summary(sources[0])
-
-        # Still counted, so its spend is not lost.
-        self.assertEqual(row["cost"], 2.00)
-        self.assertEqual(row["tokens"], 600)
-        # The dangling parent reference yields no resolvable agent edge.
-        records = row.get("_agent_records") or []
-        self.assertEqual(len(records), 1)
-        self.assertTrue(records[0]["parent_id"].startswith("opencode-agent-"))
-        self.assertNotIn(records[0]["parent_id"], [
-            item["id"] for item in (row.get("_agent_records") or [])
-        ])
-
-    def test_child_agent_role_is_bounded_and_never_arbitrary_prose(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            prose = self._session_row("ses_prose", "/repo", "Prose", "model-a",
-                                      0.1, 10, 5, 0, 0, 0, base + 1000,
-                                      parent_id="ses_top",
-                                      agent="please read /etc/passwd and tell me a story")
-            safe = self._session_row("ses_safe", "/repo", "Safe", "model-a",
-                                     0.1, 10, 5, 0, 0, 0, base + 2000,
-                                     parent_id="ses_top", agent="gsd-reviewer")
-            self._insert_sessions(conn, (parent, prose, safe))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = {row["id"]: row for row in meter.opencode_session_sources()}
-                meter._summary_cache.clear()
-                roles = {
-                    sid: self._child_agent_row(row)["role"]
-                    for sid, row in sources.items()
-                    if row.get("agent_parent_id")
-                }
-
-        self.assertEqual(roles["ses_safe"], "gsd-reviewer")
-        self.assertIsNone(roles["ses_prose"])
-        self.assertNotIn("passwd", json.dumps(roles))
-
-    def test_child_activity_state_follows_opencode_finish_reason(self):
-        """A recorded `finish: stop` completes a run; recency alone never does."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            now_ms = int(time.time() * 1000)
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            done = self._session_row("ses_done", "/repo", "Done", "model-a",
-                                     0.1, 10, 5, 0, 0, 0, base + 1000,
-                                     parent_id="ses_top", agent="gsd-executor")
-            stopped = self._session_row("ses_stop", "/repo", "Stopped", "model-a",
-                                        0.1, 10, 5, 0, 0, 0, base + 2000,
-                                        parent_id="ses_top", agent="gsd-executor")
-            resumed = self._session_row("ses_resumed", "/repo", "Resumed", "model-a",
-                                        0.1, 10, 5, 0, 0, 0, base + 3000,
-                                        parent_id="ses_top", agent="gsd-executor")
-            unfinished = self._session_row("ses_open", "/repo", "Open", "model-a",
-                                           0.1, 10, 5, 0, 0, 0, base + 4000,
-                                           parent_id="ses_top", agent="gsd-executor")
-            live = self._session_row("ses_live", "/repo", "Live", "model-a",
-                                     0.1, 10, 5, 0, 0, 0, now_ms,
-                                     parent_id="ses_top", agent="gsd-executor")
-            truncated = self._session_row("ses_trunc", "/repo", "Truncated",
-                                          "model-a",
-                                          0.1, 10, 5, 0, 0, 0, base + 5000,
-                                          parent_id="ses_top", agent="gsd-executor")
-            self._insert_sessions(
-                conn, (parent, done, stopped, resumed, unfinished, live, truncated),
-            )
-            for mid, sid, created, role, finish in (
-                ("done-u", "ses_done", base, "user", None),
-                ("done-a", "ses_done", base + 10, "assistant", "stop"),
-                ("stop-u", "ses_stop", base + 1000, "user", None),
-                ("stop-a", "ses_stop", base + 1010, "assistant", "tool-calls"),
-                ("resumed-u", "ses_resumed", base + 2000, "user", None),
-                ("resumed-a", "ses_resumed", base + 2010, "assistant", "stop"),
-                ("resumed-u2", "ses_resumed", base + 2020, "user", None),
-                ("open-u", "ses_open", base + 3000, "user", None),
-                ("open-a", "ses_open", base + 3010, "assistant", None),
-                ("live-u", "ses_live", now_ms - 1000, "user", None),
-                ("live-a", "ses_live", now_ms - 500, "assistant", "tool-calls"),
-                ("trunc-u", "ses_trunc", base + 4000, "user", None),
-                ("trunc-a", "ses_trunc", base + 4010, "assistant", "length"),
-            ):
-                data = {"role": role, "time": {"created": created}}
-                if finish is not None:
-                    data["finish"] = finish
-                conn.execute(
-                    "INSERT INTO message VALUES (?,?,?,?,?)",
-                    (mid, sid, created, created, json.dumps(data)),
-                )
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = {row["id"]: row for row in meter.opencode_session_sources()}
-                meter._summary_cache.clear()
-                states = {
-                    sid: self._child_agent_row(row)["activity_state"]
-                    for sid, row in sources.items()
-                    if row.get("agent_parent_id")
-                }
-
-        # `stop` is the only confirmed finish, and only when nothing resumes it.
-        self.assertEqual(states["ses_done"], "complete")
-        self.assertEqual(states["ses_resumed"], "incomplete")
-        # Mid-loop, missing, and length-truncated turns stay nonterminal.
-        self.assertEqual(states["ses_stop"], "incomplete")
-        self.assertEqual(states["ses_open"], "incomplete")
-        # A nonterminal run that is still active reads as working, not complete.
-        self.assertEqual(states["ses_live"], "working")
-        # A length-truncated turn is not a confirmed finish either.
-        self.assertEqual(states["ses_trunc"], "incomplete")
-
-    def test_child_sessions_reach_aggregate_totals_without_a_second_session(self):
-        """canonical_agent_sources selects each child once and keeps accounting."""
-        sources = [
-            {"provider": "opencode", "id": "ses_top", "path": "opencode:ses_top",
-             "mtime": 10.0, "signature_mtime": 10.0},
-            {"provider": "opencode", "id": "ses_child", "path": "opencode:ses_child",
-             "mtime": 20.0, "signature_mtime": 20.0,
-             "agent_parent_id": "ses_top", "agent_depth": 1},
-            {"provider": "claude", "id": "claude-1", "path": "/trace.jsonl",
-             "mtime": 5.0, "signature_mtime": 5.0},
-        ]
-        selected = meter.canonical_agent_sources(sources)
-
-        self.assertEqual(
-            sorted(row["id"] for row in selected),
-            ["claude-1", "ses_child", "ses_top"],
-        )
-        # Accounting sources are untouched by the agent selection.
-        self.assertEqual(
-            sorted(row["id"] for row in meter.canonical_aggregation_sources(sources)),
-            ["claude-1", "ses_child", "ses_top"],
-        )
-
-    def test_old_child_reports_incomplete_not_complete(self):
-        """A child with no terminal evidence is a stale nonterminal trace."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            # One hour old: past the working window, with no terminal evidence.
-            old_child = self._session_row("ses_old", "/repo", "Old child", "model-a",
-                                          0.1, 10, 5, 0, 0, 0, base - 3_600_000,
-                                          parent_id="ses_top", agent="explore")
-            self._insert_sessions(conn, (parent, old_child))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = {row["id"]: row for row in meter.opencode_session_sources()}
-                meter._summary_cache.clear()
-                record = self._child_agent_row(sources["ses_old"])
-
-        self.assertEqual(record["activity_state"], "incomplete")
-        self.assertNotEqual(record["activity_state"], "complete")
-        self.assertNotEqual(record["activity_state"], "recent")
-
-    def test_parent_with_only_archived_children_emits_no_root_record(self):
-        """A parent whose children are all archived has no live child group."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            archived_child = self._session_row(
-                "ses_arch", "/repo", "Archived child", "model-a",
-                0.1, 10, 5, 0, 0, 0, base + 1000,
-                parent_id="ses_top", agent="explore", archived=base + 2000,
-            )
-            self._insert_sessions(conn, (parent, archived_child))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                sources = meter.opencode_session_sources()
-                meter._summary_cache.clear()
-                rows = [meter.session_summary(s) for s in sources]
-
-        # The archived child is not discovered, so the parent has no live
-        # children and must not emit a root record for a group that cannot form.
-        self.assertEqual([row["id"] for row in rows], ["ses_top"])
-        self.assertFalse(rows[0].get("_agent_records"))
-
-    def _assistant(self, conn, mid, sid, cost, created, inp=10, out=5):
-        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (
-            mid, sid, created, created + 500, json.dumps({
-                "role": "assistant", "modelID": "model-a", "providerID": "opencode-go",
-                "time": {"created": created, "completed": created + 500},
-                "tokens": {"input": inp, "output": out, "reasoning": 0,
-                           "cache": {"read": 0, "write": 0}},
-                "cost": cost,
-            }),
-        ))
-
-    def _family_db(self, root, base, rows, messages=True):
-        """Insert sessions plus one assistant message carrying each row's cost."""
-        conn = self._build_db(root)
-        self._insert_sessions(conn, rows)
-        if messages:
-            for index, row in enumerate(rows):
-                self._assistant(conn, "m-" + row["id"], row["id"], row["cost"],
-                                base + index)
-        conn.commit()
-        conn.close()
-        return root / "opencode.db"
-
-    def _cross(self, db_path, sources=None):
-        saved = dict(meter._xsess)
-        try:
-            meter._xsess["data"], meter._xsess["at"] = None, 0
-            meter._summary_cache.clear()
-            with mock.patch.object(meter, "OPENCODE_DB", str(db_path)), \
-                    mock.patch.object(meter, "capability_inventory", return_value={}):
-                sources = meter.opencode_session_sources() if sources is None else sources
-                cross = meter.cross_session(sources=sources)
-                family_rows = list(meter._xsess.get("sessions") or [])
-            return sources, cross, family_rows
-        finally:
-            meter._xsess.clear()
-            meter._xsess.update(saved)
-            meter._summary_cache.clear()
-
-    def test_child_parent_id_stays_out_of_allowlisted_projections(self):
-        """Raw parent linkage never reaches sessions, /logs rows, or Subagents."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       0.5, 100, 20, 0, 0, 0, base)
-            child = self._session_row("ses_child", "/repo", "Child", "model-a",
-                                      0.75, 300, 60, 0, 0, 0, base + 1000,
-                                      parent_id="ses_top", agent="explore")
-            orphan = self._session_row("ses_orphan", "/repo", "Orphan", "model-a",
-                                       0.25, 30, 6, 0, 0, 0, base + 2000,
-                                       parent_id="ses_private_missing", agent="explore")
-            db_path = self._family_db(root, base, (parent, child, orphan))
-            _sources, cross, family_rows = self._cross(db_path)
-
-        by_id = {row["id"]: row for row in cross["sessions"]}
-        public = json.dumps({
-            "sessions": cross["sessions"], "family": family_rows,
-            "agent_usage": agent_usage_projection(cross["agent_usage"]),
-        }, default=str)
-        self.assertNotIn("child_parent_id", public)
-        # The unlisted parent reference of an orphan never leaves the server.
-        self.assertNotIn("ses_private_missing", public)
-        # Only the resolved, listed root id is published on a child row.
-        self.assertEqual(by_id["ses_child"]["root_session_id"], "ses_top")
-        self.assertTrue(by_id["ses_child"]["is_child_session"])
-        self.assertNotIn("root_session_id", by_id["ses_orphan"])
-        self.assertNotIn("root_session_id", by_id["ses_top"])
-
-    def test_archived_root_excludes_its_whole_family_from_totals(self):
-        """An archived root hides its children and grandchildren, as before."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            base = 1_784_548_900_000
-            rows = (
-                self._session_row("ses_arch", "/old", "Archived", "model-a",
-                                  1.00, 10, 5, 0, 0, 0, base, archived=base + 9000),
-                self._session_row("ses_arch_child", "/old", "Archived child", "model-a",
-                                  2.00, 10, 5, 0, 0, 0, base + 1000,
-                                  parent_id="ses_arch", agent="explore"),
-                self._session_row("ses_arch_grand", "/old", "Archived grandchild", "model-a",
-                                  4.00, 10, 5, 0, 0, 0, base + 2000,
-                                  parent_id="ses_arch_child", agent="explore"),
-                self._session_row("ses_live", "/repo", "Live", "model-a",
-                                  0.50, 10, 5, 0, 0, 0, base + 3000),
-                self._session_row("ses_live_child", "/repo", "Live child", "model-a",
-                                  0.25, 10, 5, 0, 0, 0, base + 4000,
-                                  parent_id="ses_live", agent="explore"),
-            )
-            db_path = self._family_db(root, base, rows)
-            sources, cross, _family = self._cross(db_path)
-
-        ids = sorted(row["id"] for row in sources)
-        self.assertEqual(ids, ["ses_live", "ses_live_child"])
-        self.assertAlmostEqual(cross["total_cost"], 0.75)
-        self.assertEqual(cross["total_sessions"], 2)
-        # Nothing is left looking like an unattributed child of an archived parent.
-        self.assertEqual(cross["agent_usage"]["totals"]["unresolved_agents"], 0)
-        self.assertNotIn("ses_arch", json.dumps(cross["sessions"]))
-
-    def test_missing_parent_is_the_only_unresolved_family(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            base = 1_784_548_900_000
-            rows = (
-                self._session_row("ses_live", "/repo", "Live", "model-a",
-                                  0.50, 10, 5, 0, 0, 0, base),
-                self._session_row("ses_orphan", "/repo", "Orphan", "model-a",
-                                  0.40, 10, 5, 0, 0, 0, base + 1000,
-                                  parent_id="ses_gone", agent="explore"),
-            )
-            db_path = self._family_db(root, base, rows)
-            _sources, cross, _family = self._cross(db_path)
-
-        self.assertAlmostEqual(cross["total_cost"], 0.90)
-        self.assertEqual(cross["agent_usage"]["totals"]["unresolved_agents"], 1)
-        self.assertAlmostEqual(
-            cross["agent_usage"]["totals"]["unresolved_known_cost"], 0.40,
-        )
-
-    def test_grandchild_resolves_root_project_depth_and_root_session(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            base = 1_784_548_900_000
-            rows = (
-                self._session_row("ses_root", "/repo/root", "Root", "model-a",
-                                  0.50, 10, 5, 0, 0, 0, base),
-                self._session_row("ses_mid", "/repo/mid", "Mid", "model-a",
-                                  0.25, 10, 5, 0, 0, 0, base + 1000,
-                                  parent_id="ses_root", agent="explore"),
-                self._session_row("ses_leaf", "/repo/leaf", "Leaf", "model-a",
-                                  0.125, 10, 5, 0, 0, 0, base + 2000,
-                                  parent_id="ses_mid", agent="gsd-reviewer"),
-            )
-            db_path = self._family_db(root, base, rows)
-            sources, cross, _family = self._cross(db_path)
-            with mock.patch.object(meter, "OPENCODE_DB", str(db_path)):
-                meter._summary_cache.clear()
-                by_source = {row["id"]: row for row in sources}
-                leaf_record = self._child_agent_row(by_source["ses_leaf"])
-                meter._summary_cache.clear()
-
-        by_source = {row["id"]: row for row in sources}
-        self.assertEqual(by_source["ses_leaf"]["project"], "/repo/root")
-        self.assertEqual(by_source["ses_mid"]["project"], "/repo/root")
-        self.assertEqual(by_source["ses_leaf"]["agent_depth"], 2)
-        self.assertEqual(by_source["ses_mid"]["agent_depth"], 1)
-        self.assertEqual(by_source["ses_leaf"]["agent_root_id"], "ses_root")
-        self.assertTrue(by_source["ses_mid"]["agent_has_children"])
-        self.assertEqual(leaf_record["depth"], 2)
-        sessions = {row["id"]: row for row in cross["sessions"]}
-        self.assertEqual(sessions["ses_leaf"]["root_session_id"], "ses_root")
-        self.assertEqual(sessions["ses_leaf"]["child_depth"], 2)
-        self.assertAlmostEqual(cross["total_cost"], 0.875)
-        self.assertEqual(cross["agent_usage"]["totals"]["unresolved_agents"], 0)
-        self.assertEqual(cross["agent_usage"]["totals"]["agents"], 2)
-
-    def test_parent_cost_excludes_children_so_headline_is_parent_plus_children(self):
-        """Pin the additive assumption against message-level parent evidence."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            base = 1_784_548_900_000
-            rows = (
-                self._session_row("ses_top", "/repo", "Root", "model-a",
-                                  1.25, 10, 5, 0, 0, 0, base),
-                self._session_row("ses_a", "/repo", "A", "model-a",
-                                  3.00, 10, 5, 0, 0, 0, base + 1000,
-                                  parent_id="ses_top", agent="explore"),
-            )
-            db_path = self._family_db(root, base, rows)
-            _sources, cross, family = self._cross(db_path)
-
-        costs = {row["id"]: row["cost"] for row in cross["sessions"]}
-        self.assertAlmostEqual(costs["ses_top"], 1.25)
-        self.assertAlmostEqual(cross["total_cost"], 4.25)
-        self.assertFalse(any("_cost_includes_children" in row for row in family))
-
-    def test_parent_cost_above_own_messages_is_kept_and_children_added(self):
-        """A parent reporting more than its own message sum is never reduced.
-
-        Reverted messages leave a parent's session cost above its remaining
-        message-level cost; that gap must not be read as included child spend.
-        """
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            base = 1_784_548_900_000
-            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
-                                       3.00, 10, 5, 0, 0, 0, base)
-            child = self._session_row("ses_a", "/repo", "A", "model-a",
-                                      0.50, 10, 5, 0, 0, 0, base + 1000,
-                                      parent_id="ses_top", agent="explore")
-            conn = self._build_db(root)
-            self._insert_sessions(conn, (parent, child))
-            self._assistant(conn, "m-top", "ses_top", 1.00, base)
-            self._assistant(conn, "m-a", "ses_a", 0.50, base + 1)
-            conn.commit()
-            conn.close()
-            _sources, cross, family = self._cross(root / "opencode.db")
-
-        costs = {row["id"]: row["cost"] for row in cross["sessions"]}
-        self.assertAlmostEqual(costs["ses_top"], 3.00)
-        self.assertAlmostEqual(costs["ses_a"], 0.50)
-        self.assertAlmostEqual(sum(row["cost"] for row in family), 3.50)
-
-    def test_live_child_runs_fold_into_one_current_root_session(self):
-        """Root + active child + grandchild form one current session and one cap."""
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            now_ms = int(time.time() * 1000)
-            # The root itself is idle; only its descendants are active.
-            rows = (
-                self._session_row("ses_root", "/repo", "Root", "model-a",
-                                  1.00, 10, 5, 0, 0, 0, now_ms - 40 * 60_000),
-                self._session_row("ses_child", "/repo", "Child", "model-a",
-                                  2.00, 20, 10, 0, 0, 0, now_ms - 30_000,
-                                  parent_id="ses_root", agent="explore"),
-                self._session_row("ses_grand", "/repo", "Grand", "model-a",
-                                  4.00, 40, 20, 0, 0, 0, now_ms - 20_000,
-                                  parent_id="ses_child", agent="explore"),
-            )
-            db_path = self._family_db(root, now_ms - 50 * 60_000, rows)
-            sources, cross, family = self._cross(db_path)
-
-        current = cross["current_sessions"]
-        self.assertEqual([row["id"] for row in current], ["ses_root"])
-        self.assertAlmostEqual(current[0]["cost"], 7.00)
-        self.assertEqual(current[0]["turns"], 3)
-        self.assertNotIn("subagent_runs", current[0])
-        self.assertFalse(current[0]["cost_partial"])
-        self.assertEqual(current[0]["activity_state"], "working")
-
-        # The native recent-session list offers the root, never a child run.
-        recent = meter.menubar_recent_sessions(sources, summaries=current)
-        self.assertEqual([row["id"] for row in recent], ["ses_root"])
-        # The watcher's live source is the root even though a child is newest.
-        self.assertEqual(meter.newest_current_source(sources)["id"], "ses_root")
-
-        # A child run has no separate cap: it reports the root's cap, and the
-        # root cap's spend includes every child run.
-        settings = meter.normalize_budget_settings({})
-        with mock.patch.dict(meter._xsess, {"sessions": family}):
-            root_snapshot = meter.session_budget_snapshot(
-                {"id": "ses_root"}, {"total_cost": 1.0, "availability": {"cost": True}},
-                settings,
-            )
-            child_snapshot = meter.session_budget_snapshot(
-                {"id": "ses_grand"}, {"total_cost": 4.0, "availability": {"cost": True}},
-                settings,
-            )
-        self.assertEqual(root_snapshot["id"], "ses_root")
-        self.assertAlmostEqual(root_snapshot["spend_usd"], 7.0)
-        self.assertNotIn("subagent_runs", root_snapshot)
-        self.assertFalse(root_snapshot["cost_partial"])
-        self.assertEqual(child_snapshot["id"], "ses_root")
-        self.assertAlmostEqual(child_snapshot["spend_usd"], 7.0)
-
-    def test_session_cap_spend_combines_family_cost_availability(self):
-        """Measured family spend is kept and any unavailable member is partial."""
-        def family(root_available, child_available):
-            return [
-                {"id": "ses_root", "provider": "opencode", "cost": 1.0,
-                 "availability": {"cost": root_available}},
-                {"id": "ses_child", "provider": "opencode", "cost": 2.5,
-                 "is_child_session": True, "root_session_id": "ses_root",
-                 "availability": {"cost": child_available}},
-            ]
-
-        settings = meter.normalize_budget_settings({})
-        with mock.patch.dict(meter._xsess, {"sessions": family(False, True)}):
-            unavailable_root = meter.session_budget_snapshot(
-                {"id": "ses_root"},
-                {"total_cost": 0.0, "availability": {"cost": False}},
-                settings,
-            )
-        self.assertAlmostEqual(unavailable_root["spend_usd"], 2.5)
-        self.assertTrue(unavailable_root["cost_available"])
-        self.assertTrue(unavailable_root["cost_partial"])
-
-        with mock.patch.dict(meter._xsess, {"sessions": family(True, False)}):
-            unavailable_child = meter.session_budget_snapshot(
-                {"id": "ses_root"},
-                {"total_cost": 1.0, "availability": {"cost": True}},
-                settings,
-            )
-        self.assertAlmostEqual(unavailable_child["spend_usd"], 1.0)
-        self.assertTrue(unavailable_child["cost_partial"])
-
-        with mock.patch.dict(meter._xsess, {"sessions": family(False, False)}):
-            unmeasured = meter.session_budget_snapshot(
-                {"id": "ses_root"},
-                {"total_cost": 0.0, "availability": {"cost": False}},
-                settings,
-            )
-        self.assertIsNone(unmeasured["spend_usd"])
-        self.assertFalse(unmeasured["cost_available"])
-        self.assertEqual(unmeasured["threshold_state"], "unavailable")
-
-        # A session with no child runs keeps its existing payload shape.
-        with mock.patch.dict(meter._xsess, {"sessions": []}):
-            solo = meter.session_budget_snapshot(
-                {"id": "ses_solo"},
-                {"total_cost": 1.0, "availability": {"cost": True}},
-                settings,
-            )
-        self.assertNotIn("cost_partial", solo)
-
-    def test_discovery_reuses_idle_database_inventory(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Idle", "model-a",
-                                    0, 0, 0, 0, 0, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         tuple(top.values()))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_native_adapters", {}):
-                first = meter.opencode_session_sources()
-                with mock.patch.object(
-                    meter.OpenCodeRuntimeAdapter, "connection",
-                    side_effect=AssertionError("unchanged database should use the inventory cache"),
-                ):
-                    second = meter.opencode_session_sources()
-        self.assertEqual(first, second)
-
-    def test_opencode_paths_and_model_catalog_are_xdg_aware_and_refreshable(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            models_path = root / "models.json"
-            with mock.patch.object(meter, "OPENCODE_DATA_ROOT", str(root / "data" / "opencode")), \
-                    mock.patch.object(meter, "OPENCODE_DB", "relative.db"):
-                self.assertEqual(
-                    meter.opencode_db_path(), str(root / "data" / "opencode" / "relative.db")
-                )
-            with mock.patch.object(meter, "OPENCODE_MODELS_PATH", str(models_path)), \
-                    mock.patch.object(meter, "_opencode_native_adapters", {}):
-                self.assertEqual(meter._load_opencode_models(), {})
-                models_path.write_text(json.dumps({
-                    "provider-a": {"models": {"shared": {"limit": {"context": 100}}}},
-                    "provider-b": {"models": {"shared": {"limit": {"context": 200}}}},
-                }))
-                self.assertEqual(meter._opencode_model_window("shared", "provider-a"), 100)
-                self.assertEqual(meter._opencode_model_window("shared", "provider-b"), 200)
-                self.assertIsNone(meter._opencode_model_window("shared"))
-                models_path.write_text(json.dumps({
-                    "provider-a": {"models": {"shared": {"limit": {"context": 300}}}},
-                }))
-                self.assertEqual(meter._opencode_model_window("shared", "provider-a"), 300)
-                self.assertEqual(meter._opencode_model_window("shared"), 300)
-
-    def _sample_messages(self):
-        base = 1_784_548_800_000
-        return [
-            self._message("msg1", "ses_top", {
-                "role": "assistant", "agent": "build", "modelID": "deepseek-v4-pro",
-                "providerID": "opencode-go",
-                "tokens": {"input": 1000, "output": 200, "reasoning": 50,
-                           "cache": {"write": 0, "read": 300}},
-                "cost": 0.01, "finish": "tool-calls",
-                "time": {"created": base, "completed": base + 5000},
-            }, base),
-            self._message("msg2", "ses_top", {
-                "role": "assistant", "agent": "build", "modelID": "deepseek-v4-pro",
-                "providerID": "opencode-go",
-                "tokens": {"input": 500, "output": 100, "reasoning": 0,
-                           "cache": {"write": 0, "read": 0}},
-                "cost": 0.005, "finish": "turn_complete",
-                "time": {"created": base + 60_000, "completed": base + 70_000},
-            }, base + 60_000),
-            self._message("msg3", "ses_top", {"role": "user", "text": "hi"}, base + 10_000),
-        ]
-
-    def test_recompute_opencode_reads_authoritative_tokens_and_cost(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
-                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
-                          top["directory"], top["title"], top["version"], top["time_created"],
-                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
-                          top["cost"], top["tokens_input"], top["tokens_output"],
-                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
-            for mid, sid, created, updated, data in self._sample_messages():
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
-            conn.execute("INSERT INTO part VALUES ('p0','msg3','ses_top',1,1,?)", (json.dumps({
-                "type": "text", "text": "  Follow   up  ",
-            }),))
-            conn.execute("INSERT INTO part VALUES ('p1','msg1','ses_top',1,1,?)", (json.dumps({
-                "type": "tool", "tool": "read", "callID": "call-1",
-                "state": {"status": "completed", "input": {"filePath": "/repo/a.py"},
-                          "output": "line one\nline two"},
-            }),))
-            conn.execute("INSERT INTO part VALUES ('p2','msg1','ses_top',1,1,?)", (json.dumps({
-                "type": "reasoning", "text": "think", "time": {"start": 1_784_548_800_100, "end": 1_784_548_800_900},
-            }),))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=200000):
-                state = meter.recompute_opencode({
-                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
-                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                    "path": "opencode:ses_top", "project": "/repo",
-                })
-        self.assertEqual(state["provider"], "opencode")
-        self.assertEqual(state["turns"], 2)
-        self.assertEqual(state["tokens"], {"input": 1500, "cache_write": 0, "cache_read": 300, "output": 300})
-        self.assertEqual(state["total_tokens"], 2150)
-        self.assertAlmostEqual(state["total_cost"], 0.015, places=6)
-        self.assertEqual(state["primary_model"], "deepseek-v4-pro")
-        self.assertTrue(state["availability"]["tokens"])
-        self.assertTrue(state["availability"]["cost"])
-        self.assertTrue(state["availability"]["context"])
-        self.assertTrue(state["timing"]["duration_available"])
-        self.assertEqual(state["timing"]["execution_count"], 2)
-        # Bucket split preserves the authoritative total.
-        self.assertAlmostEqual(sum(state["cost"][k] for k in ("input", "cache_write", "cache_read", "output")),
-                               state["total_cost"], places=6)
-        self.assertEqual(len(state["executions"]), 2)
-        self.assertEqual(state["executions"][0]["tool_count"], 1)
-        self.assertEqual(state["executions"][0]["tools"][0]["name"], "read")
-        self.assertGreater(state["executions"][0]["tools"][0]["output_tokens"], 0)
-        self.assertEqual(state["executions"][0]["reasoning_tokens"], 50)
-        self.assertEqual(state["executions"][0]["context_tokens"], 1550)
-        self.assertEqual(state["executions"][0]["duration_ms"], 5000)
-        self.assertEqual([row["user_message"] for row in state["series"]], ["", "Follow up"])
-        self.assertEqual([row["user_input"] for row in state["executions"]], ["", "Follow up"])
-        user_events = [event for event in state["trace"] if event["kind"] == "user"]
-        self.assertEqual([event["detail"] for event in user_events], ["Follow up"])
-        self.assertGreater(state["throughput"]["available"], False)
-
-    def test_recompute_dispatch_routes_opencode(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
-                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
-                          top["directory"], top["title"], top["version"], top["time_created"],
-                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
-                          top["cost"], top["tokens_input"], top["tokens_output"],
-                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
-            for mid, sid, created, updated, data in self._sample_messages():
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
-                    mock.patch.object(meter, "CODEX_SESSIONS", str(root / "no-codex")), \
-                    mock.patch.object(meter, "CODEX_INDEX", str(root / "no-index")), \
-                    mock.patch.object(meter, "CURSOR_PROJECTS", str(root / "no-cursor")), \
-                    mock.patch.object(meter, "claude_desktop_index", return_value={}):
-                state = meter.recompute({
-                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
-                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                    "path": "opencode:ses_top", "project": "/repo",
-                })
-        self.assertIsNotNone(state)
-        self.assertEqual(state["provider"], "opencode")
-
-    def test_recompute_handles_empty_and_zero_cost_sessions(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_900_000
-            top = self._session_row("ses_top", "/repo", "New session", "model-a",
-                                    0, 0, 0, 0, 0, 0, base)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         tuple(top.values()))
-            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (
-                "u1", "ses_top", base, base,
-                json.dumps({"role": "user", "time": {"created": base}}),
-            ))
-            conn.commit()
-            conn.close()
-            source = {
-                "provider": "opencode", "id": "ses_top", "model": "model-a",
-                "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                "path": "opencode:ses_top", "project": "/repo",
-            }
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
-                empty_state = meter.recompute_opencode(source)
-            self.assertEqual(empty_state["turns"], 0)
-            self.assertFalse(empty_state["timing"]["duration_available"])
-            self.assertTrue(empty_state["availability"]["cost"])
-
-            conn = sqlite3.connect(root / "opencode.db")
-            data = {
-                "role": "assistant", "modelID": "model-a", "providerID": "provider-a",
-                "tokens": {"input": 1, "output": 0, "reasoning": 1,
-                           "cache": {"read": 0, "write": 0}},
-                "cost": 0.0, "time": {"created": base + 1000, "completed": base + 2000},
-            }
-            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)",
-                         ("a1", "ses_top", base + 1000, base + 2000, json.dumps(data)))
-            conn.execute("UPDATE session SET tokens_input=1,tokens_reasoning=1,time_updated=? WHERE id=?",
-                         (base, "ses_top"))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
-                zero_state = meter.recompute_opencode(source)
-            self.assertTrue(zero_state["availability"]["cost"])
-            self.assertTrue(zero_state["executions"][0]["availability"]["cost"])
-            self.assertEqual(zero_state["total_cost"], 0)
-            self.assertEqual(zero_state["total_tokens"], 2)
-
-    def test_detail_history_reports_truncation(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Long", "deepseek-v4-pro",
-                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         tuple(top.values()))
-            for row in self._sample_messages():
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", row)
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "OPENCODE_DETAIL_MESSAGE_LIMIT", 1), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=200000):
-                state = meter.recompute_opencode({
-                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
-                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                    "path": "opencode:ses_top", "project": "/repo",
-                })
-        self.assertTrue(state["execution_history_truncated"])
-        self.assertEqual(state["execution_history_limit"], 1)
-        self.assertEqual(len(state["executions"]), 1)
-
-    def test_opencode_database_is_read_only_and_not_a_delete_target(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
-                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
-                          top["directory"], top["title"], top["version"], top["time_created"],
-                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
-                          top["cost"], top["tokens_input"], top["tokens_output"],
-                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
-            for mid, sid, created, updated, data in self._sample_messages():
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
-            conn.execute("INSERT INTO part VALUES ('p1','msg1','ses_top',1,1,'{}')")
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
-                conn = meter._opencode_db_connection()
-                with self.assertRaises(sqlite3.OperationalError):
-                    conn.execute("DELETE FROM session WHERE id='ses_top'")
-                self.assertEqual(conn.execute("SELECT COUNT(*) FROM message").fetchone()[0], 3)
-                conn.close()
-        self.assertFalse(hasattr(meter, "remove_opencode_session"))
-        self.assertIn("opencode", meter.session_action_capability()["read_only_providers"])
-
-    def test_opencode_summary_reports_latest_context_pct(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
-                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
-                          top["directory"], top["title"], top["version"], top["time_created"],
-                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
-                          top["cost"], top["tokens_input"], top["tokens_output"],
-                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
-            for mid, sid, created, updated, data in self._sample_messages():
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=200000):
-                row = meter.opencode_summary({
-                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
-                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                    "path": "opencode:ses_top", "project": "/repo", "title": "Explain it",
-                    "mtime": 1_784_548_900.0,
-                })
-        self.assertEqual(row["context"]["window"], 200000)
-        self.assertEqual(row["context"]["latest"], 600)
-        self.assertAlmostEqual(row["context"]["latest_pct"], 600 / 200000)
-        self.assertFalse(row["context"]["estimated"])
-        self.assertEqual(row["_context_samples"], [1550, 600])
-        self.assertTrue(row["availability"]["context"])
-
-    def test_opencode_summary_processes_only_newest_500_messages_in_order(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            base = 1_784_548_800_000
-            top = self._session_row(
-                "ses_top", "/repo", "Long history", "model-a",
-                5.01, 501, 501, 0, 0, 0, base + 501_000,
-            )
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         tuple(top.values()))
-            for index in range(501):
-                created = base + index * 1_000
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", self._message(
-                    f"a{index:04d}", "ses_top", {
-                        "role": "assistant", "modelID": "model-a",
-                        "providerID": "provider-a",
-                        "tokens": {"input": 1, "output": 1, "reasoning": 0,
-                                   "cache": {"read": 0, "write": 0}},
-                        "cost": 0.01,
-                        "time": {"created": created, "completed": created + 500},
-                    }, created,
-                ))
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=1_000):
-                row = meter.opencode_summary({
-                    "provider": "opencode", "id": "ses_top", "model": "model-a",
-                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                    "path": "opencode:ses_top", "project": "/repo",
-                    "mtime": (base + 501_000) / 1_000,
-                })
-
-        self.assertEqual(row["turns"], 500)
-        self.assertEqual(len(row["_performance_samples"]), 500)
-        self.assertEqual(row["_performance_samples"][0]["ts"], (base + 1_500) / 1_000)
-        self.assertEqual(row["_performance_samples"][-1]["ts"], (base + 500_500) / 1_000)
-        self.assertEqual(row["tokens"], 1_002)
-
-    def test_opencode_summary_attributes_models_and_calendar_days_per_message(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            # Naive local noon, because the adapter groups cost by local day
-            # (time.localtime). A UTC-built instant lands on the next day east
-            # of UTC, which would move the cost out of the asserted bucket.
-            jan = int(datetime.datetime(2026, 1, 31, 12).timestamp() * 1000)
-            feb = int(datetime.datetime(2026, 2, 1, 12).timestamp() * 1000)
-            top = self._session_row("ses_top", "/repo", "Across months", "model-b",
-                                    0.1, 30, 7, 5, 3, 2, feb + 1000)
-            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                         tuple(top.values()))
-            messages = [
-                self._message("a1", "ses_top", {
-                    "role": "assistant", "modelID": "model-a", "providerID": "provider-a",
-                    "tokens": {"input": 10, "output": 4, "reasoning": 2,
-                               "cache": {"read": 3, "write": 0}},
-                    "cost": 0.1, "time": {"created": jan, "completed": jan + 1000},
-                }, jan),
-                self._message("a2", "ses_top", {
-                    "role": "assistant", "modelID": "model-b", "providerID": "provider-b",
-                    "tokens": {"input": 20, "output": 3, "reasoning": 3,
-                               "cache": {"read": 0, "write": 2}},
-                    "cost": 0.0, "time": {"created": feb, "completed": feb + 1000},
-                }, feb),
-            ]
-            for row in messages:
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", row)
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
-                row = meter.opencode_summary({
-                    "provider": "opencode", "id": "ses_top", "model": "model-b",
-                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
-                    "path": "opencode:ses_top", "project": "/repo", "mtime": feb / 1000,
-                })
-        self.assertEqual(row["turns"], 2)
-        self.assertEqual(row["tokens"], 47)
-        self.assertEqual(row["_day_cost"], {"2026-01-31": 0.1, "2026-02-01": 0.0})
-        self.assertEqual(row["_model_tok"], {"model-a": 19, "model-b": 28})
-        self.assertEqual({item["model"]: item["executions"] for item in row["model_stats"]},
-                         {"model-a": 1, "model-b": 1})
-        model_b = next(item for item in row["model_stats"] if item["model"] == "model-b")
-        model_a = next(item for item in row["model_stats"] if item["model"] == "model-a")
-        self.assertTrue(model_b["availability"]["cost"])
-        self.assertEqual((model_a["cache_read_tokens"], model_a["cache_write_tokens"]),
-                         (3, 0))
-        self.assertEqual((model_a["reasoning_tokens"], model_a["reasoning_output_tokens"]),
-                         (2, 6))
-        self.assertEqual(model_a["reasoning_executions"], 1)
-        self.assertEqual((model_b["cache_read_tokens"], model_b["cache_write_tokens"]),
-                         (0, 2))
-        self.assertEqual((model_b["reasoning_tokens"], model_b["reasoning_output_tokens"]),
-                         (3, 6))
-        self.assertEqual(model_b["reasoning_executions"], 1)
-        self.assertEqual({item["day"] for item in row["_model_daily"]},
-                         {"2026-01-31", "2026-02-01"})
-
-    def test_opencode_efficiency_denominators_exclude_uncovered_messages(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            conn = self._build_db(root)
-            ts = int(datetime.datetime(
-                2026, 8, 27, 12, tzinfo=datetime.timezone.utc,
-            ).timestamp() * 1000)
-            top = self._session_row(
-                "ses_coverage", "/repo", "Mixed evidence", "model-a",
-                0.1, 110, 110, 0, 0, 0, ts + 4000,
-            )
-            conn.execute(
-                "INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                tuple(top.values()),
-            )
-            messages = [
-                self._message("a1", "ses_coverage", {
-                    "role": "assistant", "modelID": "model-a",
-                    "tokens": {"input": 10, "output": 10}, "cost": 0.1,
-                    "time": {"created": ts, "completed": ts + 1000},
-                }, ts),
-                self._message("a2", "ses_coverage", {
-                    "role": "assistant", "modelID": "model-a",
-                    "tokens": {"input": 100, "output": 100},
-                    "time": {"created": ts + 1000, "completed": ts + 2000},
-                }, ts + 1000),
-                self._message("a3", "ses_coverage", {
-                    "role": "assistant", "modelID": "model-a",
-                    "time": {"created": ts + 2000, "completed": ts + 3000},
-                }, ts + 2000),
-                self._message("a4", "ses_coverage", {
-                    "role": "assistant", "modelID": "model-a", "tokens": {},
-                    "time": {"created": ts + 3000, "completed": ts + 3500},
-                }, ts + 3000),
-                self._message("a5", "ses_coverage", {
-                    "role": "assistant", "modelID": "model-a",
-                    "tokens": {"input": "50", "output": "20"},
-                    "time": {"created": ts + 3500, "completed": ts + 4000},
-                }, ts + 3500),
-            ]
-            for message in messages:
-                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", message)
-            conn.commit()
-            conn.close()
-            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
-                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
-                session = meter.opencode_summary({
-                    "provider": "opencode", "id": "ses_coverage",
-                    "model": "model-a", "label": "OpenCode", "runtime": "OpenCode",
-                    "session": "ses_coverage", "path": "opencode:ses_coverage",
-                    "project": "/repo", "mtime": ts / 1000,
-                })
-
-        stats = session["model_stats"][0]
-        self.assertEqual(stats["executions"], 5)
-        self.assertEqual(stats["input_tokens"], 110)
-        self.assertEqual(stats["output_tokens"], 110)
-        self.assertEqual(stats["token_covered_executions"], 2)
-        self.assertEqual(stats["cache_covered_input_tokens"], 110)
-        self.assertEqual(stats["cost_covered_executions"], 1)
-        self.assertEqual(stats["cost_covered_output_tokens"], 10)
-        aggregate = meter.aggregate_model_stats([session])["models"][0]
-        self.assertEqual(aggregate["cost_covered_output_tokens"], 10)
-        self.assertEqual(aggregate["token_covered_executions"], 2)
-        self.assertFalse(aggregate["coverage"]["cost"]["complete"])
-        self.assertEqual(aggregate["daily"][0]["cost_covered_output_tokens"], 10)
-        self.assertEqual(aggregate["daily"][0]["token_covered_executions"], 2)
-        self.assertFalse(aggregate["daily"][0]["coverage"]["tokens"]["complete"])
-
-    def test_opencode_budget_defaults_and_distribute_cost(self):
-        with mock.patch.object(meter, "OPENCODE_DB", str(Path("/nonexistent/opencode.db"))):
-            settings = meter.normalize_budget_settings({"allocations": {}})
-        self.assertEqual(settings["allocations"]["opencode"], meter.DEFAULT_RUNTIME_BUDGET)
-        self.assertEqual(settings["allocations"]["kiro"], meter.DEFAULT_RUNTIME_BUDGET)
-        usage = {"input_tokens": 1000, "cache_creation_input_tokens": 0,
-                 "cache_read_input_tokens": 500, "output_tokens": 100, "reasoning_tokens": 50}
-        split = meter._opencode_distribute(0.02, usage)
-        self.assertAlmostEqual(sum(split.values()), 0.02, places=6)
-        self.assertEqual(meter._opencode_distribute(0.0, usage)["output"], 0.0)
-
-
-class OpenCodeSubagentDashboardContractTests(unittest.TestCase):
-    """The All sessions view keeps child runs out of the list but shows them."""
-
-    def setUp(self):
-        self.page = Path(DASHBOARD_PAGE).read_text(
-            encoding="utf-8"
-        )
-
-    def test_child_sessions_are_filtered_from_the_default_list(self):
-        self.assertIn("const view=allSessionsView(workRows,{showChildren:globalShowChildren", self.page)
-        self.assertIn("rows=(all||[]).filter(s=>!s.is_child_session&&", self.page)
-        self.assertIn("let globalShowChildren=localStorage.getItem('tm_global_children')", self.page)
-        self.assertIn("data-gchildren=hide", self.page)
-        self.assertIn("data-gchildren=show", self.page)
-        # The preference is a stored browser preference and is restored on load.
-        self.assertIn("paintGlobalChildren();", self.page)
-        # The control matches the g-sort segmented buttons: plain tab-reachable
-        # buttons with pressed state, not an ARIA radio group without arrow keys.
-        control = re.search(r'id=g-children[^>]*>(.*?)</div>', self.page, re.S).group(0)
-        self.assertNotIn("role=radio", control)
-        self.assertIn("type=button aria-pressed=true data-gchildren=hide", control)
-        self.assertIn("type=button aria-pressed=false data-gchildren=show", control)
-        self.assertNotIn("role=radiogroup", self.page)
-        self.assertIn("b.setAttribute('aria-pressed',on?'true':'false');", self.page)
-
-    def test_hidden_child_spend_is_still_reported_in_the_row_count_line(self):
-        # Filtering rows out of a list must not imply their spend was excluded.
-        self.assertIn("renderAllSessionStats(view.statsRows);", self.page)
-        self.assertIn("setLogText($('g-count'),allSessionsCountText(view));", self.page)
-        self.assertIn("counted, ${parentNote}", self.page)
-        self.assertIn("listed under parents", self.page)
-        self.assertIn("with no parent session", self.page)
-
-    def test_current_session_card_marks_partial_family_cost_as_lower_bound(self):
-        self.assertIn("const costPartial=costAvailable&&!!row.cost_partial;", self.page)
-        self.assertIn("costLabel=costPartial?'Cost, at least':'Cost'", self.page)
-        self.assertNotIn("(costPartial?'≥':'')", self.page)
-        self.assertIn(
-            "Cost is a lower bound: some runs in this session family have no cost evidence.",
-            self.page,
-        )
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_session_cap_display_and_alert_use_family_spend(self):
-        """An OpenCode family cap reports and alerts on root plus child spend."""
-        page_path = Path(DASHBOARD_PAGE)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const metricAvailable=(row,metric)=>row?.availability?.[metric]!==false,money=n=>'$'+Number(n).toFixed(2);
-const nodes={{}},el=id=>nodes[id]||(nodes[id]={{value:'',max:'',min:'0.5',textContent:'',style:{{setProperty(){{}}}}}});
-const $=el,defaultSessionBudget=10,SESSION_BUDGET_SLIDER_MIN=0.5,SESSION_BUDGET_SLIDER_BASE_MAX=50,formatBudgetInput=n=>String(n);
-let cap=10;const dollarInputValue=()=>cap;
-eval(extract('sessionCapSpend'));
-eval(extract('sessionBudgetSliderMax'));
-eval(extract('syncSessionBudgetControls'));
-eval(extract('sessionAlert'));
-const family=(partial,rootAvailable=true)=>({{provider:'opencode',source:{{id:'ses_root'}},total_cost:1,availability:{{cost:rootAvailable}},
- session_budget:{{id:'ses_root',budget_usd:10,spend_usd:10.5,cost_available:true,cost_partial:partial}}}});
-const out={{}};
-const complete=family(false);syncSessionBudgetControls(10,complete);
-out.familySpend=el('session-budget-spend').textContent;out.familyAlert=sessionAlert(complete);
-const partial=family(true,false);syncSessionBudgetControls(10,partial);
-out.partialSpend=el('session-budget-spend').textContent;out.partialAlert=sessionAlert(partial);
-const claude={{provider:'claude',source:{{id:'c1'}},total_cost:1,availability:{{cost:true}},
- session_budget:{{id:'c1',budget_usd:10,spend_usd:1,cost_available:true}}}};
-syncSessionBudgetControls(10,claude);out.claudeSpend=el('session-budget-spend').textContent;out.claudeAlert=sessionAlert(claude);
-const claudeOver={{...claude,total_cost:12,session_budget:undefined}};out.claudeOverAlert=sessionAlert(claudeOver);
-const unmeasured={{...claude,availability:{{cost:false}}}};syncSessionBudgetControls(10,unmeasured);
-out.unmeasuredSpend=el('session-budget-spend').textContent;out.unmeasuredAlert=sessionAlert(unmeasured);
-process.stdout.write(JSON.stringify(out));
-"""
-        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
-        self.assertEqual(completed.returncode, 0, completed.stderr)
-        out = json.loads(completed.stdout)
-        self.assertEqual(out["familySpend"], "Session spend $10.50")
-        self.assertEqual(out["familyAlert"]["type"], "budget")
-        self.assertEqual(out["familyAlert"]["current"], 10.5)
-        self.assertIn("now $10.50", out["familyAlert"]["msg"])
-        # A measured lower bound is still available and is labeled as such.
-        self.assertEqual(out["partialSpend"], "Session spend at least $10.50")
-        self.assertIn("now at least $10.50", out["partialAlert"]["msg"])
-        # Sessions without a folded family keep their own-cost behavior.
-        self.assertEqual(out["claudeSpend"], "Session spend $1.00")
-        self.assertEqual(out["claudeAlert"]["msg"], "")
-        self.assertIn("now $12.00", out["claudeOverAlert"]["msg"])
-        self.assertEqual(out["unmeasuredSpend"], "Session spend unavailable")
-        self.assertEqual(out["unmeasuredAlert"]["msg"], "")
-
-    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
-    def test_all_sessions_view_counts_children_and_respects_filters(self):
-        page_path = Path(DASHBOARD_PAGE)
-        script = f"""
-const fs=require('fs');
-const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
-function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
-const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'',metricAvailable=(row,key)=>row?.availability?.[key]!==false,hasLocalEstimate=()=>false;
-const f=n=>String(n),money=n=>'$'+Number(n).toFixed(2),countWord=(n,w)=>n===1?w:w+'s';
-eval(extract('childRootId'));eval(page.slice(page.indexOf('function allSessionsView('),page.indexOf('function allSessionsCountText(')));eval(extract('allSessionsCountText'));
-const all=[
- {{id:'root',provider:'opencode',project:'/a',title:'Root work',cost:1,mtime:100}},
- {{id:'mid',provider:'opencode',project:'/a',title:'Mid run',cost:2,mtime:200,is_child_session:true,root_session_id:'root',child_depth:1}},
- {{id:'leaf',provider:'opencode',project:'/a',title:'Needle leaf',cost:4,mtime:300,is_child_session:true,root_session_id:'root',child_depth:2}},
- {{id:'orphan',provider:'opencode',project:'/a',title:'Orphan',cost:8,mtime:300,is_child_session:true}},
- {{id:'other',provider:'claude',project:'/b',title:'Other',cost:16,mtime:400}},
-];
-const hidden=allSessionsView(all,{{}});
-const listed=allSessionsView(all,{{showChildren:true}});
-const project=allSessionsView(all,{{project:'/b'}});
-const search=allSessionsView(all,{{query:'needle'}});
-const spend=v=>v.statsRows.filter(r=>metricAvailable(r,'cost')).reduce((a,b)=>a+(b.cost||0),0);
-const filters={{search:{{query:'needle'}},time:{{rangeStart:250}},project:{{project:'/a'}},searchTime:{{query:'leaf',rangeStart:250}},none:{{}}}};
-const parity=Object.fromEntries(Object.entries(filters).map(([name,opts])=>{{
- const h=allSessionsView(all,opts),l=allSessionsView(all,{{...opts,showChildren:true}});
- return [name,{{hidden:spend(h),listed:spend(l),hiddenCovered:h.statsRows.length,listedCovered:l.statsRows.length}}];
-}}));
-const time=allSessionsView(all,{{rangeStart:250}});
-console.log(JSON.stringify({{
- parity,searchText:allSessionsCountText(search),listedText:allSessionsCountText(listed),
- time:{{rows:time.rows.map(r=>r.id),text:allSessionsCountText(time)}},
- hiddenRows:hidden.rows.map(r=>r.id),hiddenStatsCost:hidden.statsRows.reduce((a,b)=>a+b.cost,0),
- listedStatsCost:listed.statsRows.reduce((a,b)=>a+b.cost,0),listedRows:listed.rows.length,
- hidden:{{children:hidden.children,underParent:hidden.underParent,unparented:hidden.unparented,total:hidden.total}},
- hiddenText:allSessionsCountText(hidden),
- project:{{rows:project.rows.map(r=>r.id),children:project.children,text:allSessionsCountText(project)}},
- search:{{rows:search.rows.map(r=>r.id),children:search.children,underParent:search.underParent}},
-}}));
-"""
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        data = json.loads(result.stdout)
-        self.assertEqual(data["hiddenRows"], ["root", "other"])
-        # Header stats include hidden child spend, identical to Listed mode.
-        self.assertEqual(data["hiddenStatsCost"], 31)
-        self.assertEqual(data["listedStatsCost"], 31)
-        self.assertEqual(data["listedRows"], 5)
-        # The grandchild counts under its root card even though its parent is hidden.
-        self.assertEqual(data["hidden"], {"children": 3, "underParent": 2, "unparented": 1, "total": 2})
-        self.assertIn("2 of 2 sessions · $31.00 covered spend · 5 of 5 cost-covered", data["hiddenText"])
-        # Hidden and Listed header spend and coverage are equal under every filter,
-        # and a root surfaced only by a matching child adds none of its own cost.
-        for name, row in data["parity"].items():
-            self.assertEqual(row["hidden"], row["listed"], name)
-            self.assertEqual(row["hiddenCovered"], row["listedCovered"], name)
-        self.assertEqual(data["parity"]["search"]["hidden"], 4)
-        self.assertEqual(data["parity"]["time"]["hidden"], 28)
-        self.assertEqual(data["parity"]["searchTime"]["hidden"], 4)
-        self.assertIn("0 of 2 sessions · $4.00 covered spend · 1 of 1 cost-covered", data["searchText"])
-        self.assertIn("1 parent card shown for matching runs", data["searchText"])
-        self.assertIn("2 of 2 sessions + 3 subagent runs · $31.00 covered spend · 5 of 5 cost-covered", data["listedText"])
-        self.assertNotIn("parent card shown", data["listedText"])
-        self.assertEqual(data["time"]["rows"], ["root", "other"])
-        self.assertIn("1 of 2 sessions · $28.00 covered spend · 3 of 3 cost-covered", data["time"]["text"])
-        self.assertIn("3 subagent runs ($14.00) counted, 2 shown under parent cards · 1 with no parent session", data["hiddenText"])
-        # The hidden-children note respects the active project filter.
-        self.assertEqual(data["project"]["rows"], ["other"])
-        self.assertEqual(data["project"]["children"], 0)
-        self.assertNotIn("subagent", data["project"]["text"])
-        # Search in Hidden mode finds a child run by surfacing its root card.
-        self.assertEqual(data["search"], {"rows": ["root"], "children": 1, "underParent": 1})
-
-    def test_parent_card_renders_an_accessible_child_subsection(self):
-        self.assertIn("function childAgentSubsection(s)", self.page)
-        self.assertIn('class=subagents', self.page)
-        self.assertIn('class=subagentRow type=button data-open-session="${esc(sessionRowKey(child))}"', self.page)
-        # Children are real buttons with a complete accessible name, so depth
-        # and identity are never carried by indentation alone.
-        self.assertIn('aria-label="Open subagent run ${esc(title)}"', self.page)
-        # The role is provider-reported metadata, surfaced verbatim and bounded.
-        self.assertIn('class=subagentRole>${esc(child.child_agent_role)}<', self.page)
-        self.assertIn("Unreported role", self.page)
-
-    def test_child_rows_navigate_without_double_firing_the_parent(self):
-        self.assertIn("const childButton=event.target.closest('[data-open-session]');", self.page)
-        self.assertIn("event.stopPropagation();", self.page)
-        self.assertIn("selectSession(sessionRowKey(childRow))", self.page)
-
-    def test_measured_free_tier_zero_is_not_presented_as_unavailable(self):
-        # A real free-tier price renders as $0.0, distinct from missing billing.
-        self.assertIn("child.cost>0?costValueHtml", self.page)
-        self.assertIn("Measured free-tier price", self.page)
-        self.assertIn("cost unavailable", self.page)
-
-    def test_child_subsection_is_bounded_and_reports_the_hidden_count(self):
-        self.assertIn("const CHILD_SECTION_LIMIT=6;", self.page)
-        self.assertIn("const shown=children.slice(0,CHILD_SECTION_LIMIT);", self.page)
-        self.assertIn("more ${countWord(hidden,'run')} not shown", self.page)
-
-    def test_child_changes_invalidate_the_cached_parent_row(self):
-        self.assertIn("childAgentsFor(s).map(c=>[c.id,c.cost,c.tokens", self.page)
-        self.assertIn("function indexChildSessions(rows)", self.page)
-        # Every descendant is keyed by its published root id, never a raw parent id.
-        self.assertIn("const key=childRootId(row);", self.page)
-        self.assertNotIn("child_parent_id", self.page)
-
-    def test_subagents_page_discloses_unattributed_child_runs(self):
-        # A child run whose parent was never discovered is counted in totals but
-        # has no parent card, so the explorer must disclose the gap rather than
-        # let the rollup look complete.
-        self.assertIn('id=subagent-coverage-note', self.page)
-        self.assertIn("usage?.totals?.unresolved_agents", self.page)
-        self.assertIn("usage?.totals?.unresolved_known_cost", self.page)
-        self.assertIn("has':'have'} no parent session; left out of the rollups above.", self.page)
-        self.assertIn("counted in global totals", self.page)
-        # Archived families are excluded from discovery, so the only remaining
-        # cause is a missing parent record; the copy must not blame archiving.
-        self.assertNotIn("usually because the parent session was archived", self.page)
-        self.assertIn("parent session record is missing", self.page)
-        self.assertIn(".subagentCoverageNote[hidden]{display:none}", self.page)
-
-    def test_parent_row_with_children_uses_top_aligned_metrics(self):
-        # A parent with a tall child subsection must not center its own
-        # headline metrics beside the middle of that subsection.
-        self.assertIn(".srow.hasChildren{align-items:start}", self.page)
-        self.assertIn("const hasChildren=childAgentsFor(s).length>0;", self.page)
-        self.assertIn("${hasChildren?' hasChildren':''}", self.page)
-
-    def test_subagent_subsection_never_overflows_its_parent_at_laptop_width(self):
-        # Long role/model/time text must truncate inside the grid track rather
-        # than push the page wider at the 1024px laptop width.
-        self.assertIn(".subagentMain{min-width:0;overflow:hidden}", self.page)
-        self.assertIn(
-            ".subagentMain .meta{font-size:var(--fs-11);color:var(--faint);margin-top:2px;"
-            "display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;"
-            "min-width:0}",
-            self.page,
-        )
-
-
-class ToolUsageEvidenceRealityTests(unittest.TestCase):
-    """Tools-tab usage evidence must match what the raw traces contain."""
-
-    @staticmethod
-    def inventory(waste, *, codex_mcp=None, claude_mcp=None, skills=None):
-        with mock.patch.object(meter, "codex_mcp_states", return_value=codex_mcp or {}), \
-                mock.patch.object(meter, "claude_mcp_states", return_value=claude_mcp or {}), \
-                mock.patch.object(meter, "discovered_skills",
-                                  side_effect=lambda usage=None: [dict(row) for row in (skills or [])]), \
-                mock.patch.object(meter, "claude_desktop_index", return_value={}), \
-                mock.patch.object(meter, "claude_local_agent_sources", return_value=[]):
-            return meter.capability_inventory(waste)
-
-    @staticmethod
-    def codex_exec(code, call_id="exec-1"):
-        return {"timestamp": "2026-10-01T00:00:00.000Z", "payload": {
-            "type": "custom_tool_call", "name": "exec", "call_id": call_id, "input": code,
-        }}
-
-    def test_codex_exec_records_nested_mcp_and_app_tool_calls(self):
-        code = (
-            "const a = await tools.mcp__sharepoint__search({q: 'x'});\n"
-            "await tools.mcp__sharepoint__search({q: 'y'});\n"
-            "await tools.codex_app__load_workspace_dependencies({});\n"
-            "await tools.exec_command({cmd: 'ls'});\n"
-            "await tools.web__run({q: 'z'});\n"
-        )
-        calls = meter.codex_tool_call_evidence([self.codex_exec(code)])
-        nested = {row["name"]: row for row in calls if row.get("nested")}
-        self.assertEqual(
-            set(nested),
-            {"mcp__sharepoint__search", "mcp__codex_app__load_workspace_dependencies"},
-        )
-        self.assertEqual(nested["mcp__sharepoint__search"]["kind"], "mcp")
-        self.assertEqual(nested["mcp__sharepoint__search"]["namespace"], "sharepoint")
-        evidence = meter.summarize_tool_evidence(calls)
-        rows = {row["name"]: row for row in evidence["tools"]}
-        self.assertEqual(rows["mcp__sharepoint__search"]["calls"], 2)
-        self.assertEqual(rows["exec"]["calls"], 1)
-        self.assertEqual(evidence["total_calls"], 1)
-
-    def test_codex_app_namespace_keeps_one_canonical_identity(self):
-        from token_meter.runtimes.codex import codex_mcp_tool_name
-        self.assertEqual(
-            codex_mcp_tool_name("read_thread", "codex_app"), "mcp__codex_app__read_thread",
-        )
-        self.assertEqual(
-            codex_mcp_tool_name("read_thread", "mcp__codex_app"), "mcp__codex_app__read_thread",
-        )
-        for builtin in ("collaboration", "clock", "web", "multi_agent_v1"):
-            self.assertEqual(codex_mcp_tool_name("wait_agent", builtin), "wait_agent")
-
-    def test_codex_dynamic_catalog_matches_code_mode_calls(self):
-        from token_meter.runtimes.codex import _catalog
-        catalog = _catalog([
-            {"name": "codex_app", "tools": [
-                {"name": "wait_threads", "description": "wait"},
-                {"name": "share_thread", "description": "share"},
-            ]},
-            {"name": "exec_command", "description": "flat"},
-        ])
-        names = {row["name"]: row for row in catalog}
-        normalized = meter.normalize_dynamic_tools([
-            {"name": "codex_app", "tools": [{"name": "wait_threads"}]},
-            {"name": "exec_command"},
-        ])
-        self.assertEqual(
-            [(row["name"], row["kind"]) for row in normalized],
-            [("mcp__codex_app__wait_threads", "mcp"), ("exec_command", "tool")],
-        )
-        self.assertIn("mcp__codex_app__wait_threads", names)
-        self.assertEqual(names["mcp__codex_app__wait_threads"]["kind"], "mcp")
-        self.assertEqual(names["mcp__codex_app__wait_threads"]["namespace"], "codex_app")
-        self.assertIn("exec_command", names)
-        calls = meter.codex_tool_call_evidence([
-            self.codex_exec("await tools.mcp__codex_app__wait_threads({});"),
-        ])
-        evidence = meter.summarize_tool_evidence(calls, catalog)
-        share = names["mcp__codex_app__share_thread"]["definition_tokens"]
-        flat = names["exec_command"]["definition_tokens"]
-        self.assertEqual(evidence["unused_eager_definition_tokens"], share + flat)
-
-    def test_duplicated_claude_transcript_copies_count_each_tool_once(self):
-        def assistant(block_id, name="mcp__workspace__bash"):
-            return {
-                "type": "assistant", "timestamp": "2026-10-01T00:00:00Z",
-                "message": {"id": "msg-1", "usage": {"output_tokens": 5}, "content": [
-                    {"type": "tool_use", "id": block_id, "name": name, "input": {}},
-                ]},
-            }
-        objs = [assistant("tool-1"), assistant("tool-1"), assistant("tool-2")]
-        calls = meter.claude_tool_call_evidence(objs)
-        self.assertEqual(len(calls), 2)
-
-    def test_claude_tool_rows_keep_their_own_runtime(self):
-        call = {**meter.tool_identity("Bash"), "output_tokens": 1, "ts": 100,
-                "args_fingerprint": "x", "error": False}
-        rows = [
-            {"id": "a", "provider": "claude", "runtime": "Claude-3P", "project": "/r",
-             "_tool_evidence": meter.summarize_tool_evidence([call])},
-            {"id": "b", "provider": "claude", "runtime": "Claude Code", "project": "/r",
-             "_tool_evidence": meter.summarize_tool_evidence([call, call])},
-        ]
-        waste = meter.global_tool_waste(rows)
-        bash = {row["runtime"]: row["calls"] for row in waste["inventory_tools"]
-                if row["name"] == "Bash"}
-        self.assertEqual(bash, {"Claude-3P": 1, "Claude Code": 2})
-
-    def test_desktop_code_tab_sessions_cover_claude_plugin_packs(self):
-        skill = {
-            "id": "skill:claude:custom@personal:custom", "name": "custom",
-            "runtime": "Claude", "source": "User-installed plugin",
-            "plugin_id": "custom@personal", "mutable": True, "enabled": True,
-            "used": False, "reviewable": True, "measurement": "measurable",
-            "unmeasurable": False, "activations": 0, "last_used": "Never",
-            "setting_path": "~/.claude/settings.json",
-        }
-        code_tab = os.path.join(meter.CLAUDE_PROJECTS, "-repo", "session.jsonl")
-        cowork = "/tmp/Claude-3p/local-agent-mode-sessions/x/.claude/projects/s/a.jsonl"
-        waste = meter.global_tool_waste([
-            {"id": "tab", "provider": "claude", "runtime": "Claude-3P",
-             "path": code_tab, "project": "/r", "_tool_evidence": {}},
-            {"id": "cli", "provider": "claude", "runtime": "Claude Code",
-             "path": code_tab.replace("session", "cli"), "project": "/r", "_tool_evidence": {}},
-            {"id": "cowork", "provider": "claude", "runtime": "Claude-3P",
-             "path": cowork, "project": "/r", "_tool_evidence": {}},
-        ])
-        capabilities = self.inventory(waste, skills=[skill])
-        self.assertEqual(capabilities["control_groups"][0]["scanned_sessions"], 2)
-
-    def test_skill_activations_stay_with_the_runtime_that_used_them(self):
-        evidence = meter.summarize_tool_evidence([{
-            **meter.tool_identity("exec"), "output_tokens": 0, "ts": 100,
-            "args_fingerprint": "x", "error": False, "skills": ["brainstorming"],
-        }])
-        cowork = "/tmp/Claude-3p/local-agent-mode-sessions/x/.claude/projects/s/a.jsonl"
-        waste = meter.global_tool_waste([
-            {"id": "codex", "provider": "codex", "runtime": "Codex", "project": "/r",
-             "path": "/tmp/codex.jsonl", "_tool_evidence": evidence},
-            {"id": "cowork", "provider": "claude", "runtime": "Claude-3P", "project": "/r",
-             "path": cowork, "_tool_evidence": evidence},
-        ])
-        rows = [
-            {"name": "brainstorming", "runtime": "Codex", "measurement": "measurable"},
-            {"name": "brainstorming", "runtime": "Claude", "measurement": "measurable"},
-            {"name": "brainstorming", "runtime": "Claude Desktop", "measurement": "measurable"},
-        ]
-        meter.invalidate_discovered_skill_cache()
-        try:
-            with mock.patch.object(meter, "_scan_discovered_skills", return_value=rows):
-                skills = meter.discovered_skills(waste["skills"])
-        finally:
-            meter.invalidate_discovered_skill_cache()
-        used = {row["runtime"]: row["activations"] for row in skills}
-        self.assertEqual(used, {"Codex": 1, "Claude": 0, "Claude Desktop": 1})
-
-    def test_skill_usage_is_not_truncated_and_rejects_template_names(self):
-        self.assertEqual(
-            meter.skill_names_from_value(
-                "cat skills/${n}/SKILL.md skills/{name}/SKILL.md "
-                "skills/token-meter-*/SKILL.md skills/docx/SKILL.md"
-            ),
-            ["docx"],
-        )
-        calls = [{**meter.tool_identity("exec"), "output_tokens": 0, "ts": 100,
-                  "args_fingerprint": str(index), "error": False,
-                  "skills": [f"skill-{index:03d}"]} for index in range(120)]
-        waste = meter.global_tool_waste([{
-            "id": "codex", "provider": "codex", "runtime": "Codex", "project": "/r",
-            "_tool_evidence": meter.summarize_tool_evidence(calls),
-        }])
-        self.assertEqual(len(waste["skills"]), 120)
-
-    def test_mcp_without_configuration_is_not_reported_disabled(self):
-        waste = {"inventory_tools": [{
-            "id": "mcp__workspace__bash", "name": "mcp__workspace__bash",
-            "display": "bash", "kind": "mcp", "namespace": "workspace",
-            "mcp_server": "workspace", "runtime": "Claude-3P", "providers": ["claude"],
-            "calls": 9, "output_tokens": 10, "last_ts": 100, "last_used": "2026-10-01",
-        }]}
-        row = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
-        self.assertEqual(row["configuration"], "Not in config")
-        self.assertEqual(row["state"], "Not in config")
-        self.assertIsNone(row["enabled"])
-        self.assertEqual(row["runtime"], "Claude")
-
-    def test_codex_host_tool_groups_are_not_mcp_disable_candidates(self):
-        from token_meter.domain.tools import session_capabilities
-        catalog = meter.normalize_dynamic_tools([
-            {"name": "codex_app", "tools": [{"name": "navigate_to_codex_page"}]},
-            {"name": "plugin_management", "tools": [{"name": "uninstall_plugin"}]},
-        ])
-        self.assertTrue(all(row.get("host_provided") for row in catalog))
-        rows = [{
-            "id": f"s{index}", "provider": "codex", "runtime": "Codex", "project": "/r",
-            "path": f"/tmp/s{index}.jsonl",
-            "_tool_evidence": meter.summarize_tool_evidence([], catalog),
-        } for index in range(6)]
-        waste = meter.global_tool_waste(rows)
-        self.assertEqual(
-            [row["name"] for row in waste["inventory_tools"] if row["recommendation"] == "disable"],
-            [],
-        )
-        self.assertNotIn("MCP disable candidate", [row.get("title") for row in waste["insights"]])
-        self.assertEqual(
-            session_capabilities(rows[0]["_tool_evidence"])["mcp_servers"],
-            {"loaded": None, "used": 0},
-        )
-        items = self.inventory(waste)["items"]
-        self.assertEqual([row["name"] for row in items if row["type"] == "mcp"], [])
-        tools = {row["identity"]: row for row in items if row["type"] == "tool"}
-        self.assertEqual(tools["mcp__codex_app__navigate_to_codex_page"]["runtime"], "Codex")
-
-    def test_codex_host_tool_group_calls_are_host_provided(self):
-        calls = meter.codex_tool_call_evidence([
-            self.codex_exec("await tools.mcp__codex_app__wait_threads({});"),
-            {"timestamp": "2026-10-01T00:00:01Z", "payload": {
-                "type": "function_call", "name": "read_thread", "namespace": "codex_app",
-                "call_id": "c2", "arguments": "{}",
-            }},
-        ])
-        hosted = {row["name"]: row.get("host_provided") for row in calls if row["kind"] == "mcp"}
-        self.assertEqual(hosted, {
-            "mcp__codex_app__wait_threads": True, "mcp__codex_app__read_thread": True,
-        })
-
-    def test_advertised_only_mcp_has_runtime_and_no_call_claim(self):
-        catalog = [{"name": "mcp__jira__search", "namespace": "jira", "kind": "mcp",
-                    "defer_loading": True, "definition_tokens": 10}]
-        waste = meter.global_tool_waste([{
-            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
-            "_tool_evidence": meter.summarize_tool_evidence([], catalog),
-        }])
-        row = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
-        self.assertEqual((row["name"], row["runtime"], row["calls"]), ("jira", "Codex", 0))
-        script = Path(DASHBOARD_PAGE).read_text()
-        self.assertIn("Advertised in traces; not in Codex or Claude config", script)
-
-    def test_nested_calls_are_daily_and_labelled_as_call_sites(self):
-        calls = meter.codex_tool_call_evidence([
-            self.codex_exec("await tools.mcp__sharepoint__search({});"),
-        ])
-        evidence = meter.summarize_tool_evidence(calls)
-        row = next(item for item in evidence["tools"] if item["name"] == "mcp__sharepoint__search")
-        self.assertEqual(row["nested_calls"], 1)
-        self.assertEqual([day["calls"] for day in row["daily"]], [1])
-        waste = meter.global_tool_waste([{
-            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
-            "_tool_evidence": evidence,
-        }])
-        mcp = next(item for item in self.inventory(waste)["items"] if item["type"] == "mcp")
-        self.assertEqual(mcp["nested_calls"], 1)
-        script = Path(DASHBOARD_PAGE).read_text()
-        self.assertIn("code-mode call site", script)
-
-    def test_host_tools_keep_non_disable_advice(self):
-        call = {**meter.tool_identity("mcp__codex_app__read_thread"), "output_tokens": 30000,
-                "ts": 100, "args_fingerprint": "x", "error": False, "host_provided": True}
-        waste = meter.global_tool_waste([{
-            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
-            "_tool_evidence": meter.summarize_tool_evidence([call]),
-        }])
-        row = next(item for item in waste["inventory_tools"]
-                   if item["name"] == "mcp__codex_app__read_thread")
-        self.assertEqual(row["recommendation"], "narrow_results")
-
-    def test_host_tools_get_no_project_scope_advice(self):
-        def call(index):
-            return {**meter.tool_identity("mcp__codex_app__wait_threads"), "output_tokens": 1,
-                    "ts": 100 + index, "args_fingerprint": str(index), "error": False,
-                    "host_provided": True}
-        waste = meter.global_tool_waste([{
-            "id": "s", "provider": "codex", "runtime": "Codex", "project": "/r",
-            "_tool_evidence": meter.summarize_tool_evidence([call(i) for i in range(6)]),
-        }])
-        row = next(item for item in waste["inventory_tools"]
-                   if item["name"] == "mcp__codex_app__wait_threads")
-        self.assertEqual(row["recommendation"], "keep")
-        self.assertEqual(row["reason"], "Provided by the runtime itself; not a configurable MCP server.")
-
-    def test_session_catalog_host_groups_are_not_used_mcp_servers(self):
-        from token_meter.domain.tools import session_capabilities
-        catalog = meter.normalize_dynamic_tools([
-            {"name": "newapp", "tools": [{"name": "open"}]},
-        ])
-        evidence = meter.summarize_tool_evidence(meter.codex_tool_call_evidence([
-            self.codex_exec("await tools.mcp__newapp__open({});"),
-        ]), catalog)
-        self.assertEqual(
-            session_capabilities(evidence)["mcp_servers"], {"loaded": None, "used": 0},
-        )
-
-    def test_builder_recap_tool_total_excludes_code_mode_call_sites(self):
-        from token_meter.domain.builder_recap import _period_rollup
-        evidence = meter.summarize_tool_evidence(meter.codex_tool_call_evidence([
-            self.codex_exec("await tools.mcp__sharepoint__search({});"),
-        ]))
-        day = datetime.date.fromtimestamp(evidence["tools"][0]["last_ts"] or 1790812800)
-        rollup = _period_rollup([{
-            "id": "s", "provider": "codex", "runtime": "Codex", "_tool_evidence": evidence,
-        }], day, day)
-        self.assertEqual(rollup["tool_calls"], 1)
-        self.assertEqual(sorted(rollup["tools"].values()), [1, 1])
-
-    def test_codex_multi_part_mcp_namespace_keeps_server(self):
-        from token_meter.runtimes.codex import codex_mcp_tool_name
-        self.assertEqual(codex_mcp_tool_name("x", "mcp__a__b"), "mcp__a__x")
-        self.assertEqual(codex_mcp_tool_name("x", "foo__bar"), "x")
-
-    def test_tools_page_renders_unconfigured_mcp_without_off_claims(self):
-        script = Path(DASHBOARD_PAGE).read_text()
-        start = script.index("function capabilityConfigurationText(row){")
-        body = script[start:script.index("\n}", start)]
-        self.assertNotIn("row.enabled?'Enabled':'Disabled'", body.replace(" ", ""))
-        self.assertIn("row.configured===false", script)
-        for handler in ("$('c-type-filter').onclick", "$('c-state-filter').onclick"):
-            line = script[script.index(handler):].split("\n", 1)[0]
-            self.assertIn("paintCapabilityFilters()", line)
-
-    def test_codex_sanitized_mcp_names_match_configured_server(self):
-        waste = {"inventory_tools": [{
-            "id": "mcp__ghost_mcp_proxy__slack", "name": "mcp__ghost_mcp_proxy__slack",
-            "display": "slack", "kind": "mcp", "namespace": "ghost_mcp_proxy",
-            "mcp_server": "ghost_mcp_proxy", "runtime": "Codex", "providers": ["codex"],
-            "calls": 4, "output_tokens": 0, "last_ts": 100, "last_used": "2026-10-01",
-        }]}
-        items = self.inventory(waste, codex_mcp={"ghost-mcp-proxy": True})["items"]
-        mcps = {row["name"]: row for row in items if row["type"] == "mcp"}
-        self.assertEqual(set(mcps), {"ghost-mcp-proxy"})
-        self.assertEqual(mcps["ghost-mcp-proxy"]["calls"], 4)
-        self.assertTrue(mcps["ghost-mcp-proxy"]["used"])
-        self.assertEqual(mcps["ghost-mcp-proxy"]["configuration"], "Enabled")
-
-
-class DashboardThemeTests(unittest.TestCase):
-    """Theme choice is a browser preference applied before first paint and offered in Settings and ⌘K."""
-
-    def setUp(self):
-        self.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
-
-    def run_boot(self, stored, throws=False):
-        boot = re.search(r"<script id=theme-boot>(.*?)</script>", self.page, re.S).group(1)
-        script = (
-            "const document={documentElement:{dataset:{theme:'classic'}}};const window={};"
-            f"const localStorage={{getItem(){{if({json.dumps(throws)})throw new Error('blocked');return {json.dumps(stored)};}}}};"
-            f"{boot};console.log(document.documentElement.dataset.theme);"
-        )
-        return subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout.strip()
-
-    def test_boot_script_applies_only_known_stored_themes(self):
-        self.assertIn("<html lang=en data-theme=classic>", self.page)
-        self.assertLess(self.page.index("<script id=theme-boot>"), self.page.index("<style>"))
-        self.assertEqual(self.run_boot("voltage"), "voltage")
-        self.assertEqual(self.run_boot("monolith"), "monolith")
-        self.assertEqual(self.run_boot("nebula"), "nebula")
-        self.assertEqual(self.run_boot("not-a-theme"), "classic")
-        self.assertEqual(self.run_boot(None), "classic")
-        self.assertEqual(self.run_boot("voltage", throws=True), "classic")
-
-    def test_random_theme_is_retired_and_stored_value_falls_back_to_classic(self):
-        self.assertEqual(self.run_boot("random"), "classic")
-        self.assertNotIn("THEME_RANDOM", self.page)
-        self.assertNotIn("theme-random", self.page)
-        self.assertNotIn("Randomize daily", self.page)
-
-    def test_every_registered_theme_boots_and_the_picker_uses_a_four_column_grid(self):
-        for theme in ("classic", "nebula", "monolith", "voltage", "phosphor", "omarchy", "jadehorse", "ferrous", "afterglow"):
-            self.assertEqual(self.run_boot(theme), theme)
-        self.assertIn(".themePicker{display:grid;grid-template-columns:repeat(4,minmax(0,1fr))", self.page)
-
-    def test_theme_registry_normalizes_and_feeds_the_palette(self):
-        start = self.page.index("const THEMES=[")
-        registry = self.page[start:self.page.index("let activeTheme=", start)]
-        script = registry + (
-            "console.log(JSON.stringify({ids:THEMES.map(t=>t.id),bad:normalizeThemeId('x'),ok:normalizeThemeId('voltage'),"
-            "label:themeLabel('monolith'),key:THEME_STORAGE_KEY,random:normalizeThemeId('random')}));"
-        )
-        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
-        self.assertEqual(result, {"ids": ["classic", "nebula", "monolith", "voltage", "phosphor", "omarchy", "jadehorse", "ferrous", "afterglow"], "bad": "classic", "ok": "voltage",
-                                  "label": "Monolith", "key": "tm_theme", "random": "classic"})
-        self.assertIn("...THEMES.map(theme=>({id:`theme-${theme.id}`,label:`Theme · ${theme.label}`", self.page)
-        self.assertIn("if(command.action==='theme'){setTheme(command.theme);return;}", self.page)
-        self.assertIn("route:'settings-appearance'", self.page)
-
-    def test_rapid_theme_changes_keep_page_and_storage_in_sync(self):
-        start = self.page.index("function setTheme(")
-        body = self.page[start:self.page.index("\n}\n", start) + 2]
-        script = (
-            "const THEMES=[{id:'nebula'},{id:'monolith'},{id:'voltage'}];"
-            "const normalizeThemeId=v=>THEMES.some(t=>t.id===v)?v:'nebula';const THEME_STORAGE_KEY='tm_theme';"
-            "const resolveTheme=v=>v;let themePreference='nebula';"
-            "let stored=null,repaints=0,queued=[];const localStorage={setItem(k,v){stored=v;}};"
-            "const pageSignalReducedMotionQuery={matches:false};"
-            "const document={documentElement:{dataset:{theme:'nebula'}},startViewTransition(cb){queued.push(cb);return {};}};"
-            "function paintThemePicker(){}function repaintThemedSurfaces(){repaints++;}"
-            "let activeTheme='nebula';" + body +
-            "setTheme('voltage');setTheme('monolith');setTheme('nebula');queued.forEach(cb=>cb());"
-            "console.log(JSON.stringify({page:document.documentElement.dataset.theme,stored,active:activeTheme,repaints}));"
-        )
-        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
-        self.assertEqual(result["page"], "nebula")
-        self.assertEqual(result["stored"], "nebula")
-        self.assertEqual(result["active"], "nebula")
-        self.assertGreaterEqual(result["repaints"], 1)
-
-    def test_performance_page_follows_the_dashboard_theme(self):
-        perf = Path(__file__).resolve().parents[1].joinpath("performance.html").read_text(encoding="utf-8")
-        boot = re.compile(r"<script id=theme-boot>.*?</script>", re.S)
-        self.assertEqual(boot.search(perf).group(0), boot.search(self.page).group(0))
-        self.assertIn("<html lang=en data-theme=classic>", perf)
-        block = re.compile(r"\n((?::root,)?\[data-theme=(\w+)\])\{([^{}]*)\}")
-        dashboard = {m.group(2): dict(re.findall(r"--([\w-]+):([^;]+);", m.group(3))) for m in block.finditer(self.page)}
-        performance = {m.group(2): dict(re.findall(r"--([\w-]+):([^;]+);", m.group(3))) for m in block.finditer(perf)}
-        self.assertEqual(sorted(performance), sorted(dashboard))
-        self.assertIn(":root,[data-theme=classic]{", perf)
-        for theme, tokens in performance.items():
-            with self.subTest(theme=theme):
-                self.assertTrue(tokens)
-                shared = {k: v for k, v in tokens.items() if not k.startswith("card-")}
-                self.assertEqual(shared, {k: dashboard[theme][k] for k in shared})
-                card = sorted(k for k in tokens if k.startswith("card-"))
-                self.assertEqual(card, ["card-a-rgb", "card-b-rgb", "card-c-rgb", "card-foot", "card-glow-rgb",
-                                        "card-hero", "card-hi-rgb", "card-idle-rgb", "card-paper-a-rgb",
-                                        "card-paper-b-rgb"])
-        style = perf[perf.index("<style>"):perf.index("</style>")]
-        chrome = block.sub("", style)
-        self.assertNotIn("#00bceb", chrome)
-        self.assertNotIn("rgba(0,188,235", chrome)
-        script = perf[perf.index("<script>"):perf.rindex("</script>")]
-        draw = script[script.index("function cardPalette("):script.index("function setStatus(")]
-        draw = draw.replace(draw[draw.index("const CLASSIC_CARD="):draw.index("\n", draw.index("const CLASSIC_CARD="))], "")
-        for literal in ("#00bceb", "#4054d6", "#8ee9f2", "#8f6ce6", "rgba(0,188,235", "rgba(64,84,214", "rgba(127,219,242", "#0d2c3d"):
-            with self.subTest(card_literal=literal):
-                self.assertNotIn(literal, draw)
-        self.assertIn("window.addEventListener('storage',event=>{", script)
-
-    def test_performance_rail_lists_the_same_destinations_as_the_dashboard(self):
-        perf = Path(__file__).resolve().parents[1].joinpath("performance.html").read_text(encoding="utf-8")
-        def groups(source, primary, secondary, label):
-            top = source[source.index(f"<div class={primary}>"):source.index(f"<div class={secondary}>")]
-            bottom = source[source.index(f"<div class={secondary}>"):source.index("</nav>", source.index(f"<div class={secondary}>"))]
-            return re.findall(label, top), re.findall(label, bottom)
-        dashboard = groups(self.page, "navPrimary", "navSecondary", r'class="?tab[^>]*data-label=(\w+)')
-        performance = groups(perf, "railPrimary", "railSecondary", r"<span class=railLabel>(\w+)</span>")
-        self.assertEqual(performance, dashboard)
-        self.assertEqual(dashboard[1][0], "Read")
-        tokenomics = re.search(r"const TOKENOMICS_SEARCH_URL='([^']+)'", self.page).group(1)
-        self.assertIn(f'id=tab-read href="{tokenomics}" target=_blank rel="noopener noreferrer"', perf)
-
-    def test_appearance_settings_section_and_route(self):
-        self.assertIn('<nav class="card settingsMap" aria-label="Settings sections">\n    <button type=button data-settings-target=appearance-settings><b>Appearance</b></button>', self.page)
-        content = self.page.index("<div class=settingsPageContent>")
-        self.assertEqual(self.page.index("<section", content), self.page.index('<section class="card pad appearanceSettings"', content))
-        self.assertIn('<section class="card pad appearanceSettings" id=appearance-settings>', self.page)
-        self.assertIn("<div class=themePicker id=theme-picker role=group aria-labelledby=appearance-title></div>", self.page)
-        self.assertIn("h==='settings-appearance'", self.page)
-        self.assertIn("option.setAttribute('aria-pressed',String(option.dataset.themeOption===themePreference));", self.page)
-        self.assertIn("window.addEventListener('storage',event=>{if(event.key===THEME_STORAGE_KEY)", self.page)
-
-    def test_theme_switch_repaints_token_driven_surfaces(self):
-        start = self.page.index("function repaintThemedSurfaces(){")
-        body = self.page[start:self.page.index("\n}", start)]
-        for marker in ("readChartTokens();", "drawIO(", "renderModelStats(", "renderEfficiency(",
-                       "drawSpendScatter(", "drawDeliveryChart(", "syncActivePageSignalEffects();", "meta[name=theme-color]"):
-            with self.subTest(marker=marker):
-                self.assertIn(marker, body)
-        effects = Path(__file__).resolve().parents[1].joinpath("assets", "session-effects.js").read_text(encoding="utf-8")
-        self.assertIn("getComputedStyle(element)", effects)
-        for token in ("--fx-front-rgb", "--fx-back-rgb", "--fx-edge-a-rgb", "--fx-edge-b-rgb"):
-            self.assertIn(f'"{token}"', effects)
-
-    def motion_source(self, start, end):
-        return self.page[self.page.index(start):self.page.index(end)]
-
-    def test_readouts_count_only_meaningful_numeric_changes(self):
-        source = self.motion_source("const READOUT_PATTERN=", "// Readouts count toward")
-        script = (
-            "let clock=0;const performance={now:()=>clock};const frames=[];const requestAnimationFrame=cb=>frames.push(cb);"
-            "const cssVar=()=>'480ms';" + source +
-            "const el={textContent:''};const ran=(a,b)=>{frames.length=0;tweenReadout(el,a,b);return frames.length>0;};"
-            "const out={placeholder:ran('—','$4.20'),word:ran('Sonnet 3.7','Sonnet 4.5'),suffix:ran('12K','3M'),"
-            "tiny:ran('$100.00','$100.40'),real:ran('$100.00','$140.00')};clock=2000;out.quiet=ran('$140.00','$200.00');"
-            "clock=20000;out.later=ran('$140.00','$200.00');"
-            "const other={textContent:''};frames.length=0;tweenReadout(other,'$1,000','$2,000');clock=50000;frames.shift()(clock);out.final=other.textContent;"
-            "console.log(JSON.stringify(out));"
-        )
-        result = json.loads(subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout)
-        self.assertEqual(result, {"placeholder": False, "word": False, "suffix": False, "tiny": False, "real": True,
-                                  "quiet": False, "later": True, "final": "$2,000"})
-
-    def test_no_glow_follows_the_cursor(self):
-        # A highlight moving behind text under the pointer made cards hard to read, so cards stay still.
-        self.assertNotIn("isSpotlit", self.page)
-        self.assertNotIn("--spot", self.page)
-        self.assertNotIn("spotlight", self.page.lower().replace("spotlights", ""))
-
-    def test_chart_reveal_runs_once_per_route_change(self):
-        source = self.motion_source("const chartsRevealedThisVisit=", "const READOUT_SELECTOR=")
-        script = (
-            "let animations=0;const svg={id:'iochart',childElementCount:3,getClientRects:()=>[1],animate(){animations++;}};"
-            "const $=()=>svg;const motionAllowed=()=>true;const cssVar=()=>'ease';const CHART_REVEAL_IDS=['iochart'];"
-            "class MutationObserver{observe(){}}" + source +
-            "const session={dataset:{entered:'1'},children:[]},spend={dataset:{entered:'1'},children:[]};"
-            "playRouteMotion(session);playRouteMotion(session);revealChart(svg);playRouteMotion(spend);playRouteMotion(session);"
-            "console.log(animations);"
-        )
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True).stdout.strip()
-        self.assertEqual(result, "3")
-
-
-class CostDiscountTests(unittest.TestCase):
-    """Contracted discounts apply per request to list-price estimates only."""
-
-    T0 = 1_788_000_000  # 2026-08-29T14:40:00Z
-
-    def setUp(self):
-        meter._reset_cost_discount_cache()
-        self.addCleanup(meter._reset_cost_discount_cache)
-        self._tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        self.tmp = Path(self._tmp.name)
-
-    @staticmethod
-    def rule(price_list, channel, percent, start=None, end=None, rule_id=None):
-        return {"id": rule_id or "d_" + (price_list + channel + str(percent)).replace(".", "")[:30].lower().ljust(8, "0"),
-                "price_list": price_list, "channel": channel, "percent": percent,
-                "start": start, "end": end}
-
-    def settings(self, rules=(), runtime_channels=None, **other):
-        path = self.tmp / "settings-{}.json".format(len(list(self.tmp.iterdir())))
-        payload = dict(other)
-        if rules is not None:
-            payload["cost_discounts"] = {"version": 1, "rules": list(rules),
-                                         **({"runtime_channels": runtime_channels} if runtime_channels else {})}
-        path.write_text(json.dumps(payload))
-        meter._reset_cost_discount_cache()
-        return path
-
-    def patched(self, path):
-        return mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path))
-
-    CODEX_USAGE = {"input_tokens": 1_000_000, "output_tokens": 100_000,
-                   "cache_read_input_tokens": 0, "cache_creation_input_tokens": 0}
-
-    # ---- persistence -------------------------------------------------
-
-    def test_absent_key_means_list_price_and_reading_never_seeds(self):
-        path = self.settings(rules=None, budgets={"monthly_total": 5})
-        before = path.read_text()
-        with self.patched(path):
-            listed = meter.cost_of(self.CODEX_USAGE, "gpt-5.4", "codex", at=self.T0)
-            view = meter.cost_discount_settings()
-        self.assertEqual(listed.discount_usd, 0.0)
-        self.assertEqual(view["rules"], [])
-        self.assertEqual(view["runtime_channels"], {"claude_code": "auto", "claude_desktop": "auto"})
-        self.assertEqual(path.read_text(), before)
-        self.assertNotIn("cost_discounts", meter.OBSOLETE_SETTINGS_KEYS)
-
-    def test_ops_persist_atomically_and_preserve_other_settings(self):
-        path = self.settings(rules=None, budgets={"monthly_total": 5})
-        original = meter.atomic_write_text
-        with mock.patch.object(meter, "atomic_write_text", side_effect=original) as write:
-            result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {
-                "external_id": "sync:a", "price_list": "anthropic", "channel": "direct",
-                "percent": 30, "start": "2026-09-01T00:00:00-07:00", "end": None,
-                "label": "Team plan"}}], path=str(path), now=self.T0)
-        saved = json.loads(path.read_text())
-        self.assertTrue(result["ok"], result)
-        self.assertTrue(result["changed"])
-        self.assertEqual(write.call_count, 1)
-        self.assertEqual(saved["budgets"], {"monthly_total": 5})
-        stored = saved["cost_discounts"]["rules"][0]
-        self.assertRegex(stored["id"], r"^d_[a-z0-9]{8,40}$")
-        self.assertEqual((stored["start"], stored["set_by"], stored["source"]), (1788246000, "Settings", "dashboard"))
-        self.assertEqual(result["revision"], meter.cost_discount_settings(str(path))["revision"])
-        self.assertEqual(result["rules"][0]["start_iso"], "2026-09-01T07:00:00Z")
-
-    def test_invalid_stored_rule_is_ignored_without_rewrite(self):
-        path = self.settings([self.rule("openai", "any", 50), {"id": "broken", "percent": 500}])
-        before, mtime = path.read_text(), path.stat().st_mtime_ns
-        with self.patched(path):
-            view = meter.cost_discount_settings()
-            cost = meter.cost_of(self.CODEX_USAGE, "gpt-5.4", "codex", at=self.T0)
-        self.assertEqual(view["invalid_rules"], 1)
-        self.assertEqual(len(view["rules"]), 1)
-        self.assertAlmostEqual(cost.discount_usd, cost.list_usd * 0.5)
-        self.assertEqual((path.read_text(), path.stat().st_mtime_ns), (before, mtime))
-
-    def test_upsert_delete_replace_scope_and_runtime_channels(self):
-        path = str(self.settings(rules=None))
-        upsert = {"op": "upsert", "rule": {"external_id": "sync:a", "price_list": "anthropic",
-                                           "channel": "direct", "percent": 30}}
-        first = meter.apply_cost_discount_ops([upsert], path=path, now=1)
-        original = meter.atomic_write_text
-        with mock.patch.object(meter, "atomic_write_text", side_effect=original) as write:
-            again = meter.apply_cost_discount_ops([upsert], source="api", set_by="sync", path=path, now=2)
-        self.assertEqual((again["changed"], again["revision"], write.call_count), (False, first["revision"], 0))
-        rule_id = first["rules"][0]["id"]
-        edited = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {
-            "external_id": "sync:a", "percent": 25}}], source="api", set_by="contract-sync", path=path, now=3)
-        self.assertEqual((edited["rules"][0]["id"], edited["rules"][0]["percent"]), (rule_id, 25))
-        self.assertEqual(edited["rules"][0]["set_by"], "contract-sync")
-        scoped = meter.apply_cost_discount_ops([{"op": "replace_scope", "price_list": "openai", "channel": "any",
-                                                 "rules": [{"external_id": "sync:o", "percent": 62}]}], path=path)
-        self.assertEqual(sorted(r["price_list"] for r in scoped["rules"]), ["anthropic", "openai"])
-        cleared = meter.apply_cost_discount_ops([{"op": "replace_scope", "price_list": "openai",
-                                                  "channel": "any", "rules": []}], path=path)
-        self.assertEqual([r["id"] for r in cleared["rules"]], [rule_id])
-        missing = meter.apply_cost_discount_ops([{"op": "delete", "external_id": "nope"}], path=path)
-        self.assertEqual((missing["ok"], missing["changed"]), (True, False))
-        channels = meter.apply_cost_discount_ops([{"op": "set_runtime_channels", "claude_code": "bedrock"}], path=path)
-        self.assertTrue(channels["changed"])
-        self.assertEqual(meter.cost_discount_settings(path)["runtime_channels"]["claude_code"], "bedrock")
-        deleted = meter.apply_cost_discount_ops([{"op": "delete", "id": rule_id}], path=path)
-        self.assertEqual(deleted["rules"], [])
-
-    def test_batches_are_all_or_nothing_and_errors_are_plain(self):
-        path = str(self.settings([self.rule("anthropic", "direct", 30, start=100)]))
-        before = Path(path).read_text()
-        overlap = meter.apply_cost_discount_ops([
-            {"op": "upsert", "rule": {"price_list": "openai", "percent": 10}},
-            {"op": "upsert", "rule": {"price_list": "anthropic", "channel": "direct", "percent": 20, "start": 50}},
-        ], path=path)
-        self.assertFalse(overlap["ok"])
-        self.assertEqual(overlap["error"], "Anthropic billed by the provider already has 30% for overlapping dates.")
-        for ops in ([{"op": "rename"}], [{"op": "delete", "id": "x"}] * 65,
-                    [{"op": "upsert", "rule": {"price_list": "openai", "percent": 5, "start": "2026-09-01"}}],
-                    [{"op": "upsert", "rule": {"price_list": "cursor", "channel": "direct", "percent": 5}}]):
-            self.assertFalse(meter.apply_cost_discount_ops(ops, path=path)["ok"])
-        self.assertEqual(Path(path).read_text(), before)
-
-    def test_stale_expected_revision_is_a_conflict(self):
-        path = str(self.settings(rules=None))
-        stale = meter.cost_discount_settings(path)["revision"]
-        meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}], path=path)
-        result = meter.apply_cost_discount_ops(
-            [{"op": "upsert", "rule": {"price_list": "openai", "channel": "azure", "percent": 9}}],
-            expected_revision=stale, path=path)
-        self.assertEqual((result["ok"], result["conflict"]), (False, True))
-        self.assertEqual(result["revision"], meter.cost_discount_settings(path)["revision"])
-
-    def test_concurrent_settings_writers_keep_each_others_keys(self):
-        path = str(self.settings(rules=None))
-        original_load = meter.load_json
-
-        def slow_load(*args, **kwargs):
-            value = original_load(*args, **kwargs)
-            time.sleep(0.003)
-            return value
-
-        errors = []
-
-        def discounts():
-            for index in range(15):
-                result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {
-                    "external_id": "e{}".format(index), "price_list": "openai", "channel": "any",
-                    "percent": 5, "start": index * 10, "end": index * 10 + 10}}], path=path)
-                errors.extend([result] if not result["ok"] else [])
-
-        def other_features():
-            for index in range(15):
-                meter.set_update_settings({"enabled": index % 2 == 0}, path=path)
-                meter.set_model_price("openai", "gpt-custom-{}".format(index),
-                                      {"input": 1, "output": 2, "cache_write": 0, "cache_read": 0}, path=path)
-
-        with mock.patch.object(meter, "load_json", side_effect=slow_load):
-            threads = [threading.Thread(target=discounts), threading.Thread(target=other_features)]
-            for thread in threads:
-                thread.start()
-            for thread in threads:
-                thread.join()
-        saved = json.loads(Path(path).read_text())
-        self.assertEqual(errors, [])
-        self.assertEqual(len(saved["cost_discounts"]["rules"]), 15)
-        self.assertEqual(len(saved["model_pricing"]["codex"]), 15)
-        self.assertIn("updates", saved)
-
-    # ---- application -------------------------------------------------
-
-    def codex_rows(self, stamps):
-        rows = [{"type": "turn_context", "timestamp": stamps[0], "payload": {"model": "gpt-5.4"}}]
-        for stamp in stamps:
-            rows.append({"timestamp": stamp, "payload": {"type": "token_count", "info": {
-                "last_token_usage": {"input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}})
-        return rows
-
-    def codex_summary(self, path, stamps):
-        source = {"id": "s", "path": "/tmp/s.jsonl", "provider": "codex", "client": "codex",
-                  "label": "Codex", "project": "/repo", "mtime": 1, "title": "t", "model": "gpt-5.4"}
-        with self.patched(path):
-            return meter.codex_summary(source, self.codex_rows(stamps))
-
-    def test_codex_discount_applies_only_inside_its_range(self):
-        stamps = ["2026-09-01T10:00:00.000Z", "2026-09-02T10:00:00.000Z", "2026-09-03T10:00:00.000Z"]
-        start = meter.parse_iso("2026-09-02T00:00:00")
-        end = meter.parse_iso("2026-09-03T00:00:00")
-        listed = self.codex_summary(self.settings(rules=None), stamps)
-        discounted = self.codex_summary(self.settings([self.rule("openai", "direct", 50, start, end)]), stamps)
-        each = listed["cost"] / 3
-        self.assertAlmostEqual(discounted["cost"], each * 2.5)
-        self.assertAlmostEqual(discounted["discount_usd"], each * 0.5)
-        self.assertAlmostEqual(discounted["cost"] + discounted["discount_usd"], listed["cost"])
-        self.assertAlmostEqual(discounted["model_stats"][0]["discount_usd"], each * 0.5)
-        self.assertAlmostEqual(sum(discounted["_day_discount"].values()), each * 0.5)
-        self.assertAlmostEqual(sum(discounted["_day_cost"].values()), discounted["cost"])
-        azure = dict(listed)
-        self.assertEqual(azure["discount_usd"], 0.0)
-
-    def test_mid_day_boundary_splits_one_days_cost(self):
-        stamps = ["2026-09-02T10:00:00.000Z", "2026-09-02T14:00:00.000Z"]
-        start = meter.parse_iso("2026-09-02T12:00:00")
-        listed = self.codex_summary(self.settings(rules=None), stamps)
-        row = self.codex_summary(self.settings([self.rule("openai", "any", 40, start)]), stamps)
-        (day, cost), = row["_day_cost"].items()
-        self.assertAlmostEqual(cost, listed["_day_cost"][day] * 0.8)
-        self.assertAlmostEqual(row["_day_discount"][day], listed["_day_cost"][day] * 0.2)
-
-    def test_codex_on_azure_uses_azure_then_any_rule(self):
-        path = self.settings([self.rule("openai", "direct", 50), self.rule("openai", "azure", 20)])
-        source = {"id": "s", "path": "/tmp/s.jsonl", "provider": "codex", "client": "codex", "label": "Codex",
-                  "project": "/repo", "mtime": 1, "title": "t", "model": "gpt-5.4", "model_provider": "azure"}
-        with self.patched(path):
-            row = meter.codex_summary(source, self.codex_rows(["2026-09-02T10:00:00.000Z"]))
-        self.assertAlmostEqual(row["discount_usd"] / (row["cost"] + row["discount_usd"]), 0.2)
-
-    def test_cursor_hosted_gpt_ignores_openai_rule(self):
-        usage = {"input_tokens": 1_000_000, "output_tokens": 100_000}
-        with self.patched(self.settings([self.rule("openai", "any", 60)])):
-            openai_only = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=self.T0)
-        with self.patched(self.settings([self.rule("cursor", "any", 10)])):
-            cursor_rule = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=self.T0)
-        self.assertGreater(openai_only.list_usd, 0)
-        self.assertEqual(openai_only.discount_usd, 0.0)
-        self.assertAlmostEqual(cursor_rule.discount_usd, cursor_rule.list_usd * 0.1)
-
-    def test_kiro_takes_only_kiro_rules(self):
-        from token_meter.runtimes.kiro import KiroRuntimeAdapter
-        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
-                                     compatibility=meter._kiro_compatibility())
-        turn = {"input_tokens": 100_000, "output_tokens": 10_000, "end": self.T0, "model": "claude-sonnet-4-6"}
-        source = {"model": "claude-sonnet-4-6"}
-        with self.patched(self.settings([self.rule("anthropic", "any", 30)])):
-            _model, anthropic_only, available = adapter._legacy_turn(source, turn)
-        with self.patched(self.settings([self.rule("kiro", "any", 20)])):
-            _model, kiro_rule, _available = adapter._legacy_turn(source, turn)
-        self.assertTrue(available)
-        self.assertEqual(anthropic_only.discount_usd, 0.0)
-        self.assertAlmostEqual(kiro_rule.discount_usd, kiro_rule.list_usd * 0.2)
-        self.assertAlmostEqual(sum(kiro_rule.values()), sum(anthropic_only.values()) * 0.8)
-
-    def pi_summary(self, path, provider, child=None):
-        root = self.tmp / "pi-{}".format(len(list(self.tmp.iterdir())))
-        directory = root / "sessions" / "--repo--"
-        directory.mkdir(parents=True)
-        cost = {"input": 0.001, "output": 0.002, "cacheRead": 0.0001, "cacheWrite": 0.0002}
-        assistant = {"role": "assistant", "model": "claude-test", "provider": provider,
-                     "content": [{"type": "toolCall", "id": "call", "name": "subagent" if child else "read",
-                                  "arguments": {"agent": "probe"}}],
-                     "usage": {"input": 100, "output": 20, "cacheRead": 10, "cacheWrite": 5, "cost": cost}}
-        rows = [
-            {"type": "session", "version": 3, "id": "pi", "timestamp": "2026-09-04T10:00:00Z", "cwd": "/repo"},
-            {"type": "model_change", "timestamp": "2026-09-04T10:00:01Z", "provider": provider, "modelId": "claude-test"},
-            {"type": "message", "timestamp": "2026-09-04T10:00:02Z", "message": {"role": "user", "content": []}},
-            {"type": "message", "timestamp": "2026-09-04T10:00:05Z", "message": assistant},
-        ]
-        if child:
-            rows.append({"type": "message", "timestamp": "2026-09-04T10:00:09Z", "message": {
-                "role": "toolResult", "toolCallId": "call", "toolName": "subagent",
-                "details": {"mode": "single", "results": [{
-                    "agent": "probe", "exitCode": 0, "stopReason": "stop", "model": child,
-                    "usage": {"input": 1000, "output": 100, "cacheRead": 0, "cacheWrite": 0,
-                              "cost": 0.25, "turns": 2}}]}}})
-        (directory / "pi.jsonl").write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-        with self.patched(path), mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
-                mock.patch.object(meter, "_pi_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            return meter.pi_summary(meter.pi_session_sources()[0])
-
-    def test_pi_on_bedrock_uses_bedrock_then_any_never_direct(self):
-        own = 0.0033
-        direct_only = self.pi_summary(self.settings([self.rule("anthropic", "direct", 90)]), "amazon-bedrock")
-        both = self.pi_summary(self.settings([self.rule("anthropic", "bedrock", 40),
-                                              self.rule("anthropic", "any", 10)]), "amazon-bedrock")
-        any_only = self.pi_summary(self.settings([self.rule("anthropic", "any", 10)]), "amazon-bedrock")
-        self.assertAlmostEqual(direct_only["cost"], own)
-        self.assertEqual(direct_only["discount_usd"], 0.0)
-        self.assertAlmostEqual(both["cost"], own * 0.6)
-        self.assertAlmostEqual(any_only["cost"], own * 0.9)
-        self.assertAlmostEqual(any_only["cost"] + any_only["discount_usd"], own)
-
-    def test_pi_subagent_cost_is_discounted_once(self):
-        listed = self.pi_summary(self.settings(rules=None), "anthropic", child="anthropic/claude-sonnet-4-6")
-        row = self.pi_summary(self.settings([self.rule("anthropic", "any", 50)]), "anthropic",
-                              child="anthropic/claude-sonnet-4-6")
-        self.assertAlmostEqual(listed["cost"], 0.2533)
-        self.assertAlmostEqual(row["cost"], 0.2533 * 0.5)
-        self.assertAlmostEqual(row["discount_usd"], 0.2533 * 0.5)
-        records = {record["kind"]: record for record in row["_agent_records"]}
-        self.assertAlmostEqual(records["root"]["cost"] + records["spawned"]["cost"], row["cost"])
-        gateway = self.pi_summary(self.settings([self.rule("anthropic", "any", 50)]), "anthropic",
-                                  child="opencode-go/deepseek-v4.1-flash")
-        self.assertAlmostEqual(gateway["cost"], 0.0033 * 0.5 + 0.25)
-
-    def test_opencode_vendor_messages_take_vendor_rules_and_gateway_takes_opencode(self):
-        helper = OpenCodeTests()
-        conn = helper._build_db(self.tmp)
-        base = 1_788_000_000_000
-        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
-            helper._session_row("ses_mix", "/repo", "Mixed", "claude-sonnet-4-6", 1.11,
-                                300, 30, 0, 0, 0, base + 10_000, provider_id="anthropic").values()))
-        for index, (model, provider, cost) in enumerate((
-                ("claude-sonnet-4-6", "anthropic", 1.0), ("gpt-5.4", "openai", 0.1),
-                ("kimi-k2", "opencode", 0.01), ("free-model", "openai", 0.0))):
-            created = base + index * 1000
-            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", helper._message(
-                "m{}".format(index), "ses_mix", {
-                    "role": "assistant", "modelID": model, "providerID": provider, "cost": cost,
-                    "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}},
-                    "time": {"created": created, "completed": created + 500}}, created))
-        conn.commit()
-        conn.close()
-        path = self.settings([self.rule("anthropic", "direct", 10), self.rule("openai", "any", 50),
-                              self.rule("opencode", "any", 20)])
-        source = {"provider": "opencode", "id": "ses_mix", "model": "claude-sonnet-4-6", "label": "OpenCode",
-                  "runtime": "OpenCode", "session": "ses_mix", "path": "opencode:ses_mix",
-                  "project": "/repo", "title": "Mixed", "mtime": 1.0}
-        with self.patched(path), mock.patch.object(meter, "OPENCODE_DB", str(self.tmp / "opencode.db")), \
-                mock.patch.object(meter, "_opencode_native_adapters", {}):
-            row = meter.opencode_summary(source)
-        costs = {stats["model"]: stats for stats in row["model_stats"]}
-        self.assertAlmostEqual(costs["claude-sonnet-4-6"]["cost"], 0.9)
-        self.assertAlmostEqual(costs["gpt-5.4"]["cost"], 0.05)
-        self.assertAlmostEqual(costs["kimi-k2"]["cost"], 0.008)
-        self.assertEqual(costs["free-model"]["cost"], 0.0)
-        self.assertAlmostEqual(row["discount_usd"], 0.1 + 0.05 + 0.002)
-        self.assertAlmostEqual(row["cost"] + row["discount_usd"], 1.11)
-
-    def opencode_long_session(self, schema):
-        """A 10-message OpenCode session, 0.1 each, in a V1 or V2 store."""
-        from tests.runtimes.test_opencode_adapter import V2_SCHEMA
-        db = self.tmp / "opencode-{}.db".format(schema)
-        con = sqlite3.connect(db)
-        base = 1_788_000_000_000
-        model = json.dumps({"id": "gpt-5.4", "providerID": "openai"})
-        if schema == "v2":
-            con.executescript(V2_SCHEMA)
-            con.execute(
-                "INSERT INTO session_v2 (id, project_id, slug, directory, title, version, cost, "
-                "tokens_input, tokens_output, agent, model, time_created, time_updated) "
-                "VALUES ('ses','p','ses','/repo','Long','2',1.0,1000,100,'build',?,?,?)",
-                (model, base, base + 20_000))
-        else:
-            OpenCodeTests._build_db(None, self.tmp)
-            con.close()
-            (self.tmp / "opencode.db").rename(db)
-            con = sqlite3.connect(db)
-            con.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
-                OpenCodeTests._session_row(None, "ses", "/repo", "Long", "gpt-5.4", 1.0, 1000, 100, 0, 0, 0,
-                                           base + 20_000, provider_id="openai").values()))
-        for index in range(10):
-            created = base + index * 1000
-            data = {"role": "assistant", "modelID": "gpt-5.4", "providerID": "openai", "cost": 0.1,
-                    "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}},
-                    "time": {"created": created, "completed": created + 500}}
-            if schema == "v2":
-                data = dict(data, model={"id": "gpt-5.4", "providerID": "openai"})
-                con.execute("INSERT INTO session_message VALUES (?,?,?,?,?,?,?)",
-                            ("m{}".format(index), "ses", "assistant", index, created, created, json.dumps(data)))
-            else:
-                con.execute("INSERT INTO message VALUES (?,?,?,?,?)",
-                            ("m{}".format(index), "ses", created, created, json.dumps(data)))
-        con.commit()
-        con.close()
-        return db
-
-    def test_opencode_session_discount_covers_messages_beyond_the_load_cap(self):
-        from token_meter.runtimes import opencode as opencode_runtime
-        source = {"provider": "opencode", "id": "ses", "model": "gpt-5.4", "model_provider": "openai",
-                  "label": "OpenCode", "runtime": "OpenCode", "session": "ses", "path": "opencode:ses",
-                  "project": "/repo", "title": "Long", "mtime": 1.0}
-        path = self.settings([self.rule("openai", "any", 50)])
-        for schema in ("v1", "v2"):
-            with self.subTest(schema=schema):
-                db = self.opencode_long_session(schema)
-                adapter = opencode_runtime.OpenCodeRuntimeAdapter(
-                    db, None, compatibility=meter._opencode_compatibility(), detail_message_limit=3)
-                with self.patched(path), mock.patch.object(opencode_runtime, "SUMMARY_MESSAGE_LIMIT", 4):
-                    row = adapter.summarize_legacy(dict(source))
-                    state = adapter.recompute_legacy(dict(source))
-                self.assertEqual(row["turns"], 4)
-                self.assertAlmostEqual(row["discount_usd"], 0.5)
-                self.assertAlmostEqual(row["cost"], 0.5)
-                self.assertAlmostEqual(row["cost"] + row["discount_usd"], 1.0)
-                self.assertEqual(len(state["executions"]), 3)
-                self.assertAlmostEqual(state["total_cost"], 0.5)
-        with self.patched(self.settings(rules=None)):
-            listed = opencode_runtime.OpenCodeRuntimeAdapter(
-                db, None, compatibility=meter._opencode_compatibility()).summarize_legacy(dict(source))
-        self.assertAlmostEqual(listed["cost"], 1.0)
-        self.assertEqual(listed["discount_usd"], 0.0)
-
-    def hermes_cost(self, path, status, column):
-        db = self.tmp / "hermes-{}.db".format(len(list(self.tmp.iterdir())))
-        con = sqlite3.connect(db)
-        con.execute("""CREATE TABLE sessions (id TEXT PRIMARY KEY, model TEXT, billing_provider TEXT,
-            started_at REAL, ended_at REAL, last_activity_at REAL, input_tokens INTEGER, output_tokens INTEGER,
-            cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER,
-            estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT,
-            billing_mode TEXT, tool_call_count INTEGER, api_call_count INTEGER, cwd TEXT, title TEXT)""")
-        con.execute("INSERT INTO sessions VALUES ('h','claude-test','anthropic',?,?,?,100,20,10,5,3,"
-                    "?,?,?,'recorded',NULL,2,1,'/p','t')",
-                    (self.T0, self.T0 + 10, self.T0 + 10,
-                     2.0 if column == "estimated" else None, 2.0 if column == "actual" else None, status))
-        con.commit()
-        con.close()
-        from token_meter.contracts import DetailLevel, DiscoveryContext
-        from token_meter.runtimes.hermes import HermesRuntimeAdapter
-        with self.patched(path):
-            adapter = HermesRuntimeAdapter(db, compatibility={
-                "price_for": meter.price_for, "cost_of": meter.cost_of, "discount_amount": meter.discount_amount})
-            source = adapter.discover(DiscoveryContext(home="/home/test"))[0]
-            return adapter.load(source, DetailLevel.SUMMARY).usage.cost_usd.value
-
-    def test_hermes_billed_cost_is_untouched_and_estimate_is_discounted(self):
-        path = self.settings([self.rule("anthropic", "any", 25)])
-        self.assertAlmostEqual(self.hermes_cost(path, "actual", "actual"), 2.0)
-        self.assertAlmostEqual(self.hermes_cost(path, "estimated", "estimated"), 1.5)
-
-    def claude_rows(self, request_id):
-        row = {"type": "assistant", "timestamp": "2026-09-02T10:00:00.000Z", "message": {
-            "id": "msg-1", "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
-            "usage": {"input_tokens": 100_000, "output_tokens": 10_000,
-                      "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0}}}
-        if request_id:
-            row["requestId"] = request_id
-        return [row]
-
-    def claude_fraction(self, path, request_id, client="claude_code"):
-        source = {"id": "c", "path": "/tmp/c.jsonl", "provider": "claude", "client": client, "label": "Claude",
-                  "project": "/repo", "mtime": 1, "title": "t", "model": None}
-        with self.patched(path):
-            row = meter.claude_summary(source, self.claude_rows(request_id))
-        self.assertGreater(row["cost"], 0)
-        return round(row["discount_usd"] / (row["cost"] + row["discount_usd"]), 6)
-
-    def test_claude_channel_follows_request_id_shape_or_declaration(self):
-        uuid = "0b7c0a8e-3f7d-4c55-9b1e-6c2f6d1c9a10"
-        rules = [self.rule("anthropic", "direct", 30), self.rule("anthropic", "bedrock", 15)]
-        path = self.settings(rules)
-        self.assertEqual(self.claude_fraction(path, "req_011abc"), 0.30)
-        self.assertEqual(self.claude_fraction(path, uuid), 0.15)
-        self.assertEqual(self.claude_fraction(path, None), 0.0)
-        any_path = self.settings([*rules, self.rule("anthropic", "any", 5)])
-        self.assertEqual(self.claude_fraction(any_path, None), 0.05)
-        declared = self.settings(rules, runtime_channels={"claude_code": "bedrock"})
-        self.assertEqual(self.claude_fraction(declared, "req_011abc"), 0.15)
-        self.assertEqual(self.claude_fraction(declared, "req_011abc", client="claude_desktop"), 0.30)
-
-    def test_cache_savings_are_discounted_by_the_same_rate(self):
-        execution = {"tokens": {"cache_read": 1_000_000, "fresh_input": 0, "cache_write": 0, "output": 0},
-                     "model": "gpt-5.4", "ts": self.T0, "cost": 0.6, "discount_usd": 0.4}
-        with self.patched(self.settings(rules=None)):
-            listed = meter.cache_savings({}, "codex", "gpt-5.4", [dict(execution, discount_usd=0.0)])
-            plain_now = meter.cache_savings({"cache_read": 1_000_000}, "codex", "gpt-5.4")
-        with self.patched(self.settings([self.rule("openai", "any", 40)])):
-            discounted = meter.cache_savings({}, "codex", "gpt-5.4", [execution])
-            now = meter.cache_savings({"cache_read": 1_000_000}, "codex", "gpt-5.4")
-        self.assertGreater(listed, 0)
-        self.assertAlmostEqual(discounted, listed * 0.6)
-        self.assertAlmostEqual(now, plain_now * 0.6)
-
-    def test_discount_stacks_on_price_override_and_after_modifiers(self):
-        path = self.settings(rules=None)
-        meter.set_model_price("openai", "gpt-custom-1",
-                              {"input": 2, "output": 8, "cache_write": 0, "cache_read": 0.2}, path=str(path),
-                              apply_to_all_history=True)
-        rules = {"version": 1, "rules": [self.rule("openai", "any", 50), self.rule("anthropic", "any", 25)]}
-        data = json.loads(path.read_text())
-        data["cost_discounts"] = rules
-        path.write_text(json.dumps(data))
-        meter._reset_cost_discount_cache()
-        with self.patched(path):
-            override = meter.cost_of(self.CODEX_USAGE, "gpt-custom-1", "codex", at=self.T0)
-            usage = {"input_tokens": 100_000, "output_tokens": 10_000, "speed": "fast", "inference_geo": "us",
-                     "server_tool_use": {"web_search_requests": 3}}
-            fast = meter.cost_of(usage, "claude-opus-5-5", "claude", at=self.T0)
-            plain = meter.cost_of({"input_tokens": 100_000, "output_tokens": 10_000},
-                                  "claude-opus-5-5", "claude", at=self.T0)
-        self.assertAlmostEqual(sum(override.values()), (2 + 0.8) / 2)
-        self.assertGreater(fast.list_usd, plain.list_usd * 2)
-        self.assertAlmostEqual(sum(fast.values()), fast.list_usd * 0.75)
-        self.assertAlmostEqual(sum(fast.values()) + fast.discount_usd, fast.list_usd)
-        self.assertAlmostEqual(fast["server_tools"], 0.03 * 0.75)
-
-    def test_unavailable_and_free_stay_as_they_are(self):
-        with self.patched(self.settings([self.rule("openai", "any", 50)])):
-            unpriced = meter.cost_of(self.CODEX_USAGE, "no-such-model", "codex", at=self.T0)
-            free = meter.cost_of({"input_tokens": 0, "output_tokens": 0}, "gpt-5.4", "codex", at=self.T0)
-            self.assertEqual(meter.discount_amount(None, "openai", "direct", self.T0), (None, 0.0))
-            self.assertEqual(meter.discount_amount(0.0, "openai", "direct", self.T0), (0.0, 0.0))
-            row = self.codex_summary(Path(meter.TOKEN_METER_SETTINGS), ["2026-09-02T10:00:00.000Z"])
-        self.assertEqual((sum(unpriced.values()), unpriced.discount_usd), (0.0, 0.0))
-        self.assertEqual((sum(free.values()), free.discount_usd), (0.0, 0.0))
-        self.assertTrue(row["availability"]["cost"])
-
-    def test_cross_session_aggregates_carry_discount_beside_cost(self):
-        rows = [{
-            "id": "a", "provider": "codex", "runtime": "Codex", "cost": 6.0, "discount_usd": 4.0, "turns": 1,
-            "availability": {"cost": True}, "_model_cost": {"gpt": 6.0}, "_model_discount": {"gpt": 4.0},
-            "_model_tok": {"gpt": 10}, "_day_cost": {"2026-09-01": 2.0, "2026-09-02": 4.0},
-            "_day_discount": {"2026-09-02": 4.0}, "mtime": 1,
-        }, {
-            "id": "b", "provider": "claude", "runtime": "Claude", "cost": 1.0, "discount_usd": 0.0, "turns": 1,
-            "availability": {"cost": True}, "_model_cost": {"opus": 1.0}, "_model_tok": {"opus": 5},
-            "_day_cost": {"2026-09-02": 1.0}, "mtime": 2,
-        }]
-        aggregate = meter._domain_aggregate_cross_session_rows(rows)
-        daily = {row["day"]: row for row in meter.daily_summaries(rows, limit=None)}
-        months = meter.monthly_summaries(rows)
-        spend = meter.spend_projection(list(daily.values()))
-        self.assertEqual((aggregate["total_cost"], aggregate["discount_usd"]), (7.0, 4.0))
-        self.assertEqual({item["model"]: item.get("discount_usd") for item in aggregate["model_mix"]},
-                         {"gpt": 4.0, "opus": None})
-        self.assertEqual(daily["2026-09-02"]["discount_usd"], 4.0)
-        self.assertNotIn("discount_usd", daily["2026-09-01"])
-        self.assertEqual({p["provider"]: p.get("discount_usd") for p in daily["2026-09-02"]["providers"]},
-                         {"codex": 4.0, "claude": None})
-        listed = meter._domain_aggregate_cross_session_rows([rows[1]])
-        self.assertNotIn("discount_usd", listed)
-        self.assertEqual((months[0]["cost"], months[0]["discount_usd"]), (7.0, 4.0))
-        self.assertEqual(sum(day.get("discount_usd", 0.0) for day in spend), 4.0)
-
-    def test_pricing_recalculation_is_single_flight_and_repeats_when_stale(self):
-        calls = []
-        release = threading.Event()
-
-        def runner():
-            calls.append(1)
-            release.wait(5)
-            meter._pricing_state["cache_revision"] = meter.pricing_fingerprint()
-
-        with mock.patch.dict(meter._pricing_recalc, {"running": False, "pending": False}), \
-                mock.patch.dict(meter._pricing_state, {"cache_revision": None}):
-            self.assertEqual(meter.schedule_pricing_recalculation(runner), "scheduled")
-            self.assertEqual(meter.schedule_pricing_recalculation(runner), "scheduled")
-            release.set()
-            meter._pricing_recalc["thread"].join(5)
-            self.assertFalse(meter.pricing_recalculation_running())
-        self.assertEqual(len(calls), 2)
-
-    def test_invalidate_cost_caches_drops_cached_dollars(self):
-        meter._summary_cache["/x"] = {"signature": 1, "row": {}}
-        meter._xsess["data"], meter._xsess["at"] = {"total_cost": 1}, time.time()
-        path = self.settings([self.rule("openai", "any", 5)])
-        with self.patched(path), mock.patch.dict(meter._pricing_state, {"cache_revision": "p_old"}):
-            meter._load_cost_discounts()
-            meter._cost_discount_cache["state"] = dict(meter._cost_discount_cache["state"], revision="stale")
-            meter.invalidate_cost_caches()
-            self.assertNotIn("/x", meter._summary_cache)
-            self.assertIsNone(meter._xsess["data"])
-            self.assertNotEqual(meter._cost_discount_cache["state"]["revision"], "stale")
-            self.assertEqual(meter._pricing_state["cache_revision"], meter.pricing_fingerprint())
-
-
-class LocalServerBindTests(unittest.TestCase):
-    def test_binding_the_local_server_skips_reverse_dns(self):
-        # A stalled resolver must not delay listen(): http.server would call
-        # socket.getfqdn here, which can block for ~35s on some networks.
-        with mock.patch("socket.getfqdn", side_effect=AssertionError("reverse DNS on bind")):
-            server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
-        try:
-            self.assertEqual(server.server_name, "127.0.0.1")
-            self.assertEqual(server.server_port, server.server_address[1])
-        finally:
-            server.server_close()
-
-
-class LocalApiHttpBase(unittest.TestCase):
-    """A loopback server with temp settings and API token for the local API tests."""
-
-    def setUp(self):
-        meter._reset_cost_discount_cache()
-        self.addCleanup(meter._reset_cost_discount_cache)
-        self._tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        self.tmp = Path(self._tmp.name)
-        self.settings = self.tmp / "settings.json"
-        self.token_path = self.tmp / "api-token"
-        self.server = meter.TokenMeterHTTPServer(("127.0.0.1", 0), meter.H)
-        self.port = self.server.server_port
-        thread = threading.Thread(target=self.server.serve_forever, daemon=True)
-        thread.start()
-
-        def stop():
-            self.server.shutdown()
-            self.server.server_close()
-            thread.join(timeout=5)
-        self.addCleanup(stop)
-        self.scheduled = mock.Mock(return_value="scheduled")
-        for patcher in (
-            mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(self.settings)),
-            mock.patch.object(meter, "TOKEN_METER_API_TOKEN", str(self.token_path)),
-            mock.patch.object(meter, "PORT", self.port),
-            mock.patch.object(meter, "schedule_pricing_recalculation", self.scheduled),
-            mock.patch.object(meter, "STATE", {"ok": True, "xsession": {"pricing_revision": "p_old"}}),
-            mock.patch.dict(meter._pricing_recalc, {"running": False, "pending": False}),
-        ):
-            patcher.start()
-            self.addCleanup(patcher.stop)
-        self.token = meter.ensure_api_token()
-
-    def request(self, method, path, body=None, *, bearer=True, action=False, host=None,
-                origin=None, client=None, raw=None, content_type="application/json"):
-        conn = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10)
-        data = raw if raw is not None else (json.dumps(body).encode() if body is not None else b"")
-        headers = {"Host": host or "127.0.0.1:{}".format(self.port)}
-        if data or method == "POST":
-            headers.update({"Content-Type": content_type, "Content-Length": str(len(data))})
-        if bearer:
-            headers["Authorization"] = "Bearer " + (bearer if isinstance(bearer, str) else self.token)
-        if action:
-            headers["X-Token-Meter-Action"] = meter._ACTION_TOKEN
-        if origin:
-            headers["Origin"] = origin
-        if client is not None:
-            headers["X-Token-Meter-Client"] = client
-        conn.putrequest(method, path, skip_host=True)
-        for key, value in headers.items():
-            conn.putheader(key, value)
-        conn.endheaders()
-        if data:
-            conn.send(data)
-        response = conn.getresponse()
-        text = response.read().decode()
-        conn.close()
-        try:
-            return response.status, json.loads(text), text
-        except json.JSONDecodeError:
-            return response.status, None, text
-
-
-
-class CostDiscountHttpTests(LocalApiHttpBase):
-    """The local discount API: Host/Origin gate, tokens, limits, and recalculation."""
-
-    UPSERT = {"ops": [{"op": "upsert", "rule": {"external_id": "sync:o", "price_list": "openai",
-                                                "channel": "any", "percent": 62}}]}
-
-    def test_bearer_and_action_tokens_are_accepted_and_others_refused(self):
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts")[0], 200)
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts", bearer=False, action=True)[0], 200)
-        for bearer in (False, "x" * 43):
-            status, payload, _ = self.request("GET", "/api/v1/cost-discounts", bearer=bearer)
-            self.assertEqual((status, payload), (401, {"ok": False, "error": "Unauthorized."}))
-        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, bearer=False)
-        self.assertEqual(status, 401)
-
-    def test_host_and_origin_must_be_loopback(self):
-        for host in ("evil.example:{}".format(self.port), "127.0.0.1:1", "127.0.0.1"):
-            status, payload, _ = self.request("GET", "/api/v1/cost-discounts", host=host)
-            self.assertEqual((status, payload), (403, {"ok": False, "error": "Forbidden."}))
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts",
-                                      host="localhost:{}".format(self.port))[0], 200)
-        status, _, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, origin="https://evil.example")
-        self.assertEqual(status, 403)
-        self.assertFalse(self.settings.exists())
-
-    def test_limits_and_validation_errors(self):
-        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", raw=b"{" + b" " * 9000 + b"}")
-        self.assertEqual((status, payload["error"]), (413, "Request too large."))
-        self.assertEqual(self.request("POST", "/api/v1/cost-discounts", raw=b"{nope")[0], 400)
-        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [{"op": "upsert", "rule": {
-            "price_list": "openai", "percent": 100}}]})
-        self.assertEqual((status, payload["error"]),
-                         (400, "Discount percent must be more than 0 and less than 100."))
-        self.scheduled.assert_not_called()
-
-    def test_write_records_client_conflicts_and_idempotent_repeat(self):
-        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, client="contract-sync")
-        self.assertEqual(status, 200, payload)
-        self.assertEqual((payload["changed"], payload["recalculation"]), (True, "scheduled"))
-        self.assertEqual(payload["rules"][0]["set_by"], "contract-sync")
-        self.assertEqual(payload["pricing_revision"], meter.pricing_fingerprint())
-        self.assertEqual(self.scheduled.call_count, 1)
-        status, again, _ = self.request("POST", "/api/v1/cost-discounts", self.UPSERT, client="<bad>")
-        self.assertEqual((status, again["changed"], again["recalculation"]), (200, False, "complete"))
-        self.assertEqual(self.scheduled.call_count, 1)
-        status, stale, _ = self.request("POST", "/api/v1/cost-discounts", {
-            "expected_revision": "r_0000000000000000", **self.UPSERT})
-        self.assertEqual((status, stale["revision"]), (409, payload["revision"]))
-        status, other, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [{"op": "upsert", "rule": {
-            "price_list": "anthropic", "percent": 5}}]}, client="<bad>")
-        self.assertEqual(other["rules"][0]["set_by"], "Another tool")
-
-    def test_resolve_endpoint(self):
-        self.request("POST", "/api/v1/cost-discounts", self.UPSERT)
-        status, payload, _ = self.request(
-            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=azure&at=2026-10-01T12:00:00Z")
-        self.assertEqual((status, payload["percent"]), (200, 62))
-        self.assertRegex(payload["rule_id"], r"^d_")
-        status, none, _ = self.request("GET", "/api/v1/cost-discounts/resolve?price_list=cursor&channel=any&at=1")
-        self.assertEqual((status, none["percent"], none["rule_id"]), (200, None, None))
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts/resolve?price_list=google&channel=any")[0], 400)
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=x")[0], 400)
-        self.assertEqual(self.request(
-            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=any&at=2026-10-01")[0], 400)
-
-    def test_rotate_replaces_token_and_old_token_stops_working(self):
-        old = self.token
-        status, payload, text = self.request("POST", "/api/v1/api-token/rotate", raw=b"")
-        self.assertEqual((status, payload), (200, {"ok": True}))
-        new = self.token_path.read_text().strip()
-        self.assertNotEqual(new, old)
-        self.assertNotIn(new, text)
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts", bearer=old)[0], 401)
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts", bearer=new)[0], 200)
-        self.assertEqual(self.request("POST", "/api/v1/api-token/rotate", raw=b"", bearer=False)[0], 401)
-
-    def test_token_file_is_private_and_reused_across_restarts(self):
-        self.assertEqual(self.token_path.stat().st_mode & 0o777, 0o600)
-        self.assertEqual(meter.ensure_api_token(), self.token)
-        os.chmod(self.token_path, 0o644)
-        self.assertEqual(meter.ensure_api_token(), self.token)
-        self.assertEqual(self.token_path.stat().st_mode & 0o777, 0o600)
-
-    def test_token_never_appears_in_dashboard_or_health_payloads(self):
-        with mock.patch.dict(meter._xsess, {"data": {"pricing_revision": "p_old"}, "at": time.time()}), \
-                mock.patch.object(meter, "provider_quota_snapshots", return_value={}):
-            for path in ("/state", "/health", "/menubar", "/api/v1/cost-discounts"):
-                with self.subTest(path=path):
-                    _status, _payload, text = self.request("GET", path)
-                    self.assertNotIn(self.token, text)
-        self.assertNotIn(self.token, json.dumps(meter.health_state()[0]))
-
-    def test_dashboard_alias_needs_the_action_token(self):
-        status, payload, _ = self.request("POST", "/settings/cost-discounts", self.UPSERT)
-        self.assertEqual(status, 403)
-        status, payload, _ = self.request("POST", "/settings/cost-discounts", self.UPSERT,
-                                          bearer=False, action=True)
-        self.assertEqual(status, 200, payload)
-        self.assertEqual((payload["rules"][0]["source"], payload["rules"][0]["set_by"]), ("dashboard", "Settings"))
-
-    def test_health_reports_new_pricing_revision_once_recalculation_completes(self):
-        self.request("POST", "/api/v1/cost-discounts", self.UPSERT)
-        expected = meter.pricing_fingerprint()
-        self.assertEqual(meter.health_state()[0]["pricing_revision"], "p_old")
-        with mock.patch.object(meter, "schedule_pricing_recalculation", _REAL_SCHEDULE), \
-                mock.patch.object(meter, "all_session_sources", return_value=[]), \
-                mock.patch.object(meter, "newest_source", return_value=None), \
-                mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}), \
-                mock.patch.dict(meter._pricing_state, {"cache_revision": None}):
-            meter.schedule_pricing_recalculation()
-            meter._pricing_recalc["thread"].join(30)
-            self.assertFalse(meter.pricing_recalculation_running())
-            # Once the rebuilt snapshot is the one served, health reports its revision.
-            meter.STATE["xsession"] = meter._xsess["data"]
-            self.assertEqual(meter.health_state()[0]["pricing_revision"], expected)
-
-    def test_watcher_reprices_after_a_direct_settings_edit(self):
-        self.settings.write_text(json.dumps({"updates": {"enabled": True}}))
-        meter._reset_cost_discount_cache()
-        with mock.patch.dict(meter._pricing_state, {"cache_revision": meter.pricing_fingerprint()}):
-            self.assertFalse(meter.pricing_watch_tick())
-            self.settings.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [{
-                "id": "d_handedit1", "price_list": "openai", "channel": "any", "percent": 10}]}}))
-            meter._reset_cost_discount_cache()
-            self.assertTrue(meter.pricing_watch_tick())
-        self.scheduled.assert_called_once_with()
-
-
-_REAL_SCHEDULE = meter.schedule_pricing_recalculation
-
-
-class BudgetApiHttpTests(LocalApiHttpBase):
-    """Local tools can read and partially update monthly budgets; session caps stay private."""
-
-    def setUp(self):
-        super().setUp()
-        self.settings.write_text(json.dumps({"budgets": {
-            "allocations": {"claude": 100, "codex": 50},
-            "session_budgets": {"private-session-id": 3},
-        }, "updates": {"enabled": False}}))
-        self.refresh = mock.Mock(return_value={})
-        patcher = mock.patch.object(meter, "refresh_cross_session_state", self.refresh)
-        patcher.start()
-        self.addCleanup(patcher.stop)
-
-    def saved(self):
-        return json.loads(self.settings.read_text())
-
-    def test_gate_matches_the_discount_api(self):
-        self.assertEqual(self.request("GET", "/api/v1/budgets")[0], 200)
-        self.assertEqual(self.request("GET", "/api/v1/budgets", bearer=False, action=True)[0], 200)
-        self.assertEqual(self.request("GET", "/api/v1/budgets", bearer=False)[0], 401)
-        self.assertEqual(self.request("GET", "/api/v1/budgets", bearer="x" * 43)[0], 401)
-        self.assertEqual(self.request("GET", "/api/v1/budgets", host="evil.example:{}".format(self.port))[0], 403)
-        self.assertEqual(self.request("POST", "/api/v1/budgets", {"thresholds": [50]},
-                                      origin="https://evil.example")[0], 403)
-        self.assertEqual(self.request("POST", "/api/v1/budgets", raw=b"{" + b" " * 9000 + b"}")[0], 413)
-        self.assertEqual(self.request("POST", "/api/v1/budgets", raw=b"{nope")[0], 400)
-        self.assertEqual(self.request("POST", "/api/v1/budgets", {"thresholds": [50]},
-                                      content_type="text/plain")[0], 415)
-        self.assertEqual(self.saved()["budgets"]["allocations"], {"claude": 100, "codex": 50})
-
-    def test_get_shape_never_includes_session_budgets(self):
-        status, payload, text = self.request("GET", "/api/v1/budgets")
-        self.assertEqual(status, 200)
-        self.assertEqual(set(payload), {"ok", "revision", "budgets", "runtimes", "limits", "month"})
-        self.assertRegex(payload["revision"], r"^b_[0-9a-f]{16}$")
-        self.assertEqual(set(payload["budgets"]), {"currency", "allocations", "monthly_total", "thresholds",
-                                                   "native_notifications", "default_session_budget"})
-        self.assertEqual(set(payload["budgets"]["allocations"]), set(meter.BUDGET_PROVIDERS))
-        self.assertEqual(payload["budgets"]["monthly_total"], 150)
-        self.assertEqual(payload["runtimes"], list(meter.BUDGET_PROVIDERS))
-        self.assertEqual(payload["limits"], {"max_monthly_budget": meter.MAX_MONTHLY_BUDGET,
-                                             "min_session_budget": meter.MIN_SESSION_BUDGET})
-        self.assertNotIn("private-session-id", text)
-        self.assertNotIn("session_budgets", text)
-
-    def test_month_reports_spend_and_list_spend_from_served_state(self):
-        cross = {"budget": {"month": "2026-10", "spend": 70.0, "partial": True},
-                 "monthly": [{"month": "2026-10", "cost": 70.0, "discount_usd": 30.0}]}
-        with mock.patch.object(meter, "STATE", {"ok": True, "xsession": cross}):
-            payload = self.request("GET", "/api/v1/budgets")[1]
-        self.assertEqual(payload["month"], {"month": "2026-10", "spent": 70.0, "list_spent": 100.0,
-                                            "coverage_partial": True})
-
-    def test_partial_allocation_merge_keeps_other_runtimes_and_session_caps(self):
-        status, payload, _ = self.request("POST", "/api/v1/budgets", {"allocations": {"cursor": 25}},
-                                          client="budget-sync")
-        self.assertEqual(status, 200, payload)
-        self.assertTrue(payload["changed"])
-        self.assertEqual(payload["budgets"]["allocations"]["claude"], 100)
-        self.assertEqual(payload["budgets"]["allocations"]["cursor"], 25)
-        self.assertEqual(payload["budgets"]["monthly_total"], 175)
-        saved = self.saved()
-        self.assertEqual(saved["budgets"]["session_budgets"], {"private-session-id": 3.0})
-        self.assertEqual(saved["updates"], {"enabled": False})
-        self.refresh.assert_called_once_with()
-        self.assertEqual(self.request("GET", "/api/v1/budgets")[1]["revision"], payload["revision"])
-
-    def test_validation_messages(self):
-        cases = (
-            ({"allocations": {"claude": -1}}, "Claude allocation must be between 0 and 100,000,000."),
-            ({"allocations": {"claude": 200_000_000}}, "Claude allocation must be between 0 and 100,000,000."),
-            ({"allocations": {"gemini": 5}}, "Unknown runtime: gemini"),
-            ({"thresholds": [90, 80]}, "Use 1 to 10 unique budget thresholds in increasing order."),
-            ({"thresholds": [0]}, "Budget thresholds must be whole percentages from 1 to 100."),
-            ({"session_budgets": {"x": 1}}, "Unknown field: session_budgets"),
-            ({"monthly_total": 5}, "Unknown field: monthly_total"),
-            ({"native_notifications": "yes"}, "Budget notifications must be on or off."),
-        )
-        before = self.settings.read_text()
-        for body, message in cases:
-            with self.subTest(body=body):
-                status, payload, _ = self.request("POST", "/api/v1/budgets", body)
-                self.assertEqual((status, payload["error"]), (400, message))
-        self.assertEqual(self.settings.read_text(), before)
-        self.refresh.assert_not_called()
-
-    def test_stale_revision_conflicts_and_repeat_is_a_no_op(self):
-        stale = self.request("GET", "/api/v1/budgets")[1]["revision"]
-        first = self.request("POST", "/api/v1/budgets", {"thresholds": [50, 100]})[1]
-        status, conflict, _ = self.request("POST", "/api/v1/budgets", {
-            "expected_revision": stale, "thresholds": [60]})
-        self.assertEqual((status, conflict["revision"]), (409, first["revision"]))
-        mtime = self.settings.stat().st_mtime_ns
-        status, again, _ = self.request("POST", "/api/v1/budgets", {
-            "expected_revision": first["revision"], "thresholds": [50, 100]})
-        self.assertEqual((status, again["changed"], again["revision"]), (200, False, first["revision"]))
-        self.assertEqual(self.settings.stat().st_mtime_ns, mtime)
-        self.assertEqual(self.refresh.call_count, 1)
-
-    def test_budget_status_after_post_reflects_the_new_total(self):
-        with mock.patch.object(meter, "refresh_cross_session_state", _REAL_REFRESH), \
-                mock.patch.object(meter, "all_session_sources", return_value=[]), \
-                mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
-            self.request("POST", "/api/v1/budgets", {"allocations": {"claude": 400}})
-            budget = meter._xsess["data"]["budget"]
-            self.assertEqual(budget["budget"], 450)
-            self.assertTrue(budget["configured"])
-            month = self.request("GET", "/api/v1/budgets")[1]["month"]
-        self.assertEqual(month["spent"], 0.0)
-
-
-_REAL_REFRESH = meter.refresh_cross_session_state
-
-
-class ReviewFixHttpTests(LocalApiHttpBase):
-    """Fixes from the independent security and pricing review (HTTP surface)."""
-
-    RULE = {"op": "upsert", "rule": {"price_list": "openai", "channel": "any", "percent": 10}}
-
-    def test_s1_out_of_range_dates_are_rejected_by_the_api_and_resolve(self):
-        for start in (1e20, "9999-12-31T23:59:59-23:59"):
-            status, payload, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [
-                {"op": "upsert", "rule": {"price_list": "openai", "percent": 5, "start": start}}]})
-            self.assertEqual((status, payload["error"]), (400, "Start date must be between 1970 and 2100."))
-        self.assertEqual(self.request(
-            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=any&at=100000000000000000000")[0], 400)
-        self.assertEqual(self.request(
-            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=any&at=9999-12-31T23:59:59-23:59")[0], 400)
-
-    def test_s1_hand_edited_huge_date_is_ignored_not_fatal(self):
-        self.settings.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [
-            {"id": "d_huge0001", "price_list": "openai", "channel": "any", "percent": 5, "start": 1e20},
-            {"id": "d_fine0001", "price_list": "anthropic", "channel": "any", "percent": 5,
-             "start": "9999-12-31T23:59:59-23:59"},
-        ]}}))
-        meter._reset_cost_discount_cache()
-        view = meter.cost_discount_settings()
-        self.assertEqual((view["rules"], view["invalid_rules"]), ([], 2))
-        with mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
-            self.assertEqual(meter.cross_session(sources=[])["cost_discounts"]["invalid_rules"], 2)
-        self.assertEqual(self.request("GET", "/api/v1/cost-discounts")[0], 200)
-
-    def test_s2_invalid_stored_budgets_are_refused_not_reset(self):
-        stored = {"budgets": {"allocations": {"claude": -5}, "session_budgets": {"sid": 3}}}
-        self.settings.write_text(json.dumps(stored))
-        status, payload, _ = self.request("POST", "/api/v1/budgets", {"allocations": {"codex": 5}})
-        self.assertEqual((status, payload), (409, {"ok": False,
-                         "error": "Stored budgets are invalid; fix them in Token Meter first."}))
-        self.assertEqual(json.loads(self.settings.read_text()), stored)
-
-    def test_s3_deeply_nested_json_is_invalid_json(self):
-        # Whether the parser recurses out depends on the Python version, so force that path.
-        routes = (("/api/v1/cost-discounts", {}), ("/api/v1/budgets", {}),
-                  ("/settings/budgets", {"bearer": False, "action": True}))
-        real_loads = json.loads
-
-        def loads(text, *args, **kwargs):
-            if text in (b"[[1]]", "[[1]]"):
-                raise RecursionError
-            return real_loads(text, *args, **kwargs)
-
-        with mock.patch.object(meter.json, "loads", side_effect=loads):
-            for path, kwargs in routes:
-                with self.subTest(path=path, parser="recursion"):
-                    status, payload, _ = self.request("POST", path, raw=b"[[1]]", **kwargs)
-                    self.assertEqual((status, payload), (400, {"ok": False, "error": "Invalid JSON."}))
-        body = b"[" * 4000 + b"]" * 4000
-        for path, kwargs in routes:
-            with self.subTest(path=path, parser="real"):
-                status, payload, _ = self.request("POST", path, raw=body, **kwargs)
-                self.assertEqual(status, 400)
-                self.assertIn(payload["error"], ("Invalid JSON.", "Send a JSON object with ops.",
-                                                 "Send a JSON object.", "Budget settings must be an object."))
-
-    def test_s4_every_route_requires_the_loopback_host(self):
-        foreign = "rebind.example:{}".format(self.port)
-        with mock.patch.object(meter, "provider_quota_snapshots", return_value={}):
-            for path in ("/state", "/health", "/menubar", "/session?id=x", "/"):
-                with self.subTest(path=path):
-                    status, payload, _ = self.request("GET", path, host=foreign, bearer=False)
-                    self.assertEqual((status, payload), (403, {"ok": False, "error": "Forbidden."}))
-            self.assertEqual(self.request("GET", "/state", bearer=False)[0], 200)
-            self.assertEqual(self.request("GET", "/health", bearer=False,
-                                          host="localhost:{}".format(self.port))[0] in (200, 503), True)
-        status, _, _ = self.request("POST", "/settings/budgets", {"allocations": {}}, host=foreign,
-                                    bearer=False, action=True)
-        self.assertEqual(status, 403)
-        status, _, _ = self.request("HEAD", "/", host=foreign, bearer=False)
-        self.assertEqual(status, 403)
-
-    def test_s5_unknown_top_level_and_op_fields_are_rejected(self):
-        cases = (
-            ({"expected_revison": "r_x", "ops": [self.RULE]}, "Unknown field: expected_revison"),
-            ({"ops": [{**self.RULE, "extra": 1}]}, "Unknown field: extra"),
-            ({"ops": [{"op": "upsert", "rule": {"price_list": "openai", "pct": 5}}]}, "Unknown field: pct"),
-            ({"ops": [{"op": "delete", "id": "d_aaaaaaaa", "price_list": "openai"}]}, "Unknown field: price_list"),
-            ({"ops": [{"op": "replace_scope", "price_list": "openai", "channel": "any", "rules": [],
-                       "force": True}]}, "Unknown field: force"),
-            ({"ops": [{"op": "set_runtime_channels", "claude_cli": "bedrock"}]}, "Unknown field: claude_cli"),
-        )
-        for body, message in cases:
-            with self.subTest(body=body):
-                status, payload, _ = self.request("POST", "/api/v1/cost-discounts", body)
-                self.assertEqual((status, payload["error"]), (400, message))
-        self.assertFalse(self.settings.exists())
-
-    def test_s7_newer_file_version_is_read_only(self):
-        stored = {"cost_discounts": {"version": 2, "rules": [
-            {"id": "d_newer001", "price_list": "openai", "channel": "any", "percent": 20}]}}
-        self.settings.write_text(json.dumps(stored))
-        meter._reset_cost_discount_cache()
-        view = meter.cost_discount_settings()
-        self.assertTrue(view["read_only"])
-        self.assertEqual(len(view["rules"]), 1)
-        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})
-        self.assertEqual((status, payload), (409, {"ok": False, "error": "Discounts were saved by a newer Token Meter."}))
-        self.assertEqual(json.loads(self.settings.read_text()), stored)
-
-
-class DiscountPricingFixture(unittest.TestCase):
-    """Temp settings file with discount rules for pricing behaviour tests."""
-
-    T0 = 1_788_000_000
-
-    def setUp(self):
-        meter._reset_cost_discount_cache()
-        self.addCleanup(meter._reset_cost_discount_cache)
-        self._tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self._tmp.cleanup)
-        self.tmp = Path(self._tmp.name)
-        self.path = self.tmp / "settings.json"
-        patcher = mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(self.path))
-        patcher.start()
-        self.addCleanup(patcher.stop)
-        self.rules()
-
-    def rules(self, *rules):
-        self.path.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [
-            {"id": "d_rule{:04d}".format(index), "price_list": price_list, "channel": channel,
-             "percent": percent, "start": start, "end": None}
-            for index, (price_list, channel, percent, start) in enumerate(rules)]}}))
-        meter._reset_cost_discount_cache()
-
-
-class ReviewFixPricingTests(DiscountPricingFixture):
-    """Fixes from the independent pricing review."""
-
-    def test_p1_hermes_mixed_vendor_rows_are_kept_and_discounted_by_their_own_vendor(self):
-        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
-        db_path = HermesRuntimeAdapterTests._create_store(None, self.tmp, estimated_cost=3.0)
-        con = sqlite3.connect(db_path)
-        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
-        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", [
-            ("hermes-session", "claude-test", "anthropic", 50, 10, 5, 2, 1, 2.0, None, "estimated", "recorded", 1),
-            ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, 1.0, None, "estimated", "recorded", 1),
-        ])
-        con.commit()
-        con.close()
-        self.rules(("anthropic", "any", 25, None))
-        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
-                mock.patch.object(meter, "_hermes_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            summary = meter.hermes_summary(meter.hermes_session_sources()[0])
-        self.assertAlmostEqual(summary["cost"], 2.5)
-        self.assertAlmostEqual(summary["discount_usd"], 0.5)
-        self.assertEqual(len(summary["model_stats"]), 2)
-
-    def test_p2_summary_cache_reprices_when_rules_change_on_disk(self):
-        trace = self.tmp / "s.jsonl"
-        trace.write_text("\n".join(json.dumps(row) for row in (
-            {"type": "turn_context", "timestamp": "2026-09-02T10:00:00.000Z", "payload": {"model": "gpt-5.4"}},
-            {"timestamp": "2026-09-02T10:00:04.000Z", "payload": {"type": "token_count", "info": {
-                "last_token_usage": {"input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}},
-        )) + "\n")
-        source = {"id": "s", "path": str(trace), "provider": "codex", "client": "codex", "label": "Codex",
-                  "project": "/repo", "mtime": 1.0, "title": "t", "model": "gpt-5.4"}
-        with mock.patch.dict(meter._summary_cache, {}, clear=True):
-            listed = meter.session_summary(source)["cost"]
-            time.sleep(0.3)
-            self.rules(("openai", "any", 50, None))
-            meter._cost_discount_cache["checked_at"] = 0.0
-            repriced = meter.session_summary(source)["cost"]
-            state_key = meter.session_state_signature(source)
-        self.assertGreater(listed, 0)
-        self.assertAlmostEqual(repriced, listed * 0.5)
-        self.assertEqual(state_key[-1], meter.pricing_fingerprint())
-
-    def test_p4_cache_savings_without_executions_use_the_session_channel_and_time(self):
-        tot = {"cache_read": 1_000_000}
-        listed = meter.cache_savings(tot, "codex", "gpt-5.4", at=self.T0)
-        self.rules(("openai", "azure", 50, self.T0 - 10))
-        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", channel="azure", at=self.T0), listed * 0.5)
-        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", model_provider="azure", at=self.T0),
-                               listed * 0.5)
-        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", channel="azure", at=self.T0 - 20), listed)
-        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", channel="direct", at=self.T0), listed)
-
-    def test_p6_kiro_session_cost_is_priced_per_turn_across_a_rule_boundary(self):
-        from token_meter.runtimes.kiro import KiroRuntimeAdapter, model_ref_for
-        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
-                                     compatibility=meter._kiro_compatibility())
-        model = model_ref_for("claude-sonnet-4-6")
-        turns = [{"input_tokens": 100_000, "output_tokens": 10_000, "end": self.T0 - 100},
-                 {"input_tokens": 100_000, "output_tokens": 10_000, "end": self.T0 + 100}]
-        listed = adapter._session_cost(model, turns)
-        self.rules(("kiro", "any", 50, self.T0))
-        self.assertAlmostEqual(adapter._session_cost(model, turns), listed * 0.75)
-        source = (Path(meter.__file__).resolve().parent / "token_meter" / "runtimes" / "kiro.py").read_text()
-        self.assertIn("cost = self._session_cost(source.model_ref, turns)", source)
-
-    def test_p7_missing_timestamps_never_take_todays_rate(self):
-        usage = {"input_tokens": 1_000_000, "output_tokens": 0}
-        self.rules(("openai", "any", 50, 100))
-        self.assertEqual(meter.cost_of(usage, "gpt-5.4", "codex", at=None).discount_usd, 0.0)
-        self.assertEqual(meter.discount_amount(1.0, "openai", "direct", None), (1.0, 0.0))
-        self.assertGreater(meter.cost_of(usage, "gpt-5.4", "codex", at=self.T0).discount_usd, 0)
-        self.rules(("openai", "any", 50, None))
-        self.assertAlmostEqual(meter.discount_amount(1.0, "openai", "direct", None)[0], 0.5)
-
-    def test_p3_vertex_claude_sessions_take_the_vertex_rule(self):
-        self.rules(("anthropic", "direct", 30, None), ("anthropic", "vertex", 10, None))
-        row = {"type": "assistant", "timestamp": "2026-09-02T10:00:00.000Z", "requestId": "req_vrtx_011abc",
-               "message": {"id": "m", "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
-                           "usage": {"input_tokens": 100_000, "output_tokens": 10_000,
-                                     "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0}}}
-        source = {"id": "c", "path": "/tmp/c.jsonl", "provider": "claude", "client": "claude_code",
-                  "label": "Claude", "project": "/repo", "mtime": 1, "title": "t", "model": None}
-        summary = meter.claude_summary(source, [row])
-        self.assertAlmostEqual(summary["discount_usd"] / (summary["cost"] + summary["discount_usd"]), 0.10)
-
-
-class ReviewRound2HttpTests(LocalApiHttpBase):
-    """Round-two review fixes on the HTTP surface."""
-
-    RULE = {"op": "upsert", "rule": {"price_list": "openai", "channel": "any", "percent": 10}}
-
-    def test_r1_state_carries_fresh_discounts_while_repricing_serves_the_old_snapshot(self):
-        stale = {"pricing_revision": "p_old", "cost_discounts": {"revision": "r_old", "rules": []}}
-        with mock.patch.object(meter, "STATE", {"ok": True, "xsession": stale}), \
-                mock.patch.dict(meter._pricing_recalc, {"running": True, "pending": False}):
-            written = self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})[1]
-            state = self.request("GET", "/state", bearer=False)[1]
-        self.assertEqual(state["xsession"]["cost_discounts"]["revision"], "r_old")
-        self.assertEqual(state["cost_discounts"]["revision"], written["revision"])
-        self.assertEqual([rule["percent"] for rule in state["cost_discounts"]["rules"]], [10])
-
-    def test_r3_any_version_but_integer_one_is_read_only(self):
-        for version in ("2", 2.0, "1", True, None):
-            with self.subTest(version=version):
-                stored = {"cost_discounts": {"version": version, "rules": []}}
-                self.settings.write_text(json.dumps(stored))
-                meter._reset_cost_discount_cache()
-                self.assertTrue(meter.cost_discount_settings()["read_only"])
-                self.assertEqual(self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})[0], 409)
-                self.assertEqual(json.loads(self.settings.read_text()), stored)
-        self.settings.write_text(json.dumps({"cost_discounts": {"rules": []}}))
-        meter._reset_cost_discount_cache()
-        self.assertFalse(meter.cost_discount_settings()["read_only"])
-
-    def test_r3_invalid_stored_rules_survive_a_write_verbatim(self):
-        broken = {"id": "broken", "percent": 500, "note": "hand edit"}
-        self.settings.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [
-            {"id": "d_keep0001", "price_list": "anthropic", "channel": "any", "percent": 5}, broken]}}))
-        meter._reset_cost_discount_cache()
-        self.assertEqual(self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})[0], 200)
-        rules = json.loads(self.settings.read_text())["cost_discounts"]["rules"]
-        self.assertIn(broken, rules)
-        self.assertEqual(len(rules), 3)
-        meter._reset_cost_discount_cache()
-        view = meter.cost_discount_settings()
-        self.assertEqual((len(view["rules"]), view["invalid_rules"]), (2, 1))
-
-    def test_r4_budgets_get_refuses_invalid_stored_budgets(self):
-        self.settings.write_text(json.dumps({"budgets": {"allocations": {"claude": -5}}}))
-        status, payload, _ = self.request("GET", "/api/v1/budgets")
-        self.assertEqual((status, payload), (409, {"ok": False,
-                         "error": "Stored budgets are invalid; fix them in Token Meter first."}))
-
-
-class ReviewRound2PricingTests(DiscountPricingFixture):
-    """Round-two review fixes on pricing."""
-
-    def codex_source(self, stamps):
-        trace = self.tmp / "codex-{}.jsonl".format(len(list(self.tmp.iterdir())))
-        rows = [{"type": "turn_context", "timestamp": stamps[0], "payload": {"model": "gpt-5.4"}}]
-        rows += [{"timestamp": stamp, "payload": {"type": "token_count", "info": {"last_token_usage": {
-            "input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}} for stamp in stamps]
-        trace.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
-        return {"id": trace.stem, "session": trace.stem, "path": str(trace), "provider": "codex",
-                "client": "codex", "label": "Codex", "project": "/repo", "mtime": 1.0, "title": "t",
-                "model": "gpt-5.4"}
-
-    def test_r2_hermes_partial_model_costs_keep_list_equal_cost_plus_discount(self):
-        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
-        db_path = HermesRuntimeAdapterTests._create_store(None, self.tmp, estimated_cost=3.0)
-        con = sqlite3.connect(db_path)
-        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
-        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", [
-            ("hermes-session", "claude-test", "anthropic", 50, 10, 5, 2, 1, 2.0, None, "estimated", "recorded", 1),
-            ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, None, None, "unknown", "none", 1),
-        ])
-        con.commit()
-        con.close()
-        self.rules(("anthropic", "any", 25, None))
-        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
-                mock.patch.object(meter, "_hermes_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            summary = meter.hermes_summary(meter.hermes_session_sources()[0])
-        self.assertAlmostEqual(summary["cost"] + summary["discount_usd"], 3.0)
-        self.assertAlmostEqual(summary["discount_usd"], 0.5)
-        self.assertAlmostEqual(summary["cost"], 2.5)
-        # Two model rows plus the unattributed list-price share (round three, Q4).
-        self.assertEqual(len(summary["model_stats"]), 3)
-
-    def test_r7_opencode_prices_discounts_and_dates_a_message_with_one_time(self):
-        helper = OpenCodeTests()
-        conn = helper._build_db(self.tmp)
-        row_created = 1_788_000_000_000
-        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
-            helper._session_row("ses_t", "/repo", "Timed", "gpt-5.4", 1.0, 100, 10, 0, 0, 0,
-                                row_created + 86_400_000 * 3, provider_id="openai").values()))
-        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", helper._message("m0", "ses_t", {
-            "role": "assistant", "modelID": "gpt-5.4", "providerID": "openai", "cost": 1.0,
-            "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}}},
-            row_created))
-        conn.commit()
-        conn.close()
-        # Only the row's own creation time dates this message; the rule starts just before it.
-        self.rules(("openai", "any", 50, row_created / 1000 - 10))
-        source = {"provider": "opencode", "id": "ses_t", "model": "gpt-5.4", "label": "OpenCode",
-                  "runtime": "OpenCode", "session": "ses_t", "path": "opencode:ses_t",
-                  "project": "/repo", "title": "Timed", "mtime": 1.0}
-        with mock.patch.object(meter, "OPENCODE_DB", str(self.tmp / "opencode.db")), \
-                mock.patch.object(meter, "_opencode_native_adapters", {}):
-            row = meter.opencode_summary(source)
-            state = meter.recompute_opencode(source)
-        day = time.strftime("%Y-%m-%d", time.localtime(row_created / 1000))
-        self.assertAlmostEqual(row["discount_usd"], 0.5)
-        self.assertAlmostEqual(row["model_stats"][0]["discount_usd"], 0.5)
-        self.assertAlmostEqual(row["_day_cost"][day], 0.5)
-        self.assertAlmostEqual(state["total_cost"], 0.5)
-        self.assertAlmostEqual(state["executions"][0]["discount_usd"], 0.5)
-
-    def test_r7_kiro_prices_discounts_and_dates_a_start_only_turn_alike(self):
-        from token_meter.runtimes.kiro import KiroRuntimeAdapter
-        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
-                                     compatibility=meter._kiro_compatibility())
-        turn = {"index": 1, "input_tokens": 100_000, "output_tokens": 10_000, "start": self.T0 + 100,
-                "end": 0, "tools": (), "model": "claude-sonnet-4-6"}
-        self.rules(("kiro", "any", 50, self.T0))
-        source = {"id": "k", "path": str(self.tmp / "k.jsonl"), "provider": "kiro", "label": "Kiro",
-                  "project": "/repo", "mtime": 1.0, "title": "t", "model": "claude-sonnet-4-6"}
-        with mock.patch.object(adapter, "_legacy_rows", return_value=(turn,)):
-            row = adapter.summarize_legacy(source)
-        day = time.strftime("%Y-%m-%d", time.localtime(self.T0 + 100))
-        self.assertGreater(row["discount_usd"], 0)
-        self.assertAlmostEqual(row["discount_usd"], row["cost"])
-        self.assertAlmostEqual(row["_day_cost"][day], row["cost"])
-
-    def test_r8_whole_second_utc_stamps_parse_and_take_dated_rules(self):
-        self.assertEqual(meter.parse_iso("2026-10-29T12:00:00Z"), meter.parse_iso("2026-10-29T12:00:00.000Z"))
-        self.assertEqual(meter.parse_iso("2026-10-29T12:00:00+00:00"), 1793275200)
-        self.assertIsNone(meter.parse_iso("not a time"))
-        for value in (None, 1790000000, 1790000000.5, True, ""):
-            with self.subTest(value=value):
-                self.assertIsNone(meter.parse_iso(value))
-        numeric = self.codex_rows_for("2026-10-29T12:00:00Z")
-        numeric[0]["timestamp"] = 1790000000
-        meter.codex_summary(self.codex_source(["2026-10-29T12:00:00Z"]), numeric)
-        self.rules(("openai", "any", 50, meter.parse_iso("2026-10-01T00:00:00")))
-        for stamp in ("2026-10-29T12:00:00Z", "2026-10-29T12:00:00.250Z"):
-            with self.subTest(stamp=stamp):
-                row = meter.codex_summary(self.codex_source([stamp]), self.codex_rows_for(stamp))
-                self.assertAlmostEqual(row["discount_usd"], row["cost"])
-
-    def codex_rows_for(self, stamp):
-        return [{"type": "turn_context", "timestamp": stamp, "payload": {"model": "gpt-5.4"}},
-                {"timestamp": stamp, "payload": {"type": "token_count", "info": {"last_token_usage": {
-                    "input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}}]
-
-    def test_r9_build_state_cache_fallback_uses_the_claude_session_channel(self):
-        tot = {"input": 0, "cache_write": 0, "cache_read": 1_000_000, "output": 0}
-        cost = {"input": 0.0, "cache_write": 0.0, "cache_read": 0.0, "output": 0.0}
-        listed = meter.cache_block(tot, cost, [], "claude", "claude-sonnet-4-6", at=self.T0)["saved"]
-        self.rules(("anthropic", "bedrock", 40, None))
-        saved = meter.cache_block(tot, cost, [], "claude", "claude-sonnet-4-6",
-                                  channel="bedrock", at=self.T0)["saved"]
-        self.assertAlmostEqual(saved, listed * 0.6)
-        captured = []
-        real_build_state = meter.build_state
-
-        def capture(source, *args, **kwargs):
-            captured.append(dict(source))
-            return real_build_state(source, *args, **kwargs)
-        trace = self.tmp / "claude.jsonl"
-        trace.write_text(json.dumps({
-            "type": "assistant", "timestamp": "2026-09-02T10:00:00.000Z",
-            "requestId": "0b7c0a8e-3f7d-4c55-9b1e-6c2f6d1c9a10",
-            "message": {"id": "m", "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
-                        "usage": {"input_tokens": 10, "output_tokens": 5, "cache_creation_input_tokens": 0,
-                                  "cache_read_input_tokens": 1000}}}) + "\n")
-        with mock.patch.object(meter, "build_state", side_effect=capture):
-            adapter = meter.ClaudeRuntimeAdapter(str(self.tmp), (), compatibility=meter._claude_compatibility())
-            adapter.recompute_legacy({"id": "c", "session": "c", "path": str(trace), "provider": "claude",
-                                      "client": "claude_code",
-                                      "label": "Claude", "project": "/repo", "mtime": 1.0, "title": "t"})
-        self.assertEqual(captured[0]["discount_channel"], "bedrock")
-
-    def test_r9_kiro_load_prices_each_turn_at_its_own_time(self):
-        from token_meter.contracts import DetailLevel
-        from token_meter.runtimes.kiro import KiroRuntimeAdapter
-        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
-                                     compatibility=meter._kiro_compatibility())
-        path = self.tmp / "messages.jsonl"
-        path.write_text("")
-        source = adapter._source_from_legacy({"id": "k", "path": str(path), "model": "claude-sonnet-4-6",
-                                              "mtime": 1.0, "label": "Kiro", "project": "/repo"})
-        turns = tuple({"index": index + 1, "input_tokens": 100_000, "output_tokens": 10_000,
-                       "start": stamp - 5, "end": stamp, "tools": ()}
-                      for index, stamp in enumerate((self.T0 - 100, self.T0 + 100)))
-        parsed = {"turns": turns, "corrupt": 0, "available": True, "truncated": False, "recognized": True}
-        with mock.patch.object(adapter, "_parsed", return_value=parsed):
-            listed = adapter.load(source, DetailLevel.SUMMARY).usage.cost_usd.value
-            self.rules(("kiro", "any", 50, self.T0))
-            discounted = adapter.load(source, DetailLevel.SUMMARY).usage.cost_usd.value
-        self.assertGreater(listed, 0)
-        self.assertAlmostEqual(discounted, listed * 0.75)
-
-    def test_r9_detail_state_is_repriced_when_rules_change(self):
-        source = self.codex_source(["2026-09-02T10:00:00.000Z"])
-        with mock.patch.dict(meter._session_state_cache, {}, clear=True):
-            listed = meter.cached_session_state(source)["total_cost"]
-            time.sleep(0.3)
-            self.rules(("openai", "any", 50, None))
-            meter._cost_discount_cache["checked_at"] = 0.0
-            repriced = meter.cached_session_state(source)["total_cost"]
-        self.assertGreater(listed, 0)
-        self.assertAlmostEqual(repriced, listed * 0.5)
-
-    def test_r9_budget_status_session_cap_and_spend_goal_use_the_discounted_cost(self):
-        from token_meter.services import goals as goal_service
-        source = self.codex_source(["2026-09-02T10:00:00.000Z"])
-        self.rules(("openai", "any", 50, None))
-        row = meter.codex_summary(source, self.codex_rows_for("2026-09-02T10:00:00.000Z"))
-        self.assertGreater(row["discount_usd"], 0)
-        when = datetime.datetime(2026, 9, 15, 12).astimezone()
-        status = meter.monthly_budget_status(meter.monthly_summaries([row]),
-                                             {"allocations": {"codex": 100}}, now=when)
-        self.assertAlmostEqual(status["spend"], row["cost"])
-        state = meter.recompute(source)
-        with mock.patch.dict(meter._xsess, {"sessions": []}):
-            cap = meter.session_budget_snapshot(source, state, {"default_session_budget": 10})
-        self.assertAlmostEqual(cap["spend_usd"], round(row["cost"], 4))
-        goal = goal_service.measure("spend", {"kind": "all", "key": ""}, "2026-09-01", "2026-09-30",
-                                    [row], meter.metric_available)
-        self.assertAlmostEqual(goal["value"], row["cost"])
-
-
-class ReviewRound3Tests(DiscountPricingFixture):
-    """Round-three review fixes."""
-
-    def store(self, rules, **extra):
-        self.path.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": rules}, **extra}))
-        meter._reset_cost_discount_cache()
-
-    CLASH = [
-        {"id": "d_keep0001", "price_list": "anthropic", "channel": "direct", "percent": 30},
-        {"id": "d_clash001", "price_list": "anthropic", "channel": "direct", "percent": 20, "start": 100},
-    ]
-
-    def saved_rules(self):
-        return json.loads(self.path.read_text())["cost_discounts"]["rules"]
-
-    def test_q1_clashing_entry_never_resurrects_after_delete(self):
-        self.store(self.CLASH)
-        self.assertEqual(meter.cost_discount_settings()["invalid_rules"], 1)
-        result = meter.apply_cost_discount_ops([{"op": "delete", "id": "d_keep0001"}])
-        self.assertTrue(result["ok"], result)
-        self.assertEqual(self.saved_rules(), [])
-        meter._reset_cost_discount_cache()
-        view = meter.cost_discount_settings()
-        self.assertEqual((view["rules"], view["invalid_rules"]), ([], 0))
-        self.assertEqual(view["revision"], result["revision"])
-
-    def test_q1_replace_scope_clears_the_scope_without_resurrecting(self):
-        self.store(self.CLASH)
-        result = meter.apply_cost_discount_ops(
-            [{"op": "replace_scope", "price_list": "anthropic", "channel": "direct", "rules": []}])
-        self.assertEqual(self.saved_rules(), [])
-        meter._reset_cost_discount_cache()
-        self.assertEqual(meter.cost_discount_settings()["rules"], [])
-        self.assertEqual(meter.cost_discount_settings()["revision"], result["revision"])
-
-    def test_q1_write_revision_equals_the_next_read_with_preserved_invalid_entries(self):
-        malformed = {"id": "d_bad00001", "price_list": "anthropic", "channel": "any", "percent": 500}
-        self.store([self.CLASH[0], malformed, self.CLASH[1]])
-        result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}])
-        self.assertIn(malformed, self.saved_rules())
-        self.assertNotIn(self.CLASH[1], self.saved_rules())
-        meter._reset_cost_discount_cache()
-        view = meter.cost_discount_settings()
-        self.assertEqual(view["revision"], result["revision"])
-        self.assertEqual(view["invalid_rules"], 1)
-
-    def test_q1_deleting_or_replacing_an_invalid_entry_clears_the_count(self):
-        malformed = {"id": "d_bad00001", "price_list": "anthropic", "channel": "any", "percent": 500}
-        self.store([malformed])
-        result = meter.apply_cost_discount_ops([{"op": "delete", "id": "d_bad00001"}])
-        self.assertTrue(result["changed"])
-        self.assertEqual(self.saved_rules(), [])
-        meter._reset_cost_discount_cache()
-        self.assertEqual(meter.cost_discount_settings()["invalid_rules"], 0)
-        self.store([malformed])
-        meter.apply_cost_discount_ops([{"op": "replace_scope", "price_list": "anthropic", "channel": "any", "rules": []}])
-        self.assertEqual(self.saved_rules(), [])
-
-    def test_q5_non_object_or_non_list_shapes_are_read_only(self):
-        for stored in ({"cost_discounts": "30% off"}, {"cost_discounts": {"version": 1, "rules": "x"}},
-                       {"cost_discounts": ["rule"]}):
-            with self.subTest(stored=stored):
-                self.path.write_text(json.dumps(stored))
-                meter._reset_cost_discount_cache()
-                self.assertTrue(meter.cost_discount_settings()["read_only"])
-                result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}])
-                self.assertTrue(result.get("newer_version"), result)
-                self.assertEqual(json.loads(self.path.read_text()), stored)
-                body, status = meter.cost_discount_write({"ops": [{"op": "delete", "id": "d_x0000000"}]}, "api", "x")
-                self.assertEqual(status, 409)
-
-    def hermes(self, session_status, rows):
-        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
-        root = self.tmp / "hermes-{}".format(len(list(self.tmp.iterdir())))
-        root.mkdir()
-        db_path = HermesRuntimeAdapterTests._create_store(None, root, estimated_cost=3.0)
-        con = sqlite3.connect(db_path)
-        if session_status == "actual":
-            con.execute("UPDATE sessions SET actual_cost_usd=3.0, estimated_cost_usd=NULL, cost_status='actual'")
-        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
-        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", rows)
-        con.commit()
-        con.close()
-        self.rules(("anthropic", "any", 25, None))
-        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
-                mock.patch.object(meter, "_hermes_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            return meter.hermes_summary(meter.hermes_session_sources()[0])
-
-    ROWS = [
-        ("hermes-session", "claude-test", "anthropic", 50, 10, 5, 2, 1, 2.0, None, "estimated", "recorded", 1),
-        ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, 1.0, None, "estimated", "recorded", 1),
-    ]
-
-    def test_q2_billed_hermes_session_is_never_discounted(self):
-        for rows in (self.ROWS, [self.ROWS[0], (*self.ROWS[1][:8], None, None, "unknown", "none", 1)]):
-            with self.subTest(rows=len([row for row in rows if row[8] is not None])):
-                summary = self.hermes("actual", rows)
-                self.assertAlmostEqual(summary["cost"], 3.0)
-                self.assertEqual(summary["discount_usd"], 0.0)
-                self.assertEqual(sum(row["discount_usd"] for row in summary["model_stats"]), 0.0)
-                self.assertAlmostEqual(sum(summary["_model_cost"].values()), 3.0)
-
-    def test_q4_unpriced_share_is_a_model_row_and_inconsistent_rows_fall_back(self):
-        partial = self.hermes("estimated", [self.ROWS[0], (*self.ROWS[1][:8], None, None, "unknown", "none", 1)])
-        self.assertAlmostEqual(partial["cost"], 2.5)
-        self.assertAlmostEqual(sum(partial["_model_cost"].values()), partial["cost"])
-        self.assertAlmostEqual(sum(row["cost"] for row in partial["model_stats"]), partial["cost"])
-        self.assertIn(hermes_runtime.UNATTRIBUTED_MODEL_KEY, partial["_model_cost"])
-        over = self.hermes("estimated", [(*self.ROWS[0][:8], 4.0, None, "estimated", "recorded", 1),
-                                         (*self.ROWS[1][:8], None, None, "unknown", "none", 1)])
-        self.assertAlmostEqual(over["cost"] + over["discount_usd"], 3.0)
-        self.assertAlmostEqual(over["cost"], 2.25)
-        self.assertAlmostEqual(sum(over["_model_cost"].values()), over["cost"])
-
-    def test_q6_opencode_summary_leaves_a_timeless_message_undated(self):
-        helper = OpenCodeTests()
-        conn = helper._build_db(self.tmp)
-        timed = 1_788_000_000_000
-        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
-            helper._session_row("ses_u", "/repo", "Undated", "gpt-5.4", 2.0, 200, 20, 0, 0, 0,
-                                timed + 86_400_000 * 5, provider_id="openai").values()))
-        message = {"role": "assistant", "modelID": "gpt-5.4", "providerID": "openai", "cost": 1.0,
-                   "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}}}
-        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)",
-                     ("m0", "ses_u", timed, timed, json.dumps({**message, "time": {"created": timed}})))
-        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", ("m1", "ses_u", None, None, json.dumps(message)))
-        conn.commit()
-        conn.close()
-        source = {"provider": "opencode", "id": "ses_u", "model": "gpt-5.4", "label": "OpenCode",
-                  "runtime": "OpenCode", "session": "ses_u", "path": "opencode:ses_u",
-                  "project": "/repo", "title": "Undated", "mtime": 1.0}
-        with mock.patch.object(meter, "OPENCODE_DB", str(self.tmp / "opencode.db")), \
-                mock.patch.object(meter, "_opencode_native_adapters", {}):
-            row = meter.opencode_summary(source)
-        self.assertEqual(set(row["_day_cost"]), {time.strftime("%Y-%m-%d", time.localtime(timed / 1000))})
-
-    def test_q6_build_state_passes_the_session_channel_and_last_time_to_the_cache_block(self):
-        tot = {"input": 0, "cache_write": 0, "cache_read": 1_000_000, "output": 0}
-        cost = {"input": 0.0, "cache_write": 0.0, "cache_read": 0.0, "output": 0.0}
-
-        def saved(channel, last_ts):
-            source = {"id": "c", "session": "c", "path": "/tmp/c.jsonl", "provider": "claude",
-                      "label": "Claude", "project": "/repo", "discount_channel": channel}
-            state = meter.build_state(
-                source, tot, cost, 1_000_000, 0.0, [], [], [],
-                {"reasoning": 0, "output": 0, "retrieval": 0, "coordination": 0}, {}, [],
-                last_ts - 10, last_ts, 0, None, 0, False, "claude-sonnet-4-6", "")
-            return state["cache"]["saved"]
-        listed = saved("bedrock", self.T0 + 10)
-        self.rules(("anthropic", "bedrock", 40, self.T0))
-        self.assertAlmostEqual(saved("bedrock", self.T0 + 10), listed * 0.6)
-        self.assertAlmostEqual(saved("direct", self.T0 + 10), listed)
-        self.assertAlmostEqual(saved("bedrock", self.T0 - 100), listed)
-
-
-from token_meter.runtimes import hermes as hermes_runtime
-
-
-class ReviewRound4Tests(DiscountPricingFixture):
-    """Round-four minor fixes."""
-
-    hermes = ReviewRound3Tests.hermes
-    ROWS = ReviewRound3Tests.ROWS
-    UNPRICED = ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, None, None, "unknown", "none", 1)
-
-    def test_1_list_and_dict_timestamps_never_fail_a_build(self):
-        codex = self.tmp / "codex.jsonl"
-        codex.write_text("\n".join(json.dumps(row) for row in (
-            {"type": "turn_context", "timestamp": ["2026"], "payload": {"model": "gpt-5.4"}},
-            {"timestamp": {"at": 1}, "payload": {"type": "token_count", "info": {"last_token_usage": {
-                "input_tokens": 100, "output_tokens": 10, "total_tokens": 110}}}},
-            {"timestamp": "2026-09-02T10:00:00Z", "payload": {"type": "token_count", "info": {"last_token_usage": {
-                "input_tokens": 100, "output_tokens": 10, "total_tokens": 110}}}},
-        )) + "\n")
-        claude = self.tmp / "claude.jsonl"
-        claude.write_text("\n".join(json.dumps({
-            "type": "assistant", "timestamp": stamp, "message": {
-                "id": "m{}".format(index), "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
-                "usage": {"input_tokens": 10, "output_tokens": 5, "cache_creation_input_tokens": 0,
-                          "cache_read_input_tokens": 0}}})
-            for index, stamp in enumerate((["x"], {"y": 1}, "2026-09-02T10:00:00Z"))) + "\n")
-        sources = [
-            {"id": "cx", "session": "cx", "path": str(codex), "provider": "codex", "client": "codex",
-             "label": "Codex", "project": "/repo", "mtime": 1.0, "title": "t", "model": "gpt-5.4"},
-            {"id": "cl", "session": "cl", "path": str(claude), "provider": "claude", "client": "claude_code",
-             "label": "Claude", "project": "/repo", "mtime": 1.0, "title": "t"},
-        ]
-        self.assertIsNone(meter.parse_iso(["2026"]))
-        self.assertIsNone(meter.parse_iso({"at": 1}))
-        with mock.patch.dict(meter._summary_cache, {}, clear=True), \
-                mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
-            rows = [meter.session_summary(source) for source in sources]
-            cross = meter.cross_session(sources=sources)
-        self.assertEqual([row["turns"] for row in rows], [2, 3])
-        self.assertEqual(cross["total_sessions"], 2)
-
-    def test_2_billed_session_with_an_oversized_estimate_row_falls_back(self):
-        summary = self.hermes("actual", [(*self.ROWS[0][:8], 4.0, None, "estimated", "recorded", 1), self.UNPRICED])
-        self.assertAlmostEqual(summary["cost"], 3.0)
-        self.assertEqual(summary["discount_usd"], 0.0)
-        self.assertAlmostEqual(sum(row["cost"] for row in summary["model_stats"]), 3.0)
-        aggregate = meter._domain_aggregate_cross_session_rows([summary])
-        self.assertAlmostEqual(aggregate["total_cost"], summary["cost"])
-
-    def test_3_leftover_cost_is_a_keyed_row_that_the_models_page_keeps(self):
-        for rows in ([self.ROWS[0], self.UNPRICED],
-                     [self.ROWS[0], self.UNPRICED,
-                      ("hermes-session", "gpt-5.4-mini", "openai", 0, 0, 0, 0, 0, None, None, "unknown", "none", 1)]):
-            with self.subTest(unpriced=len(rows) - 1):
-                summary = self.hermes("estimated", rows)
-                gpt = [row for row in summary["model_stats"] if row["model"].endswith(":gpt-5.4")]
-                # The unpriced row stays uncovered (see test_mixed_model_cost_keeps_unknown_model_uncovered).
-                self.assertEqual(gpt[0]["cost"], 0.0)
-                self.assertFalse(gpt[0]["availability"]["cost"])
-                self.assertAlmostEqual(summary["_model_cost"][hermes_runtime.UNATTRIBUTED_MODEL_KEY], 1.0)
-                self.assertNotIn("unknown-model", summary["_model_cost"])
-                self.assertAlmostEqual(sum(summary["_model_cost"].values()), summary["cost"])
-                models = meter.aggregate_model_stats([summary])["models"]
-                self.assertAlmostEqual(sum(float(row.get("cost") or 0) for row in models), summary["cost"])
-                self.assertTrue(any(row["model"] == hermes_runtime.UNATTRIBUTED_MODEL_KEY for row in models))
-
-    def test_4_one_tolerance_for_reconciliation_and_leftover(self):
-        self.assertEqual(hermes_runtime.COST_TOLERANCE, 1e-9)
-        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
-        root = self.tmp / "tiny"
-        root.mkdir()
-        db_path = HermesRuntimeAdapterTests._create_store(None, root, estimated_cost=2.0000000005)
-        con = sqlite3.connect(db_path)
-        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
-        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                        [self.ROWS[0], self.UNPRICED])
-        con.commit()
-        con.close()
-        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
-                mock.patch.object(meter, "_hermes_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            summary = meter.hermes_summary(meter.hermes_session_sources()[0])
-        gpt = [row for row in summary["model_stats"] if row["model"].endswith(":gpt-5.4")]
-        self.assertEqual(gpt[0]["cost"], 0.0)
-        self.assertFalse(gpt[0]["availability"]["cost"])
-
-    def hermes_session(self, estimated_cost, rows):
-        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
-        root = self.tmp / "hermes-{}".format(len(list(self.tmp.iterdir())))
-        root.mkdir()
-        db_path = HermesRuntimeAdapterTests._create_store(None, root, estimated_cost=estimated_cost)
-        con = sqlite3.connect(db_path)
-        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
-        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", rows)
-        con.commit()
-        con.close()
-        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
-                mock.patch.object(meter, "_hermes_native_adapters", {}), \
-                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
-            return meter.hermes_summary(meter.hermes_session_sources()[0])
-
-    def test_leftover_row_never_collides_with_a_fully_unknown_usage_row(self):
-        unknown = ("hermes-session", None, None, 50, 10, 5, 3, 1, None, None, "unknown", "none", 1)
-        summary = self.hermes_session(3.0, [self.ROWS[0], unknown])
-        real_key = "unknown-model-provider:unknown-billing-route:unknown-model"
-        self.assertNotEqual(hermes_runtime.UNATTRIBUTED_MODEL_KEY, real_key)
-        real = [row for row in summary["model_stats"] if row["model"] == real_key]
-        self.assertEqual(len(real), 1)
-        self.assertEqual(real[0]["cost"], 0.0)
-        self.assertFalse(real[0]["availability"]["cost"])
-        self.assertNotIn(real_key, summary["_model_cost"])
-        self.assertAlmostEqual(summary["_model_cost"][hermes_runtime.UNATTRIBUTED_MODEL_KEY], 1.0)
-        models = meter.aggregate_model_stats([summary])["models"]
-        self.assertTrue(any(row["model"] == hermes_runtime.UNATTRIBUTED_MODEL_KEY and row["cost"] > 0
-                            for row in models))
-
-    def test_leftover_row_threshold_is_the_shared_cost_tolerance(self):
-        # A leftover below 1e-9 is rounding, not cost; above it, it is a row. Fails at 1e-12.
-        below = self.hermes_session(2.0 + 5e-10, [self.ROWS[0], self.UNPRICED])
-        above = self.hermes_session(2.0 + 5e-9, [self.ROWS[0], self.UNPRICED])
-        self.assertNotIn(hermes_runtime.UNATTRIBUTED_MODEL_KEY, below["_model_cost"])
-        self.assertIn(hermes_runtime.UNATTRIBUTED_MODEL_KEY, above["_model_cost"])
-
-    def test_5_non_object_entries_are_dropped_and_messages_name_the_reason(self):
-        malformed = {"id": "d_bad00001", "price_list": "anthropic", "percent": 500}
-        self.path.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": ["junk", 5, None, malformed]}}))
-        meter._reset_cost_discount_cache()
-        self.assertEqual(meter.cost_discount_settings()["invalid_rules"], 4)
-        meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}])
-        stored = json.loads(self.path.read_text())["cost_discounts"]["rules"]
-        self.assertEqual([entry for entry in stored if entry.get("percent") == 500], [malformed])
-        self.assertEqual(len(stored), 2)
-        for version, message in (("2", "Discounts in settings.json can't be changed by this version."),
-                                 (2, "Discounts were saved by a newer Token Meter.")):
-            with self.subTest(version=version):
-                self.path.write_text(json.dumps({"cost_discounts": {"version": version, "rules": []}}))
-                meter._reset_cost_discount_cache()
-                body, status = meter.cost_discount_write({"ops": [{"op": "delete", "id": "d_x0000000"}]}, "api", "x")
-                self.assertEqual((status, body["error"]), (409, message))
-        self.path.write_text(json.dumps({"cost_discounts": "off"}))
-        meter._reset_cost_discount_cache()
-        self.assertEqual(meter.cost_discount_settings()["read_only_reason"], "unsupported_format")
-
-
-class ReviewRound4PageTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        root = Path(meter.__file__).resolve().parent
-        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
-        cls.design = (root / "specs" / "2026-10-29-cost-discounts-design.md").read_text(encoding="utf-8")
-
-    def test_5_card_names_the_read_only_reason(self):
-        self.assertIn("discountSettings?.read_only_reason==='newer_version'", self.page)
-        self.assertIn("\"Discounts in settings.json can't be changed by this version.\"", self.page)
-
-    def test_6_clearing_the_add_row_resumes_live_renders(self):
-        self.assertIn("$('discount-form').addEventListener('input',()=>{discountFormDirty=discountAddRowHasInput();});",
-                      self.page)
-        start = self.page.index("function discountAddRowHasInput(){")
-        end = self.page.index("$('discount-form').addEventListener", start)
-        script = ("const fields={'d-pct':{value:''},'d-start':{value:''},'d-end':{value:''},'d-note':{value:'  '}};"
-                  "const $=id=>fields[id];" + self.page[start:end].replace("const DISCOUNT_ADD_FIELDS", "var DISCOUNT_ADD_FIELDS") +
-                  "const empty=discountAddRowHasInput();fields['d-pct'].value='30';const typed=discountAddRowHasInput();"
-                  "fields['d-pct'].value='';console.log([empty,typed,discountAddRowHasInput()].join(','))")
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        self.assertEqual(result.stdout.strip(), "false,true,false")
-
-    def test_7_design_doc_states_what_a_save_keeps(self):
-        self.assertIn("a malformed object entry (bad type, enum, date, or percent) is kept verbatim, while "
-                      "non-object, duplicate, clashing, and over-limit entries are discarded", self.design)
-
-
-class ReviewRound3PageTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
-
-    def test_q3_first_render_happens_even_when_the_percent_field_has_focus(self):
-        self.assertIn("if(xs?.cost_discounts&&!discountEditInProgress())renderDiscounts(xs.cost_discounts);", self.page)
-        opener = self.page[self.page.index("function openDiscounts(){"):]
-        self.assertLess(opener.index("renderDiscounts(settings)"), opener.index("$('d-pct').focus("))
-        self.assertIn("else if(!discountEditInProgress())renderDiscounts(state.cost_discounts);", self.page)
-        start = self.page.index("function discountEditInProgress(){")
-        logic = self.page[start:self.page.index("}", start) + 1]
-        script = ("let discountFormDirty=false,discountSettings={rules:[]};const $=()=>({});"
-                  "const viewInteractionActive=()=>true;" + logic +
-                  "const first=discountEditInProgress();discountFormDirty=true;const typed=discountEditInProgress();"
-                  "discountSettings=null;console.log([first,typed,discountEditInProgress()].join(','))")
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        self.assertEqual(result.stdout.strip(), "false,true,false")
-
-
-class ReviewRound2PageAndDocsTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        root = Path(meter.__file__).resolve().parent
-        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
-        cls.docs = {name: (root / "specs" / name).read_text(encoding="utf-8")
-                    for name in ("ARCHITECTURE.md", "LOCAL-API.md", "2026-10-29-cost-discounts-design.md")}
-
-    def test_r1_editor_prefers_fresh_discounts_and_rereads_after_a_conflict(self):
-        self.assertIn(" if(state.xsession)state.xsession.cost_discounts=state.cost_discounts;", self.page)
-        self.assertEqual(self.page.count("adoptFreshDiscounts(state);LATEST=state;"), 2)
-        self.assertIn("if(response.status===409)await reloadDiscounts();", self.page)
-        self.assertIn("fetch('/api/v1/cost-discounts',{headers:{'X-Token-Meter-Action':token},cache:'no-store'})",
-                      self.page)
-
-    def test_r5_status_region_focus_after_remove_and_read_only_selects(self):
-        self.assertIn("<div class=discountCue id=discount-cue role=status hidden></div>", self.page)
-        self.assertNotIn("discountCueText role=status", self.page)
-        self.assertIn("(next||$('discount-title')).focus({preventScroll:true});", self.page)
-        self.assertIn("select.disabled=readOnly;", self.page)
-
-    def test_r6_docs_describe_the_server_wide_host_check_and_vertex_ids(self):
-        self.assertIn("This applies to every Token Meter route", self.docs["LOCAL-API.md"])
-        self.assertIn("custom `TOKEN_METER_URL`", self.docs["LOCAL-API.md"])
-        self.assertIn("Every HTTP route, including the dashboard page", self.docs["ARCHITECTURE.md"])
-        self.assertIn("`req_vrtx_…` means `vertex`", self.docs["ARCHITECTURE.md"])
-        self.assertNotIn("the file is never rewritten on read |", self.docs["2026-10-29-cost-discounts-design.md"])
-
-
-class ReviewFixPageTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
-
-    def test_s6_live_refresh_keeps_the_notice_and_card_stable_and_accessible(self):
-        # Round two moved role=status back to the stable container (see R5).
-        self.assertIn("<div class=discountCue id=discount-cue role=status hidden></div>", self.page)
-        self.assertIn("if(signature===discountCueSignature)return;", self.page)
-        self.assertIn("if(signature!==discountCardSignature){", self.page)
-        self.assertIn("restoreDiscountFocus(focus);", self.page)
-        self.assertIn('aria-label="${esc(`Remove ${discountRuleName(rule)}`)}"', self.page)
-        self.assertIn("return `${(DISCOUNT_LISTS[rule.price_list]||[rule.price_list])[0]} ${rule.percent}% discount`;",
-                      self.page)
-        self.assertIn('id=discount-invalid hidden', self.page)
-        self.assertIn("saved ${invalid===1?'discount is':'discounts are'} invalid and ignored", self.page)
-
-    def test_s6_remove_label_names_the_discount(self):
-        start = self.page.index("function discountRuleName(rule){")
-        script = ("const DISCOUNT_LISTS={openai:['OpenAI','codex']};"
-                  + self.page[start:self.page.index("function renderDiscounts", start)]
-                  + "console.log(`Remove ${discountRuleName({price_list:'openai',percent:62})}`)")
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        self.assertEqual(result.stdout.strip(), "Remove OpenAI 62% discount")
-
-
-class CostDiscountPageTests(unittest.TestCase):
-    """The Spend page carries the approved Discounts notice and card."""
-
-    @classmethod
-    def setUpClass(cls):
-        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
-        if "id=spend-discounts" not in cls.page:
-            cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
-
-    def section(self, start, end):
-        begin = self.page.index(start)
-        return self.page[begin:self.page.index(end, begin)]
-
-    def test_route_and_palette_entry_keep_existing_budget_routes(self):
-        self.assertIn("h==='spend-budgets'||h==='spend-discounts'||h==='settings-budgets'||h==='budgets'", self.page)
-        self.assertIn("if(h==='spend-discounts')openDiscounts();", self.page)
-        self.assertIn("{id:'spend-discounts',label:'Spend · Discounts',", self.page)
-        self.assertIn("route:'spend-discounts'", self.page)
-        self.assertIn("{id:'spend-budgets',label:'Spend · Monthly budget'", self.page)
-
-    def test_notice_sits_in_the_budget_card_with_the_approved_copy(self):
-        lead = self.section('<section class="card budgetLead">', "<div class=budgetLeadBody>")
-        self.assertIn("id=discount-cue", lead)
-        for copy in ("Spend uses public list prices.",
-                     "Pay a negotiated or company rate? Add a discount so spend and budgets match your bill.",
-                     ">Add a discount</button>", ">Not now</button>", "Spend includes your discounts",
-                     "Costs before discounts are shown beside each total.", ">Manage discounts</button>",
-                     "tm_discount_cue_dismissed"):
-            self.assertIn(copy, self.page)
-        self.assertNotIn("mock", self.section("const DISCOUNT_LISTS=", "$('discount-rotate').onclick").lower())
-
-    def test_card_follows_the_budget_form_without_nesting_a_form(self):
-        editor = self.section("<div class=spendBudgetEditor>", "<div class=spendKpis>")
-        self.assertLess(editor.index("</form>"), editor.index("id=spend-discounts"))
-        card = editor[editor.index("id=spend-discounts"):]
-        self.assertNotIn("<form", card)
-        self.assertIn('id=discount-form role=group aria-label="Add a discount"', card)
-        for element in ("discount-tabs", "discount-rows", "discount-badge", "discount-status", "d-list",
-                        "d-channel", "d-pct", "d-start", "d-end", "d-note", "d-add", "d-claude-code",
-                        "d-claude-desktop", "discount-rotate"):
-            self.assertIn("id={}".format(element), card)
-        for copy in ("How Claude apps are billed", "Let other tools set discounts", "/api/v1/cost-discounts",
-                     "~/.token-meter/api-token", "Issue a new token", "Detect automatically"):
-            self.assertIn(copy, card)
-
-    def test_writes_use_the_dashboard_alias_and_recalculation_polling(self):
-        script = self.section("const DISCOUNT_LISTS=", "$('discount-rotate').onclick")
-        self.assertIn("fetch('/settings/cost-discounts',{method:'POST'", script)
-        self.assertIn("'X-Token-Meter-Action':token", script)
-        self.assertIn("Discount saved. Costs are being recalculated.", script)
-        self.assertIn("All costs were recalculated.", script)
-        self.assertIn("health.pricing_revision===target", script)
-        self.assertIn("op:'set_runtime_channels'", script)
-        self.assertIn("/api/v1/api-token/rotate", self.page)
-        self.assertIn("$('spend-discounts').hidden=!open;", self.page)
-
-    def test_totals_show_list_price_beside_discounted_spend(self):
-        self.assertIn("Estimate after discounts · list ${money(total+periodDiscount)}", self.page)
-        self.assertIn("After discounts · list ${money(Number(today.cost||0)+Number(today.discount_usd||0))}",
-                      self.page)
-
-    def test_card_cannot_widen_the_spend_page_at_laptop_width(self):
-        # The shared pricing table's 1030px minimum widened the whole budget editor at 1024px.
-        self.assertIn(".discountCard,.spendBudgetEditor{min-width:0}", self.page)
-        self.assertIn(".discountCard .modelPriceTable{min-width:760px}", self.page)
-        self.assertIn(".discountAdd{grid-template-columns:repeat(auto-fill,minmax(150px,1fr))}", self.page)
-        # The Add discount button sizes to its label instead of filling a grid column.
-        self.assertIn(".discountAdd .tbtn{justify-self:start;align-self:end;padding:6px 12px}", self.page)
-
-    def test_local_dates_are_sent_with_the_browser_offset(self):
-        script = self.section("function discountLocalMidnightIso", "function discountSay")
-        result = subprocess.run(["node", "-e", script + "console.log(discountLocalMidnightIso('2026-09-01'))"],
-                                capture_output=True, text=True, check=True, env={**os.environ, "TZ": "America/Los_Angeles"})
-        self.assertEqual(result.stdout.strip(), "2026-09-01T00:00:00-07:00")
-
-    def test_xsession_carries_discount_settings_but_never_the_api_token(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            token_path = Path(tmp) / "api-token"
-            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(Path(tmp) / "settings.json")), \
-                    mock.patch.object(meter, "TOKEN_METER_API_TOKEN", str(token_path)), \
-                    mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
-                meter._reset_cost_discount_cache()
-                token = meter.ensure_api_token()
-                cross = meter.cross_session(sources=[])
-            meter._reset_cost_discount_cache()
-        self.assertEqual(cross["cost_discounts"]["rules"], [])
-        self.assertIn("runtime_channels", cross["cost_discounts"])
-        self.assertNotIn(token, json.dumps(cross))
-
-
-class DeclutterCopyContractTests(unittest.TestCase):
-    """Copy moved out of view keeps its behavior: notes appear only when they say something."""
-
-    @classmethod
-    def setUpClass(cls):
-        cls.page = Path(DASHBOARD_PAGE).read_text()
-
-    def run_node(self, script):
-        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
-        return json.loads(result.stdout)
-
-    def statement(self, start, end=";\n"):
-        return start + self.page.split(start, 1)[1].split(end, 1)[0] + ";"
-
-    def test_scatter_missing_note_is_hidden_until_points_are_missing(self):
-        self.assertIn(".spendScatterLegend span[hidden]{display:none}", self.page)
-        self.assertIn("<span id=s-scatter-missing hidden>Requires active-time and selected-metric evidence.</span>", self.page)
-        self.assertIn("$('s-scatter-missing').hidden=points.length>=(rows||[]).length;", self.page)
-
-    def test_session_budget_shows_saved_briefly_after_a_successful_save(self):
-        self.assertIn("<span id=session-budget-status role=status aria-live=polite></span>", self.page)
-        self.assertNotIn("Saved for this session on this device", self.page)
-        body = self.page.split("let sessionBudgetStatusTimer=0;\n", 1)[1].split("\n}\n", 1)[0] + "\n}"
-        script = """
-const nodes={'session-budget-status':{textContent:''}};const $=id=>nodes[id];
-let CURRENT={id:'s'};const timers=[];function setTimeout(fn,ms){timers.push([fn,ms]);return timers.length;}function clearTimeout(){}
-function syncSessionBudgetControls(){}function showAppToast(){}
-async function queueSessionBudget(){return true;}
-let sessionBudgetStatusTimer=0;
-""" + body + """
-(async()=>{saveBudgetForSession('12');await new Promise(r=>setImmediate(r));
-const saved=nodes['session-budget-status'].textContent,delay=timers[0][1];timers[0][0]();
-process.stdout.write(JSON.stringify({saved,delay,after:nodes['session-budget-status'].textContent}));})();
-"""
-        self.assertEqual(self.run_node(script), {"saved": "Saved", "delay": 2500, "after": ""})
-
-    def test_agent_activity_coverage_is_empty_when_complete_and_lists_gaps(self):
-        statement = self.statement("$('agent-activity-coverage').textContent=")
-        script = """
-const nodes={'agent-activity-coverage':{textContent:'x'}};const $=id=>nodes[id];const f=n=>String(n);
-const run=(coverage,hidden)=>{""" + statement + """return nodes['agent-activity-coverage'].textContent;};
-process.stdout.write(JSON.stringify([
- run({relationships:'complete',cost:'estimated',tokens:'complete'},0),
- run({relationships:'complete',cost:'complete',tokens:'complete'},0),
- run({relationships:'partial',cost:'partial',tokens:'unavailable'},3),
-]));
-"""
-        self.assertEqual(self.run_node(script), [
-            "", "", "Relationships partial · cost partial · tokens unavailable · 3 hidden (limit 100)",
-        ])
-
-    def test_model_spend_note_marks_unpriced_runtimes_as_excluded_not_zero(self):
-        body = "function renderModelSpend(" + self.page.split("function renderModelSpend(", 1)[1].split("\nfunction ", 1)[0]
-        script = """
-const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
-const nodes={};const $=id=>nodes[id]||(nodes[id]={textContent:'',innerHTML:''});
-const setLogHtml=(el,html)=>{el.innerHTML=html;};const f=n=>String(n);const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
-const money=n=>'$'+Number(n).toFixed(2);const pct=n=>Math.round(n*100)+'%';const modelRangeLabel=()=>'30 days';let modelRange='30';
-const metricPartial=()=>false;const modelRankedColors=()=>new Map();const MODEL_OTHER_COLOR='x';
-const modelBoardValue=(group,key)=>group.window.cost==null?null:group.window.cost;
-""" + body + """
-const groups=[{key:'a',model:'a',runtime:'Codex',ids:['a'],window:{cost:2}},{key:'b',model:'b',runtime:'Codex',ids:['b'],window:{cost:null}},{key:'c',model:'c',runtime:'Codex',ids:['c'],window:{cost:null}}];
-renderModelSpend(groups,groups,[groups[0]],true);
-process.stdout.write(JSON.stringify(nodes['m-spend-note'].innerHTML));
-"""
-        html = self.run_node(script)
-        self.assertIn("<span class=fieldtip tabindex=0", html)
-        self.assertIn('data-tip="2 model runtimes without cost data are excluded, not counted as $0."', html)
-        self.assertIn('aria-description="2 model runtimes without cost data are excluded, not counted as $0."', html)
-        self.assertIn(">2 unpriced, excluded</span>", html)
-
-    NODE_EXTRACT = r"""
-const fs=require('fs');const page=fs.readFileSync(process.argv[1],'utf8');
-function extract(name){let start=page.indexOf(`async function ${name}(`);if(start<0)start=page.indexOf(`function ${name}(`);if(start<0)throw new Error('missing '+name);let i=page.indexOf('{',start),depth=0;for(;i<page.length;i++){if(page[i]==='{')depth++;else if(page[i]==='}'&&--depth===0)return page.slice(start,i+1);}}
-const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
-const f=n=>Number(n||0).toLocaleString('en-US');const money=n=>'$'+Number(n||0).toFixed(2);
-class Node{constructor(){this.textContent='';this.innerHTML='';this.hidden=false;this.dataset={};this.options=[];this.classList={add(){},remove(){},toggle(){}};this.style={setProperty(){}};this.body=null;}
- querySelector(sel){if(sel==='tbody'){return this.body||(this.body=new Node());}return null;}querySelectorAll(){return [];}setAttribute(){}removeAttribute(){}}
-const nodes={};const $=id=>nodes[id]||(nodes[id]=new Node());
-"""
-
-    def run_page_node(self, script):
-        page = str(Path(DASHBOARD_PAGE))
-        result = subprocess.run(["node", "-e", self.NODE_EXTRACT + script, page],
-                                capture_output=True, text=True)
-        if result.returncode:
-            errors = [line for line in result.stderr.splitlines() if "Error" in line]
-            self.fail(errors[0] if errors else result.stderr.strip() or "node failed")
-        return json.loads(result.stdout)
-
-    def test_today_cards_say_unavailable_only_when_daily_rows_are_missing(self):
-        out = self.run_page_node(r"""
-const localDayKey=(d=new Date())=>d.toISOString().slice(0,10);const metricAvailable=()=>true,metricPartial=()=>false,hasLocalEstimate=()=>false;
-const setCostValue=(id,text)=>{$(id).textContent=text;};const countWord=(n,one,many=one+'s')=>Number(n)===1?one:many;
-const dailyDeltaLabel=()=>'+0%';const renderTrendDelta=()=>'';
-eval(extract('renderCurrentDaySummary'));
-const ids=['current-day-spend-note','current-day-sessions-note','current-day-vs-yesterday-note'];const notes=()=>ids.map(id=>$(id).textContent);
-renderCurrentDaySummary(undefined);const loading=notes();
-renderCurrentDaySummary({current_sessions:[]});const missing=notes();
-renderCurrentDaySummary({daily:[{day:localDayKey(),cost:1.5,sessions:2}]});const arrived=notes();
-process.stdout.write(JSON.stringify({loading,missing,arrived}));
-""")
-        self.assertEqual(out["loading"], ["", "", ""])
-        self.assertEqual(out["missing"], ["Unavailable", "Unavailable", "Unavailable"])
-        self.assertNotIn("Unavailable", out["arrived"])
-        self.assertTrue(all(out["arrived"]))
-
-    def test_git_load_failure_marks_both_tables_unavailable_and_success_replaces_them(self):
-        out = self.run_page_node(r"""
-let deliveryRequest=0,deliveryRange='30',deliveryProject='',deliveryLastLoadedAt=0,deliveryRetryTimer=0,deliveryLoadRetries=0;
-let deliveryEvidenceFilter='all',deliverySort={key:'covered_cost',direction:'desc'},deliveryModelSort={key:'covered_cost',direction:'desc'};
-const modelEffortLabel=row=>row?.effort||'';const clearTimeout=()=>{};const setTimeout=()=>0;const setDeliveryEvidenceRatio=()=>{};const DELIVERY_EVIDENCE_FILTERS=['all','comparable','spend_only','git_only','unavailable'];const deliveryEvidenceFilterLabel=()=>'';
-eval(['loadDelivery','renderDeliveryTable','renderDeliveryModelTable','sortedDeliveryModelRows','deliveryModelSortValue','deliveryFilteredProjectRows','sortedDeliveryRows'].map(extract).join('\n'));
-function renderDelivery(payload){renderDeliveryModelTable(payload.model_rows,payload.model_coverage);renderDeliveryTable(payload.project_rows);}
-let respond;globalThis.fetch=async()=>respond();
-(async()=>{
- $('d-model-note').textContent='120 / 300 lines attributed';
- respond=()=>{throw new Error('offline');};await loadDelivery();
- const failed={note:$('d-model-note').textContent,model:$('d-model-table').querySelector('tbody').innerHTML,project:$('d-project-table').querySelector('tbody').innerHTML};
- respond=()=>({ok:true,json:async()=>({coverage:{last_checked:1},model_coverage:{available:true,comparable_lines:10,attributed_lines:10},model_rows:[{model:'gpt-x',runtime:'Codex',covered_cost:1,attributed_lines:10}],project_rows:[]})});
- await loadDelivery();
- const ok={note:$('d-model-note').textContent,model:$('d-model-table').querySelector('tbody').innerHTML,project:$('d-project-table').querySelector('tbody').innerHTML};
- process.stdout.write(JSON.stringify({failed,ok}));
-})();
-""")
-        failed, ok = out["failed"], out["ok"]
-        self.assertEqual(failed["note"], "")
-        self.assertIn("<td colspan=5><div class=\"deliveryEmpty emptyState\">Git evidence unavailable.</div>", failed["model"])
-        self.assertIn("<td colspan=4><div class=\"deliveryEmpty emptyState\">Git evidence unavailable.</div>", failed["project"])
-        self.assertEqual(ok["note"], "10 / 10 lines attributed")
-        self.assertIn("gpt-x", ok["model"])
-        self.assertNotIn("Git evidence unavailable.", ok["model"] + ok["project"])
-        self.assertIn("No projects match this filter.", ok["project"])
-
-    def test_scatter_missing_note_follows_plotted_points(self):
-        out = self.run_page_node(r"""
-let spendScatterMetric='cost';const CHART={lbl:'l',grid:'g'};const tint=()=>'t';const hideSpendScatterTip=()=>{};
-const sessionRowKey=row=>row.id;const spendRuntimeKey=p=>p;const spendInsightMetricFormat=v=>String(v);const sessionRoute=id=>'#'+id;
-const providerColor=()=>'c';const waitFmt=v=>String(v);const svgTextPx=(svg,w,h,px)=>px;const SPEND_RUNTIME_COLORS=new Proxy({},{get:()=>'c'});
-$('s-scatter-svg').clientWidth=1040;$('s-scatter-svg').clientHeight=340;$('s-scatter-metric');
-eval(['drawSpendScatter','spendScatterRows','spendSessionMetricValue'].map(extract).join('\n'));
-const analytics={distributions:{active:{median:0},cost:{median:0}},concentration:{top_count:0}};
-const row=(id,timed)=>({id,provider:'codex',title:id,cost:1,availability:{cost:true},duration_available:timed,duration_s:60});
-drawSpendScatter([row('a',true),row('b',false)],analytics);const partial=$('s-scatter-missing').hidden;
-drawSpendScatter([row('a',true),row('b',true)],analytics);const complete=$('s-scatter-missing').hidden;
-process.stdout.write(JSON.stringify({partial,complete,coverage:$('s-scatter-coverage').textContent}));
-""")
-        self.assertEqual(out, {"partial": False, "complete": True, "coverage": "2 of 2 sessions plotted"})
-
-    def test_work_breakdown_footnote_is_a_short_count_with_the_reason_in_a_tooltip(self):
-        start = " const excludedDetail="
-        block = start + self.page.split(start, 1)[1].split("\n}\n", 1)[0]
-        script = """
-const esc=s=>String(s??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
-const nodes={'w-breakdown-foot':{innerHTML:'x'}};const $=id=>nodes[id];const count=n=>String(n);
-const run=(unanswered,unjudged)=>{const overall={requests:10,tasks:8};""" + block + """;return nodes['w-breakdown-foot'].innerHTML;};
-process.stdout.write(JSON.stringify([run(3,2),run(0,0)]));
-"""
-        both, none = self.run_node(script)
-        self.assertEqual(none, "")
-        self.assertIn("<span class=fieldtip tabindex=0", both)
-        self.assertIn(">· 3 requests, 2 tasks excluded</span>", both)
-        self.assertIn("3 of 10 requests come from apps that don&#39;t split model calls by request", both)
-        self.assertIn("2 of 8 tasks had no labeled follow-up", both)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/tests/test_model_performance.py b/tests/test_model_performance.py
new file mode 100644
index 00000000..92df89b5
--- /dev/null
+++ b/tests/test_model_performance.py
@@ -0,0 +1,1417 @@
+import unittest
+import datetime
+import json
+import tempfile
+import threading
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class ModelPerformanceTests(unittest.TestCase):
+    def setUp(self):
+        # Matched-pace comparisons are cached per model pair and persisted, so
+        # each test starts from a clean in-memory and on-disk cache and never
+        # writes into the developer's home directory.
+        self._pace_temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._pace_temp.cleanup)
+        self._pace_cache_path = Path(self._pace_temp.name) / "matched-pace-cache.json"
+        patcher = mock.patch.object(
+            meter, "TOKEN_METER_MATCHED_PACE_CACHE", str(self._pace_cache_path),
+        )
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.addCleanup(meter._matched_pace_pair_cache.clear)
+        self.addCleanup(
+            setattr, meter, "_matched_pace_pair_cache_loaded", False,
+        )
+        self.addCleanup(meter._matched_pace_build_state.update, building=False)
+        self.addCleanup(setattr, meter, "_matched_pace_persist", False)
+        meter._matched_pace_pair_cache.clear()
+        meter._matched_pace_pair_cache_loaded = False
+        meter._matched_pace_build_state["building"] = False
+        meter._matched_pace_persist = True
+        meter._matched_pace_cache.update(signature=None, data=None)
+        self.addCleanup(meter._matched_pace_cache.update, signature=None, data=None)
+
+    def test_parse_iso_reuses_bounded_timestamp_conversions(self):
+        meter.parse_iso.cache_clear()
+        timestamp = "2026-08-14T04:30:00.123Z"
+
+        first = meter.parse_iso(timestamp)
+        before = meter.parse_iso.cache_info()
+        second = meter.parse_iso(timestamp)
+        after = meter.parse_iso.cache_info()
+
+        self.assertEqual(first, second)
+        self.assertEqual(after.hits, before.hits + 1)
+        self.assertLessEqual(after.maxsize, 65536)
+
+    def test_codex_performance_without_model_identity_stays_unknown(self):
+        objs = [
+            {"timestamp": "2026-07-01T00:00:00.000Z",
+             "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-01T00:00:01.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100, "output_tokens": 10,
+                    "total_tokens": 110,
+                }},
+            }},
+            {"timestamp": "2026-07-01T00:00:02.000Z", "payload": {
+                "type": "task_complete", "duration_ms": 2000,
+            }},
+        ]
+
+        samples = meter.codex_performance_samples(objs)
+
+        self.assertEqual(samples[0]["model"], "unknown-model")
+
+    def test_claude_tool_free_turn_uses_reported_turn_duration(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-07-01T00:00:00.000Z",
+             "message": {"content": "hello"}},
+            {"type": "assistant", "timestamp": "2026-07-01T00:00:01.900Z", "message": {
+                "id": "msg-1", "model": "claude-sonnet-5", "content": [{"type": "text", "text": "done"}],
+                "usage": {"input_tokens": 20, "output_tokens": 10}, "stop_reason": "end_turn",
+            }},
+            {"type": "system", "subtype": "turn_duration", "timestamp": "2026-07-01T00:00:02.000Z",
+             "durationMs": 2000},
+        ]
+        samples = meter.claude_performance_samples(objs)
+        summary = meter.performance_summary(samples, 10)
+        self.assertEqual(len(samples), 1)
+        self.assertEqual(samples[0]["tool_calls"], 0)
+        self.assertEqual(samples[0]["peak_input_tokens"], 20)
+        self.assertEqual(samples[0]["model_calls"], 1)
+        self.assertEqual(summary["basis"], "tool_free")
+        self.assertEqual(summary["output_tps"], 5)
+
+    def test_claude_desktop_uses_observed_turn_timing_without_duration_records(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
+             "message": {"content": "inspect the project"}},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:02.000Z", "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "text", "text": "checking"}],
+                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
+            }},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:04.000Z", "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "tool_use", "id": "tool-1", "name": "Read"}],
+                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
+            }},
+            {"type": "user", "timestamp": "2026-07-13T00:00:05.000Z", "message": {
+                "content": [{"type": "tool_result", "tool_use_id": "tool-1", "content": "done"}],
+            }},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:10.000Z", "message": {
+                "id": "msg-2", "model": "claude-opus-4-8",
+                "content": [{"type": "text", "text": "finished"}],
+                "usage": {"input_tokens": 25, "output_tokens": 20}, "stop_reason": "end_turn",
+            }},
+        ]
+        samples = meter.claude_performance_samples(objs)
+        self.assertEqual(len(samples), 1)
+        self.assertEqual(samples[0]["timing_basis"], "observed")
+        self.assertEqual(samples[0]["duration_s"], 10)
+        self.assertEqual(samples[0]["output_tokens"], 50)
+        self.assertEqual(samples[0]["tool_calls"], 1)
+        self.assertEqual(meter.performance_summary(samples, 50)["output_tps"], 5)
+
+    def test_claude_observed_throughput_excludes_user_input_pause(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
+             "message": {"content": "start"}},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:10.000Z", "message": {
+                "id": "msg-1", "model": "claude-opus-4-8", "stop_reason": "tool_use",
+                "usage": {"input_tokens": 20, "output_tokens": 10},
+                "content": [{"type": "tool_use", "id": "question-1", "name": "AskUserQuestion"}],
+            }},
+            {"type": "user", "timestamp": "2026-07-13T00:01:40.000Z", "message": {
+                "content": [{"type": "tool_result", "tool_use_id": "question-1", "content": "answer"}],
+            }},
+            {"type": "assistant", "timestamp": "2026-07-13T00:01:50.000Z", "message": {
+                "id": "msg-2", "model": "claude-opus-4-8", "stop_reason": "end_turn",
+                "usage": {"input_tokens": 25, "output_tokens": 20},
+                "content": [{"type": "text", "text": "finished"}],
+            }},
+        ]
+        sample = meter.claude_performance_samples(objs)[0]
+        self.assertEqual(sample["wall_duration_s"], 110)
+        self.assertEqual(sample["user_pause_s"], 90)
+        self.assertEqual(sample["duration_s"], 20)
+
+    def test_codex_tool_free_speed_excludes_time_to_first_token(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-01T00:00:09.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 200, "cached_input_tokens": 50,
+                    "output_tokens": 100, "total_tokens": 300,
+                }},
+            }},
+            {"timestamp": "2026-07-01T00:00:10.000Z", "payload": {
+                "type": "task_complete", "duration_ms": 10000, "time_to_first_token_ms": 2000,
+            }},
+        ]
+        samples = meter.codex_performance_samples(objs, "gpt-5.6")
+        summary = meter.performance_summary(samples, 100)
+        self.assertEqual(samples[0]["generation_s"], 8)
+        self.assertEqual(samples[0]["peak_input_tokens"], 200)
+        self.assertEqual(samples[0]["cache_read_tokens"], 50)
+        self.assertEqual(samples[0]["uncached_input_tokens"], 150)
+        self.assertEqual(samples[0]["model_calls"], 1)
+        self.assertEqual(summary["output_tps"], 12.5)
+        self.assertEqual(summary["avg_ttft_ms"], 2000)
+
+    def test_codex_live_speed_uses_completed_steps_before_task_complete(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 200, "cached_input_tokens": 50,
+                    "output_tokens": 40, "total_tokens": 240,
+                }},
+            }},
+            {"timestamp": "2026-07-01T00:00:05.000Z", "payload": {
+                "type": "function_call", "name": "exec_command", "call_id": "call-1",
+            }},
+            {"timestamp": "2026-07-01T00:00:10.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 250, "cached_input_tokens": 100,
+                    "output_tokens": 60, "total_tokens": 310,
+                }},
+            }},
+        ]
+
+        live = meter.codex_live_performance_summary(objs)
+
+        self.assertFalse(meter.performance_summary(
+            meter.codex_performance_samples(objs, "gpt-5.6"), 100,
+        )["available"])
+        self.assertTrue(live["available"])
+        self.assertEqual(live["basis"], "live_end_to_end")
+        self.assertEqual(live["completed_steps"], 2)
+        self.assertEqual(live["measured_output_tokens"], 100)
+        self.assertEqual(live["measured_seconds"], 10)
+        self.assertEqual(live["output_tps"], 10)
+
+    def test_codex_live_speed_disappears_when_task_completes(self):
+        objs = [
+            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 200, "output_tokens": 40, "total_tokens": 240,
+                }},
+            }},
+            {"timestamp": "2026-07-01T00:00:05.000Z", "payload": {
+                "type": "task_complete", "duration_ms": 5000,
+            }},
+        ]
+
+        live = meter.codex_live_performance_summary(objs)
+
+        self.assertFalse(live["available"])
+        self.assertEqual(live["completed_steps"], 0)
+        self.assertEqual(live["output_tps"], 0)
+
+    def test_tool_bearing_task_falls_back_to_end_to_end_throughput(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-01T00:00:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-01T00:00:02.000Z", "payload": {
+                "type": "function_call", "name": "exec_command", "call_id": "call-1",
+            }},
+            {"timestamp": "2026-07-01T00:00:09.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100, "output_tokens": 100, "total_tokens": 200,
+                }},
+            }},
+            {"timestamp": "2026-07-01T00:00:10.000Z", "payload": {
+                "type": "task_complete", "duration_ms": 10000, "time_to_first_token_ms": 1000,
+            }},
+        ]
+        summary = meter.performance_summary(meter.codex_performance_samples(objs), 100)
+        self.assertEqual(summary["basis"], "end_to_end")
+        self.assertEqual(summary["tool_free_samples"], 0)
+        self.assertEqual(summary["output_tps"], 10)
+
+    def test_cross_log_model_aggregation_is_weighted_and_keeps_daily_io(self):
+        sessions = [{
+            "provider": "codex",
+            "model_stats": [{"model": "gpt-5.6", "cost": 1.0, "tokens": 330,
+                             "input_tokens": 300, "output_tokens": 30, "executions": 2}],
+            "_model_daily": [{"model": "gpt-5.6", "day": "2026-07-01", "cost": 1.0,
+                              "input_tokens": 300, "output_tokens": 30, "executions": 2}],
+            "_performance_samples": [
+                {"model": "gpt-5.6", "day": "2026-07-01", "ts": 10,
+                 "output_tokens": 10, "duration_s": 2, "generation_s": 1, "tool_calls": 0},
+                {"model": "gpt-5.6", "day": "2026-07-01", "ts": 20,
+                 "output_tokens": 20, "duration_s": 5, "generation_s": 3, "tool_calls": 0},
+            ],
+            "_wait_samples": [
+                {"model": "gpt-5.6", "day": "2026-07-01", "duration_s": 8},
+                {"model": "gpt-5.6", "day": "2026-07-01", "duration_s": 12},
+            ],
+        }]
+        result = meter.aggregate_model_stats(sessions)
+        row = result["models"][0]
+        self.assertEqual(row["output_tps"], 7.5)
+        self.assertEqual(row["timing_coverage"], 1)
+        self.assertEqual(row["daily"][0]["input_tokens"], 300)
+        self.assertEqual(row["daily"][0]["throughput_samples"], 2)
+        self.assertEqual(row["avg_wait_s"], 10)
+        self.assertEqual(row["median_wait_s"], 10)
+        self.assertEqual(row["p95_wait_s"], 12)
+        self.assertEqual(row["daily"][0]["wait_durations_s"], [8, 12])
+        self.assertEqual(row["daily"][0]["max_wait_s"], 12)
+
+    def test_model_efficiency_counters_preserve_reasoning_cache_and_missing_evidence(self):
+        stats = {}
+        meter.add_model_summary(stats, "gpt-5.6", {
+            "input_tokens": 100,
+            "cache_read_input_tokens": 60,
+            "cache_creation_input_tokens": 20,
+            "output_tokens": 40,
+            "reasoning_output_tokens": 12,
+            "reasoning_available": True,
+        }, 0.5)
+        meter.add_model_summary(stats, "gpt-5.6", {
+            "input_tokens": 50,
+            "output_tokens": 10,
+        }, 0.1)
+
+        self.assertEqual(stats["gpt-5.6"], {
+            "cost": 0.6,
+            "tokens": 280,
+            "input_tokens": 230,
+            "output_tokens": 50,
+            "cache_read_tokens": 60,
+            "cache_write_tokens": 20,
+            "reasoning_tokens": 12,
+            "reasoning_output_tokens": 40,
+            "reasoning_executions": 1,
+            "reasoning_unavailable_executions": 1,
+            "thinking_executions": 0,
+            "thinking_covered_executions": 0,
+            "token_covered_executions": 2,
+            "io_covered_executions": 2,
+            "io_covered_input_tokens": 230,
+            "io_covered_output_tokens": 50,
+            "executions": 2,
+            "input_evidence": True,
+            "output_evidence": True,
+        })
+
+    def test_reasoning_requires_numeric_evidence(self):
+        from token_meter.runtimes.codex import codex_usage as native_codex_usage
+
+        for value in (
+            None, False, True, "12", -1, 12.5, float("inf"), float("nan"),
+            10 ** 400,
+        ):
+            codex = native_codex_usage({
+                "output_tokens": 20, "reasoning_output_tokens": value,
+            })
+            opencode = meter._opencode_usage({
+                "tokens": {"output": 20, "reasoning": value},
+            })
+            self.assertFalse(codex["reasoning_available"])
+            self.assertEqual(codex["reasoning_output_tokens"], 0)
+            self.assertFalse(opencode["reasoning_available"])
+            self.assertEqual(opencode["reasoning_tokens"], 0)
+            self.assertEqual(meter._opencode_context_tokens(opencode), 20)
+        self.assertTrue(native_codex_usage({
+            "output_tokens": 20, "reasoning_output_tokens": 0,
+        })["reasoning_available"])
+        self.assertTrue(meter._opencode_usage({
+            "tokens": {"output": 20, "reasoning": 0},
+        })["reasoning_available"])
+        self.assertEqual(native_codex_usage({
+            "output_tokens": 20, "reasoning_output_tokens": 12.0,
+        })["reasoning_output_tokens"], 12)
+        for normalizer in (native_codex_usage, meter.codex_usage):
+            oversized = normalizer({
+                "input_tokens": 10,
+                "output_tokens": 20,
+                "reasoning_output_tokens": 21,
+            })
+            self.assertFalse(oversized["reasoning_available"])
+            self.assertEqual(oversized["reasoning_output_tokens"], 0)
+
+        stats = {}
+        meter.add_model_summary(stats, "gpt-5.6", {
+            "input_tokens": 10,
+            "output_tokens": 20,
+            "reasoning_output_tokens": 21,
+            "reasoning_available": True,
+        }, 0.1)
+        self.assertEqual(stats["gpt-5.6"]["reasoning_tokens"], 0)
+        self.assertEqual(stats["gpt-5.6"]["reasoning_executions"], 0)
+        self.assertEqual(stats["gpt-5.6"]["reasoning_unavailable_executions"], 1)
+
+    def test_model_aggregation_exposes_efficiency_counts_and_coverage(self):
+        sessions = [{
+            "id": "session-a", "provider": "codex", "runtime": "Codex",
+            "availability": meter.metric_availability("codex"),
+            "model_stats": [{
+                "model": "gpt-5.6", "cost": 2.0, "tokens": 360,
+                "input_tokens": 300, "output_tokens": 60, "executions": 3,
+                "cache_read_tokens": 120, "cache_write_tokens": 10,
+                "reasoning_tokens": 15, "reasoning_output_tokens": 50,
+                "reasoning_executions": 2,
+                "reasoning_unavailable_executions": 1,
+            }],
+            "_model_daily": [{
+                "model": "gpt-5.6", "day": "2026-08-27", "cost": 2.0,
+                "input_tokens": 300, "output_tokens": 60, "executions": 3,
+                "cache_read_tokens": 120, "cache_write_tokens": 10,
+                "reasoning_tokens": 15, "reasoning_output_tokens": 50,
+                "reasoning_executions": 2,
+                "reasoning_unavailable_executions": 1,
+            }],
+            "_performance_samples": [{
+                "model": "gpt-5.6", "day": "2026-08-27", "ts": 10,
+                "input_tokens": 300, "output_tokens": 60,
+                "duration_s": 3, "generation_s": 3,
+                "tool_calls": 2, "model_calls": 2,
+                "attempts": 3, "retries": 2, "failed_attempts": 1,
+            }],
+            "_wait_samples": [],
+        }]
+
+        row = meter.aggregate_model_stats(sessions)["models"][0]
+
+        self.assertEqual(row["cache_read_tokens"], 120)
+        self.assertEqual(row["cache_write_tokens"], 10)
+        self.assertEqual(row["cost_covered_output_tokens"], 60)
+        self.assertEqual(row["cost_covered_executions"], 3)
+        self.assertEqual(row["cache_covered_input_tokens"], 300)
+        self.assertEqual(row["token_covered_executions"], 3)
+        self.assertEqual(row["reasoning_tokens"], 15)
+        self.assertEqual(row["reasoning_output_tokens"], 50)
+        self.assertEqual(row["reasoning_executions"], 2)
+        self.assertEqual(row["reasoning_unavailable_executions"], 1)
+        self.assertEqual(row["attempts"], 3)
+        self.assertEqual(row["retries"], 2)
+        self.assertEqual(row["failed_attempts"], 1)
+        self.assertEqual(row["attempt_samples"], 1)
+        self.assertEqual(row["coverage"]["reasoning_tokens"], {
+            "covered_executions": 2,
+            "total_executions": 3,
+            "complete": False,
+        })
+        self.assertFalse(row["coverage"]["attempts"]["complete"])
+        self.assertEqual(row["daily"][0]["reasoning_tokens"], 15)
+        self.assertEqual(row["daily"][0]["attempts"], 3)
+
+    def test_efficiency_denominators_exclude_uncovered_cost_and_cache_rows(self):
+        covered = {
+            "id": "covered", "provider": "codex", "runtime": "Codex",
+            "availability": meter.metric_availability(
+                "codex", cost=True, tokens=True, cache=True,
+            ),
+            "model_stats": [{
+                "model": "gpt-5.6", "cost": 2.0, "tokens": 360,
+                "input_tokens": 300, "output_tokens": 60, "executions": 1,
+                "cache_read_tokens": 120,
+            }],
+            "_model_daily": [{
+                "model": "gpt-5.6", "day": "2026-08-27", "cost": 2.0,
+                "input_tokens": 300, "output_tokens": 60, "executions": 1,
+                "cache_read_tokens": 120,
+            }],
+        }
+        uncovered = {
+            "id": "uncovered", "provider": "codex", "runtime": "Codex",
+            "availability": meter.metric_availability(
+                "codex", cost=False, tokens=True, cache=False,
+            ),
+            "model_stats": [{
+                "model": "gpt-5.6", "cost": 0.0, "tokens": 1100,
+                "input_tokens": 1000, "output_tokens": 100,
+                "executions": 1,
+            }],
+            "_model_daily": [{
+                "model": "gpt-5.6", "day": "2026-08-27", "cost": 0.0,
+                "input_tokens": 1000, "output_tokens": 100,
+                "executions": 1,
+            }],
+        }
+
+        row = meter.aggregate_model_stats([covered, uncovered])["models"][0]
+
+        self.assertEqual(row["output_tokens"], 160)
+        self.assertEqual(row["cost_covered_output_tokens"], 60)
+        self.assertEqual(row["cache_covered_input_tokens"], 300)
+        self.assertFalse(row["coverage"]["cost"]["complete"])
+        self.assertFalse(row["coverage"]["cache"]["complete"])
+
+    def test_input_only_model_evidence_keeps_output_unavailable(self):
+        availability = meter.metric_availability(
+            "opencode", cost=True, tokens=True, input_tokens=True,
+            output_tokens=False, cache=True,
+        )
+        stats = {
+            "model": "model-a", "cost": 1.0, "input_tokens": 10,
+            "output_tokens": 0, "executions": 1,
+            "token_covered_executions": 0, "cost_covered_executions": 0,
+            "cost_covered_output_tokens": 0,
+            "cache_covered_input_tokens": 10,
+            "availability": availability,
+        }
+        row = meter.aggregate_model_stats([{
+            "id": "input-only", "provider": "opencode", "runtime": "OpenCode",
+            "availability": meter.metric_availability(
+                "opencode", cost=True, tokens=True, input_tokens=True,
+                output_tokens=True, cache=True,
+            ),
+            "model_stats": [stats],
+            "_model_daily": [{**stats, "day": "2026-08-27"}],
+            "_wait_samples": [{
+                "model": "model-a", "day": "2026-08-27",
+                "duration_s": 1, "output_tokens": 0,
+            }],
+        }])["models"][0]
+
+        self.assertTrue(row["availability"]["tokens"])
+        self.assertTrue(row["availability"]["input_tokens"])
+        self.assertFalse(row["availability"]["output_tokens"])
+        self.assertFalse(row["daily"][0]["availability"]["output_tokens"])
+
+    def test_mixed_speed_coverage_counts_all_completed_output(self):
+        summary = meter.performance_summary([
+            {"output_tokens": 10, "duration_s": 2, "generation_s": 1, "tool_calls": 0, "ts": 1},
+            {"output_tokens": 90, "duration_s": 9, "generation_s": 8, "tool_calls": 1, "ts": 2},
+        ], 100)
+        self.assertEqual(summary["basis"], "end_to_end")
+        self.assertAlmostEqual(summary["output_tps"], 100 / 11)
+        self.assertEqual(summary["sample_count"], 2)
+        self.assertEqual(summary["timing_coverage"], 1)
+
+    def test_model_aggregation_omits_rows_without_io(self):
+        availability = meter.metric_availability(
+            "claude", cost=False, tokens=True, input_tokens=True,
+            output_tokens=True, cache=False,
+        )
+        result = meter.aggregate_model_stats([{
+            "provider": "claude", "availability": availability,
+            "model_stats": [{"model": "<synthetic>", "input_tokens": 0,
+                             "output_tokens": 0, "executions": 2, "cost": 0,
+                             "token_covered_executions": 2,
+                             "availability": availability}],
+        }])
+        self.assertEqual(result["models"], [])
+        self.assertEqual(result["total_models"], 0)
+
+    def test_model_aggregation_keeps_explicitly_covered_zero_io(self):
+        availability = meter.metric_availability(
+            "opencode", cost=True, tokens=True, input_tokens=True,
+            output_tokens=True, cache=True,
+        )
+        stats = {
+            "model": "model-a", "cost": 1.0,
+            "input_tokens": 0, "output_tokens": 0, "executions": 1,
+            "token_covered_executions": 1, "cost_covered_executions": 1,
+            "cost_covered_output_tokens": 0,
+            "cache_covered_input_tokens": 0,
+            "availability": availability,
+        }
+
+        result = meter.aggregate_model_stats([{
+            "id": "covered-zero", "provider": "opencode", "runtime": "OpenCode",
+            "availability": availability, "model_stats": [stats],
+            "_model_daily": [{**stats, "day": "2026-08-27"}],
+        }])
+
+        self.assertEqual(result["total_models"], 1)
+        row = result["models"][0]
+        self.assertEqual(row["input_tokens"], 0)
+        self.assertEqual(row["output_tokens"], 0)
+        self.assertEqual(row["cost_covered_output_tokens"], 0)
+        self.assertTrue(row["availability"]["input_tokens"])
+        self.assertTrue(row["availability"]["output_tokens"])
+        self.assertTrue(row["daily"][0]["availability"]["output_tokens"])
+
+    def test_model_aggregation_splits_same_model_by_runtime(self):
+        def session(runtime, output):
+            return {
+                "provider": "claude", "runtime": runtime,
+                "model_stats": [{"model": "claude-opus", "cost": 1, "tokens": 100,
+                                 "input_tokens": 90, "output_tokens": output, "executions": 1}],
+                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
+            }
+        result = meter.aggregate_model_stats([
+            session("Claude Code", 10), session("Claude-3P", 20),
+        ])
+        self.assertEqual(len(result["models"]), 2)
+        self.assertEqual(
+            {(row["model"], row["runtime"], row["id"]) for row in result["models"]},
+            {
+                ("claude-opus", "Claude Code", "claude-opus::Claude Code::unavailable"),
+                ("claude-opus", "Claude-3P", "claude-opus::Claude-3P::unavailable"),
+            },
+        )
+
+    def test_model_aggregation_gives_unreported_effort_an_explicit_identity(self):
+        result = meter.aggregate_model_stats([{
+            "provider": "codex", "runtime": "Codex",
+            "model_stats": [{
+                "model": "gpt-5.6", "cost": 1, "tokens": 100,
+                "input_tokens": 80, "output_tokens": 20, "executions": 1,
+            }],
+            "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
+        }])
+        self.assertEqual(result["models"][0]["id"], "gpt-5.6::Codex::unavailable")
+
+    def test_model_aggregation_keeps_trace_reported_session_effort_per_runtime(self):
+        def session(effort):
+            return {
+                "provider": "codex", "runtime": "Codex",
+                "reasoning_effort": effort,
+                "model_stats": [{
+                    "model": "gpt-5.6", "cost": 1, "tokens": 100,
+                    "input_tokens": 80, "output_tokens": 20, "executions": 1,
+                }],
+                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
+            }
+
+        rows = meter.aggregate_model_stats([
+            session("high"), session("xhigh"), session("private client note 42"),
+            session(""),
+        ])["models"]
+
+        self.assertEqual(
+            {(row.get("reasoning_effort"), tuple(row.get("reasoning_efforts") or ()))
+             for row in rows},
+            {("high", ("high",)), ("xhigh", ("xhigh",)), (None, ())},
+        )
+
+    def test_model_aggregation_scopes_effort_to_single_model_sessions_and_days(self):
+        def stats(model):
+            return {
+                "model": model, "cost": 1, "tokens": 100,
+                "input_tokens": 80, "output_tokens": 20, "executions": 1,
+            }
+
+        result = meter.aggregate_model_stats([
+            {
+                "provider": "codex", "runtime": "Codex", "reasoning_effort": "high",
+                "model_stats": [stats("gpt-5.6")],
+                "_model_daily": [{**stats("gpt-5.6"), "day": "2026-08-30"}],
+            },
+            {
+                "provider": "codex", "runtime": "Codex", "reasoning_effort": "xhigh",
+                "model_stats": [stats("gpt-5.6")],
+                "_model_daily": [{**stats("gpt-5.6"), "day": "2026-08-31"}],
+            },
+            {
+                "provider": "codex", "runtime": "Codex", "reasoning_effort": "ultra",
+                "primary_model": "gpt-a",
+                "model_stats": [stats("gpt-a"), stats("gpt-b")],
+                "_model_daily": [
+                    {**stats("gpt-a"), "day": "2026-08-31"},
+                    {**stats("gpt-b"), "day": "2026-08-31"},
+                ],
+            },
+        ])
+        by_model_effort = {
+            (row["model"], row.get("reasoning_effort")): row
+            for row in result["models"]
+        }
+
+        self.assertEqual(
+            by_model_effort[("gpt-5.6", "high")]["daily"][0]["reasoning_efforts"],
+            ["high"],
+        )
+        self.assertEqual(
+            by_model_effort[("gpt-5.6", "xhigh")]["daily"][0]["reasoning_efforts"],
+            ["xhigh"],
+        )
+        self.assertEqual(by_model_effort[("gpt-a", "ultra")]["reasoning_efforts"], ["ultra"])
+        self.assertEqual(by_model_effort[("gpt-b", None)]["reasoning_efforts"], [])
+
+    def test_project_model_stats_scopes_exactly_and_omits_session_identity(self):
+        def session(session_id, project, output):
+            return {
+                "id": session_id, "path": f"/private/logs/{session_id}.jsonl",
+                "title": f"Private title {session_id}",
+                "provider": "codex", "runtime": "Codex", "project": project,
+                "availability": meter.metric_availability("codex"),
+                "model_stats": [{
+                    "model": "gpt-5.6", "cost": 1, "tokens": 100 + output,
+                    "input_tokens": 100, "output_tokens": output, "executions": 1,
+                }],
+                "_model_daily": [{
+                    "model": "gpt-5.6", "day": "2026-07-30", "cost": 1,
+                    "input_tokens": 100, "output_tokens": output, "executions": 1,
+                }],
+                "_performance_samples": [], "_wait_samples": [],
+            }
+
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["internal_rows"] = (
+                session("secret-a", "/repo/a", 10),
+                session("secret-b", "/repo/b", 40),
+            )
+            meter._xsess["project_model_stats"] = {}
+            with mock.patch.object(meter, "cross_session",
+                                   return_value={"generated_at": 123}):
+                payload, status = meter.project_model_stats("/repo/a")
+                missing, missing_status = meter.project_model_stats("")
+                unknown, unknown_status = meter.project_model_stats("/repo/unknown")
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(status, 200)
+        self.assertTrue(payload["ok"])
+        self.assertEqual(payload["generated_at"], 123)
+        self.assertEqual(payload["model_stats"]["models"][0]["output_tokens"], 10)
+        self.assertNotIn("projects", payload["model_stats"])
+        encoded = json.dumps(payload)
+        self.assertNotIn("/repo/a", encoded)
+        self.assertNotIn("/private/logs", encoded)
+        self.assertNotIn("secret-a", encoded)
+        self.assertNotIn("Private title", encoded)
+        self.assertEqual(missing_status, 400)
+        self.assertFalse(missing["ok"])
+        self.assertEqual(unknown_status, 404)
+        self.assertFalse(unknown["ok"])
+        self.assertIn(
+            'elif req_path == "/model-stats":',
+            Path(meter.IMPLEMENTATION_FILE).read_text(),
+        )
+
+    def test_project_model_stats_groups_non_folder_labels_as_other_local_sessions(self):
+        def session(session_id, project):
+            return {
+                "id": session_id, "project": project, "provider": "codex",
+                "runtime": "Codex", "model_stats": [{
+                    "model": "gpt-5.6", "cost": 1, "tokens": 100,
+                    "input_tokens": 80, "output_tokens": 20, "executions": 1,
+                }],
+                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
+            }
+
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess.update({
+                "internal_rows": (session("cli", "CLI"), session("none", "No project")),
+                "project_model_stats": {},
+            })
+            with mock.patch.object(meter, "cross_session", return_value={"generated_at": 123}):
+                payload, status = meter.project_model_stats("__other_local_sessions__")
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(status, 200)
+        self.assertEqual(payload["model_stats"]["total_models"], 1)
+
+    def test_model_project_options_are_sorted_and_bounded(self):
+        sessions = [
+            {"project": f"/repo/{index:04d}", "provider": "codex",
+             "model_stats": [], "_model_daily": [], "_performance_samples": [],
+             "_wait_samples": []}
+            for index in range(meter.MODEL_PROJECT_OPTION_LIMIT + 1)
+        ]
+        result = meter.aggregate_model_stats(reversed(sessions))
+        self.assertEqual(len(result["projects"]), meter.MODEL_PROJECT_OPTION_LIMIT)
+        self.assertEqual(result["projects"][0], "/repo/0000")
+        self.assertTrue(result["projects_truncated"])
+
+    def test_cursor_samples_are_excluded_from_matched_pace(self):
+        samples = [{
+            "model": "gpt-5.6", "day": "2026-07-20", "ts": index + 1,
+            "input_tokens": 100, "peak_input_tokens": 100, "output_tokens": 20,
+            "duration_s": 2, "generation_s": 2, "tool_calls": 0, "model_calls": 1,
+        } for index in range(25)]
+        cursor = {
+            "id": "cursor", "provider": "cursor", "runtime": "Cursor",
+            "token_estimate": True,
+            "availability": meter.metric_availability(
+                "cursor", cost=True, tokens=True, input_tokens=True,
+                output_tokens=True, throughput=True, timing=True,
+            ),
+            "model_stats": [{"model": "gpt-5.6", "cost": 1, "tokens": 120,
+                              "input_tokens": 100, "output_tokens": 20, "executions": 1}],
+            "_model_daily": [], "_performance_samples": samples, "_wait_samples": [],
+        }
+        codex = {
+            **cursor, "id": "codex", "provider": "codex", "runtime": "Codex",
+            "token_estimate": False, "availability": meter.metric_availability("codex"),
+        }
+        result = meter.aggregate_model_stats([cursor, codex])
+        self.assertEqual({row["id"] for row in result["models"]},
+                         {"gpt-5.6::Cursor::unavailable", "gpt-5.6::Codex::unavailable"})
+        self.assertFalse(any(
+            any("::Cursor" in value for value in (pair["a_id"], pair["b_id"]))
+            for pairs in result["matched_pace"]["windows"].values() for pair in pairs
+        ))
+
+    def test_runtime_label_distinguishes_claude_desktop_roots(self):
+        standard = {
+            "provider": "claude", "client": "claude_desktop",
+            "metadata_path": str(Path(meter.CLAUDE_DESKTOP_DATA_ROOTS[0]) / "sessions" / "one.json"),
+        }
+        third_party = {
+            "provider": "claude", "client": "claude_desktop",
+            "metadata_path": str(Path(meter.CLAUDE_DESKTOP_DATA_ROOTS[1]) / "sessions" / "two.json"),
+        }
+        self.assertEqual(meter.source_runtime_label(standard), "Claude Desktop")
+        self.assertEqual(meter.source_runtime_label(third_party), "Claude-3P")
+        self.assertEqual(meter.source_runtime_label({"provider": "claude", "client": "claude_code"}),
+                         "Claude Code")
+        self.assertEqual(meter.source_runtime_label({"provider": "codex"}), "Codex")
+        self.assertEqual(meter.source_runtime_label({"provider": "cursor"}), "Cursor")
+
+    def test_matched_pace_has_exact_today_and_yesterday_windows(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(day, start):
+            return [{
+                "duration_s": 10, "ts": start + index, "day": day,
+                "input_tokens": 10000, "peak_input_tokens": 10000,
+                "cache_read_tokens": 0, "output_tokens": 1000,
+                "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        groups = {
+            runtime: (
+                samples("2026-08-11", offset)
+                + samples("2026-08-10", offset + 100)
+                + samples("2026-07-01", offset + 200)
+            )
+            for runtime, offset in (("alpha", 0), ("beta", 1000))
+        }
+
+        windows = meter.matched_pace_windows(groups, now_ts=now)["windows"]
+
+        self.assertEqual(
+            list(windows),
+            ["today", "yesterday", "7", "30", "90", "month", "last_month", "all"],
+        )
+        self.assertEqual(windows["month"][0]["a_samples"], 40)
+        for name in ("today", "yesterday"):
+            self.assertEqual(len(windows[name]), 1)
+            self.assertEqual(windows[name][0]["a_samples"], 20)
+            self.assertEqual(windows[name][0]["b_samples"], 20)
+        self.assertEqual(windows["7"][0]["a_samples"], 40)
+        self.assertEqual(windows["7"][0]["b_samples"], 40)
+        self.assertEqual(windows["all"][0]["a_samples"], 60)
+        self.assertEqual(windows["all"][0]["b_samples"], 60)
+        self.assertEqual(windows["last_month"][0]["a_samples"], 20)
+        self.assertEqual(windows["last_month"][0]["b_samples"], 20)
+        self.assertEqual(windows["month"][0]["a_samples"], 40)
+        self.assertEqual(windows["month"][0]["b_samples"], 40)
+
+    def test_matched_pace_reuses_unchanged_inputs_and_invalidates_changed_samples(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(duration, offset):
+            return [{
+                "duration_s": duration, "ts": now + offset + index,
+                "day": "2026-08-11", "input_tokens": 10000,
+                "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        groups = {"alpha": samples(10, 0), "beta": samples(20, 100)}
+        original = meter.matched_pace_comparison
+        with mock.patch.object(
+            meter, "matched_pace_comparison", wraps=original,
+        ) as comparison:
+            first = meter.matched_pace_windows(groups, now_ts=now)
+            first_call_count = comparison.call_count
+            second = meter.matched_pace_windows(groups, now_ts=now)
+            unchanged_call_count = comparison.call_count
+            changed_groups = {**groups, "beta": samples(30, 100)}
+            changed = meter.matched_pace_windows(changed_groups, now_ts=now)
+
+        self.assertGreater(first_call_count, 0)
+        self.assertEqual(unchanged_call_count, first_call_count)
+        self.assertEqual(second, first)
+        # Published snapshots are never mutated, so the cached windows are shared.
+        self.assertIs(second, first)
+        self.assertGreater(comparison.call_count, unchanged_call_count)
+        self.assertEqual(first["windows"]["today"][0]["pace_ratio"], 2)
+        self.assertEqual(changed["windows"]["today"][0]["pace_ratio"], 3)
+
+    def test_matched_pace_rebuilds_only_pairs_touching_a_changed_model(self):
+        """A new turn for one model must not recompute every model pair."""
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(duration, offset):
+            return [{
+                "duration_s": duration, "ts": now + offset + index,
+                "day": "2026-08-11", "input_tokens": 10000,
+                "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        names = ("alpha", "beta", "gamma", "delta")
+        groups = {name: samples(10 + index, index * 100)
+                  for index, name in enumerate(names)}
+        original = meter.matched_pace_comparison
+        with mock.patch.object(
+            meter, "matched_pace_comparison", wraps=original,
+        ) as comparison:
+            meter.matched_pace_windows(groups, now_ts=now)
+            first_call_count = comparison.call_count
+            changed_groups = {**groups, "gamma": samples(99, 500)}
+            meter.matched_pace_windows(changed_groups, now_ts=now)
+            after_change = comparison.call_count
+
+        # Four models form six pairs across every window. Only the three pairs
+        # that include the changed model may be recomputed.
+        windows = len(meter.MATCHED_PACE_WINDOW_KEYS)
+        self.assertEqual(first_call_count, 6 * windows)
+        self.assertEqual(after_change - first_call_count, 3 * windows)
+
+    def test_matched_pace_cached_pairs_match_a_cold_computation(self):
+        """Per-pair caching must not change any reported comparison."""
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(duration, offset):
+            return [{
+                "duration_s": duration, "ts": now + offset + index,
+                "day": "2026-08-11", "input_tokens": 10000,
+                "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        groups = {name: samples(10 + index, index * 100)
+                  for index, name in enumerate(("alpha", "beta", "gamma"))}
+        with_cached_pairs = meter.matched_pace_windows(groups, now_ts=now)
+        meter._matched_pace_pair_cache.clear()
+        meter._matched_pace_cache["signature"] = None
+        meter._matched_pace_cache["data"] = None
+        cold = meter.matched_pace_windows(groups, now_ts=now)
+
+        self.assertEqual(cold, with_cached_pairs)
+
+    def test_matched_pace_reuses_a_persisted_pair_cache_after_restart(self):
+        """A restart must reuse stored pairs instead of rebuilding every pair."""
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(duration, offset):
+            return [{
+                "duration_s": duration, "ts": now + offset + index,
+                "day": "2026-08-11", "input_tokens": 10000,
+                "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        groups = {name: samples(10 + index, index * 100)
+                  for index, name in enumerate(("alpha", "beta", "gamma"))}
+        original = meter.matched_pace_comparison
+        with mock.patch.object(
+            meter, "matched_pace_comparison", wraps=original,
+        ) as comparison:
+            first = meter.matched_pace_windows(groups, now_ts=now)
+            first_calls = comparison.call_count
+            # Simulate a process restart: drop in-memory state, keep the file.
+            meter._matched_pace_pair_cache.clear()
+            meter._matched_pace_pair_cache_loaded = False
+            meter._matched_pace_cache["signature"] = None
+            meter._matched_pace_cache["data"] = None
+            restarted = meter.matched_pace_windows(groups, now_ts=now)
+            restarted_calls = comparison.call_count - first_calls
+
+        self.assertGreater(first_calls, 0)
+        self.assertTrue(self._pace_cache_path.exists())
+        self.assertEqual(
+            restarted_calls, 0,
+            "a persisted pair cache must avoid recomputing unchanged pairs",
+        )
+        self.assertEqual(restarted, first)
+
+    def test_matched_pace_recovers_from_an_unusable_cache_file(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(duration, offset):
+            return [{
+                "duration_s": duration, "ts": now + offset + index,
+                "day": "2026-08-11", "input_tokens": 10000,
+                "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        groups = {"alpha": samples(10, 0), "beta": samples(20, 100)}
+        for payload in (
+            "{ not json",
+            json.dumps({"schema": 999, "pairs": "unexpected"}),
+            json.dumps({
+                "schema": meter.MATCHED_PACE_CACHE_SCHEMA,
+                "pairs": [{"a_id": 5}, "junk"],
+            }),
+        ):
+            with self.subTest(payload=payload[:24]):
+                self._pace_cache_path.write_text(payload)
+                meter._matched_pace_pair_cache.clear()
+                meter._matched_pace_pair_cache_loaded = False
+                meter._matched_pace_cache["signature"] = None
+                meter._matched_pace_cache["data"] = None
+                result = meter.matched_pace_windows(groups, now_ts=now)
+                self.assertEqual(len(result["windows"]["today"]), 1)
+
+    def test_matched_pace_rebuild_releases_the_cache_lock(self):
+        """A slow rebuild must not block unrelated cross-session requests."""
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+
+        def samples(duration, offset):
+            return [{
+                "duration_s": duration, "ts": now + offset + index,
+                "day": "2026-08-11", "input_tokens": 10000,
+                "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+            } for index in range(20)]
+
+        groups = {"alpha": samples(10, 0), "beta": samples(20, 100)}
+        entered = threading.Event()
+        release = threading.Event()
+        real_build = meter._build_matched_pace_windows
+        acquired = False
+
+        def blocking_build(*args, **kwargs):
+            entered.set()
+            release.wait(timeout=10)
+            return real_build(*args, **kwargs)
+
+        with mock.patch.object(
+            meter, "_build_matched_pace_windows", side_effect=blocking_build,
+        ):
+            worker = threading.Thread(
+                target=meter.matched_pace_windows,
+                args=(groups,), kwargs={"now_ts": now}, daemon=True,
+            )
+            worker.start()
+            try:
+                self.assertTrue(entered.wait(timeout=5))
+                acquired = meter._matched_pace_cache_lock.acquire(timeout=5)
+                if acquired:
+                    meter._matched_pace_cache_lock.release()
+            finally:
+                release.set()
+                worker.join(timeout=10)
+
+        self.assertTrue(
+            acquired,
+            "matched_pace_windows must not hold the cache lock while rebuilding",
+        )
+
+    @staticmethod
+    def _pace_groups(now, names=("alpha", "beta", "gamma"), day_offsets=(0,)):
+        """Build 20 timed turns per model on each day offset from ``now``."""
+        def samples(duration, offset):
+            rows = []
+            for day_offset in day_offsets:
+                ts = now - day_offset * 86400
+                day = datetime.date.fromtimestamp(ts).isoformat()
+                rows.extend({
+                    "duration_s": duration + day_offset, "ts": ts + offset + index,
+                    "day": day, "input_tokens": 10000,
+                    "peak_input_tokens": 10000, "cache_read_tokens": 0,
+                    "output_tokens": 1000, "tool_calls": 0, "model_calls": 1,
+                } for index in range(20))
+            return rows
+
+        return {name: samples(10 + index, index * 100)
+                for index, name in enumerate(names)}
+
+    @staticmethod
+    def _drop_pace_memory(loaded=False):
+        """Drop in-memory matched-pace state; ``loaded=False`` simulates restart."""
+        meter._matched_pace_pair_cache.clear()
+        meter._matched_pace_pair_cache_loaded = loaded
+        meter._matched_pace_cache["signature"] = None
+        meter._matched_pace_cache["data"] = None
+
+    def _cold_pace(self, groups, now):
+        self._drop_pace_memory(loaded=True)
+        return meter.matched_pace_windows(groups, now_ts=now)
+
+    def test_matched_pace_pair_cache_does_not_reuse_previous_day_windows(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        tomorrow = now + 86400
+        groups = self._pace_groups(now, day_offsets=(0, 1))
+        meter.matched_pace_windows(groups, now_ts=now)
+        rolled = meter.matched_pace_windows(groups, now_ts=tomorrow)
+        cold = self._cold_pace(groups, tomorrow)
+
+        self.assertEqual(rolled, cold)
+        # The previous "today" samples are now "yesterday"; nothing is today.
+        self.assertFalse(any(row["available"] for row in rolled["windows"]["today"]))
+        self.assertTrue(all(row["available"] for row in rolled["windows"]["yesterday"]))
+
+    def test_matched_pace_persisted_pairs_do_not_survive_a_day_rollover(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        tomorrow = now + 86400
+        groups = self._pace_groups(now, day_offsets=(0, 1))
+        meter.matched_pace_windows(groups, now_ts=now)
+        self.assertTrue(self._pace_cache_path.exists())
+        self._drop_pace_memory()
+        reloaded = meter.matched_pace_windows(groups, now_ts=tomorrow)
+        cold = self._cold_pace(groups, tomorrow)
+
+        self.assertEqual(reloaded, cold)
+
+    def test_matched_pace_rejects_incomplete_or_non_finite_persisted_entries(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now)
+        expected = meter.matched_pace_windows(groups, now_ts=now)
+        stored = json.loads(self._pace_cache_path.read_text())
+
+        def corrupt_missing(entry):
+            entry["windows"].pop("today")
+            entry["windows"].pop("yesterday")
+
+        def corrupt_nan(entry):
+            entry["windows"]["today"]["coverage"] = float("nan")
+
+        def corrupt_infinite(entry):
+            entry["windows"]["all"]["pace_ratio"] = float("inf")
+
+        def corrupt_type(entry):
+            entry["windows"]["7"]["matched_pairs"] = "12"
+
+        for corrupt in (corrupt_missing, corrupt_nan, corrupt_infinite, corrupt_type):
+            with self.subTest(corruption=corrupt.__name__):
+                payload = json.loads(json.dumps(stored))
+                for entry in payload["pairs"]:
+                    corrupt(entry)
+                self._pace_cache_path.write_text(json.dumps(payload))
+                self._drop_pace_memory()
+                result = meter.matched_pace_windows(groups, now_ts=now)
+                self.assertEqual(result, expected)
+                self.assertEqual(meter._matched_pace_pair_cache_loaded, True)
+                self.assertEqual(len(meter._matched_pace_pair_cache), 3)
+
+    def test_matched_pace_ignores_an_undecodable_cache_file(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now)
+        expected = self._cold_pace(groups, now)
+        self._pace_cache_path.write_bytes(b'{"schema": \xff\xfe\x80 }')
+        self._drop_pace_memory()
+
+        self.assertEqual(meter.matched_pace_windows(groups, now_ts=now), expected)
+
+    def test_project_scoped_matched_pace_leaves_the_global_pair_cache_intact(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        global_groups = self._pace_groups(now, names=("alpha", "beta", "gamma", "delta"))
+        project_groups = {
+            name: rows[:15] for name, rows in global_groups.items()
+            if name in ("alpha", "beta")
+        }
+        first = meter.matched_pace_windows(global_groups, now_ts=now)
+        persisted = self._pace_cache_path.read_bytes()
+        project = meter.matched_pace_windows(
+            project_groups, now_ts=now, persistent=False,
+        )
+        self.assertEqual(self._pace_cache_path.read_bytes(), persisted)
+        self.assertEqual(project, self._cold_pace(project_groups, now))
+        # Restore the global in-memory state the cold check discarded.
+        self._drop_pace_memory()
+        meter.matched_pace_windows(global_groups, now_ts=now)
+        meter.matched_pace_windows(project_groups, now_ts=now, persistent=False)
+        meter._matched_pace_cache["signature"] = None
+
+        original = meter.matched_pace_comparison
+        with mock.patch.object(
+            meter, "matched_pace_comparison", wraps=original,
+        ) as comparison:
+            again = meter.matched_pace_windows(global_groups, now_ts=now)
+        self.assertEqual(comparison.call_count, 0)
+        self.assertEqual(again, first)
+        self.assertEqual(self._pace_cache_path.read_bytes(), persisted)
+
+    def test_project_model_stats_uses_the_non_persistent_pace_scope(self):
+        row = {
+            "id": "s", "project": "/repo/a", "provider": "codex",
+            "runtime": "Codex", "model_stats": [{
+                "model": "gpt-5.6", "cost": 1, "tokens": 100,
+                "input_tokens": 80, "output_tokens": 20, "executions": 1,
+            }],
+            "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
+        }
+        saved_cache = dict(meter._xsess)
+        original = meter.matched_pace_windows
+        try:
+            meter._xsess.update({"internal_rows": (row,), "project_model_stats": {}})
+            with mock.patch.object(meter, "cross_session",
+                                   return_value={"generated_at": 1}), \
+                    mock.patch.object(meter, "matched_pace_windows",
+                                      wraps=original) as pace:
+                _, status = meter.project_model_stats("/repo/a")
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(status, 200)
+        self.assertEqual(pace.call_count, 1)
+        self.assertIs(pace.call_args.kwargs.get("persistent"), False)
+
+    def test_matched_pace_skips_the_write_when_no_pair_changed(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now)
+        meter.matched_pace_windows(groups, now_ts=now)
+        self.assertTrue(self._pace_cache_path.exists())
+        # Force a rebuild that finds every pair already cached: a restart that
+        # reloads the file, then a changed whole-result signature.
+        self._drop_pace_memory()
+        with mock.patch.object(meter, "atomic_write_text") as write:
+            meter.matched_pace_windows(groups, now_ts=now)
+            meter._matched_pace_cache["signature"] = None
+            meter.matched_pace_windows(groups, now_ts=now)
+        write.assert_not_called()
+
+        changed = {**groups, "gamma": groups["gamma"][:-1]}
+        with mock.patch.object(meter, "atomic_write_text") as write:
+            meter.matched_pace_windows(changed, now_ts=now)
+        self.assertEqual(write.call_count, 1)
+
+    def test_matched_pace_pair_cache_is_bounded_on_load_and_in_memory(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now, names=("alpha", "beta", "gamma", "delta"))
+        with mock.patch.object(meter, "MATCHED_PACE_CACHE_MAX_PAIRS", 2):
+            first = meter.matched_pace_windows(groups, now_ts=now)
+            self.assertEqual(len(meter._matched_pace_pair_cache), 2)
+            self.assertEqual(len(json.loads(
+                self._pace_cache_path.read_text())["pairs"]), 2)
+            self.assertEqual(first, self._cold_pace(groups, now))
+        meter._matched_pace_cache["signature"] = None
+        meter.matched_pace_windows(groups, now_ts=now)
+        stored = json.loads(self._pace_cache_path.read_text())
+        self.assertEqual(len(stored["pairs"]), 6)
+        with mock.patch.object(meter, "MATCHED_PACE_CACHE_MAX_PAIRS", 3):
+            self._drop_pace_memory()
+            with mock.patch.object(meter, "_build_matched_pace_windows",
+                                   return_value=({}, False)):
+                meter.matched_pace_windows(groups, now_ts=now)
+            self.assertEqual(len(meter._matched_pace_pair_cache), 3)
+
+    def test_matched_pace_skips_entries_with_huge_integers_without_raising(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now)
+        expected = meter.matched_pace_windows(groups, now_ts=now)
+        stored = json.loads(self._pace_cache_path.read_text())
+        huge = "9" * 400
+        # json.loads decodes a bare 400-digit literal as a Python int, for
+        # which math.isfinite raises OverflowError.
+        for field in ("pace_ratio", "matched_pairs"):
+            with self.subTest(field=field):
+                payload = json.loads(json.dumps(stored))
+                payload["pairs"][0]["windows"]["all"][field] = "HUGE"
+                text = json.dumps(payload).replace('"HUGE"', huge)
+                self._pace_cache_path.write_text(text)
+                self._drop_pace_memory()
+                original = meter.matched_pace_comparison
+                with mock.patch.object(
+                    meter, "matched_pace_comparison", wraps=original,
+                ) as comparison:
+                    result = meter.matched_pace_windows(groups, now_ts=now)
+                self.assertEqual(result, expected)
+                self.assertEqual(result, self._cold_pace(groups, now))
+                # Only the corrupted pair is recomputed; the others are kept.
+                self.assertEqual(
+                    comparison.call_count, len(meter.MATCHED_PACE_WINDOW_KEYS),
+                )
+
+    def test_matched_pace_persisted_entries_cannot_inject_output_fields(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now)
+        expected = meter.matched_pace_windows(groups, now_ts=now)
+        stored = json.loads(self._pace_cache_path.read_text())
+
+        def inject_key(window):
+            window["note"] = "/Users/x/secret"
+
+        def inject_reason(window):
+            window["reason"] = "/Users/x/secret"
+
+        def long_reason(window):
+            window["reason"] = "only 1 comparable turns; needs 20" + "x" * 300
+
+        def negative_ratio(window):
+            window["pace_ratio"] = -1.5
+
+        def negative_count(window):
+            window["a_samples"] = -3
+
+        def absurd_ratio(window):
+            window["ci_high"] = 1e300
+
+        def missing_key(window):
+            window.pop("reason")
+
+        for corrupt in (inject_key, inject_reason, long_reason, negative_ratio,
+                        negative_count, absurd_ratio, missing_key):
+            with self.subTest(corruption=corrupt.__name__):
+                payload = json.loads(json.dumps(stored))
+                for entry in payload["pairs"]:
+                    corrupt(entry["windows"]["7"])
+                self._pace_cache_path.write_text(json.dumps(payload))
+                self._drop_pace_memory()
+                result = meter.matched_pace_windows(groups, now_ts=now)
+                self.assertEqual(result, expected)
+                self.assertNotIn("/Users/x/secret", json.dumps(result))
+                self.assertNotIn("note", json.dumps(result))
+
+    def test_matched_pace_over_cap_rebuilds_do_not_rewrite_the_cache(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now, names=("alpha", "beta", "gamma", "delta"))
+        with mock.patch.object(meter, "MATCHED_PACE_CACHE_MAX_PAIRS", 2):
+            first = meter.matched_pace_windows(groups, now_ts=now)
+            kept = set(meter._matched_pace_pair_cache)
+            with mock.patch.object(meter, "atomic_write_text") as write:
+                for _ in range(3):
+                    meter._matched_pace_cache["signature"] = None
+                    again = meter.matched_pace_windows(groups, now_ts=now)
+                    self.assertEqual(again, first)
+            write.assert_not_called()
+            self.assertEqual(set(meter._matched_pace_pair_cache), kept)
+            self.assertEqual(first, self._cold_pace(groups, now))
+
+    def test_matched_pace_concurrent_callers_trigger_one_build(self):
+        now = datetime.datetime(2026, 8, 11, 12, 0, 0).timestamp()
+        groups = self._pace_groups(now)
+        callers = 4
+        waiting = set()
+        waiting_lock = threading.Lock()
+        all_waiting = threading.Event()
+
+        class CountingCondition(type(meter._matched_pace_build_condition)):
+            def wait(self, timeout=None):
+                with waiting_lock:
+                    waiting.add(threading.get_ident())
+                    if len(waiting) >= callers - 1:
+                        all_waiting.set()
+                return super().wait(timeout)
+
+        real_build = meter._build_matched_pace_windows
+        builds = []
+
+        def gated_build(*args, **kwargs):
+            builds.append(threading.get_ident())
+            all_waiting.wait(timeout=10)
+            return real_build(*args, **kwargs)
+
+        results = [None] * callers
+
+        def call(index):
+            results[index] = meter.matched_pace_windows(groups, now_ts=now)
+
+        with mock.patch.object(meter, "_matched_pace_build_condition",
+                               CountingCondition(threading.Lock())), \
+                mock.patch.object(meter, "_build_matched_pace_windows",
+                                  side_effect=gated_build):
+            threads = [threading.Thread(target=call, args=(index,), daemon=True)
+                       for index in range(callers)]
+            for thread in threads:
+                thread.start()
+            for thread in threads:
+                thread.join(timeout=15)
+
+        self.assertTrue(all_waiting.is_set())
+        self.assertEqual(len(builds), 1)
+        self.assertTrue(all(result is not None for result in results))
+        self.assertTrue(all(result == results[0] for result in results))
+
+    def test_matched_pace_reports_ratio_confidence_and_coverage(self):
+        def sample(duration, ts):
+            return {
+                "duration_s": duration, "ts": ts, "day": "2026-07-13",
+                "input_tokens": 100000, "peak_input_tokens": 50000,
+                "cache_read_tokens": 70000, "output_tokens": 2000,
+                "tool_calls": 4, "model_calls": 3,
+            }
+        left = [sample(10, index * 60) for index in range(24)]
+        right = [sample(20, index * 60 + 1) for index in range(24)]
+        comparison = meter.matched_pace_comparison("left", left, "right", right)
+        self.assertTrue(comparison["available"])
+        self.assertEqual(comparison["matched_pairs"], 24)
+        self.assertEqual(comparison["coverage"], 1)
+        self.assertEqual(comparison["pace_ratio"], 2)
+        self.assertEqual(comparison["ci_low"], 2)
+        self.assertEqual(comparison["ci_high"], 2)
+
+    def test_matched_pace_withholds_sparse_or_different_tool_shapes(self):
+        base = {
+            "duration_s": 10, "ts": 1, "day": "2026-07-13",
+            "input_tokens": 10000, "peak_input_tokens": 10000,
+            "output_tokens": 1000, "model_calls": 1, "cache_read_tokens": 0,
+        }
+        sparse = meter.matched_pace_comparison(
+            "a", [{**base, "tool_calls": 0}] * 19,
+            "b", [{**base, "tool_calls": 0}] * 19,
+        )
+        different = meter.matched_pace_comparison(
+            "a", [{**base, "tool_calls": 0}] * 20,
+            "b", [{**base, "tool_calls": 1}] * 20,
+        )
+        self.assertFalse(sparse["available"])
+        self.assertIn("20 timed turns", sparse["reason"])
+        self.assertFalse(different["available"])
+        self.assertEqual(different["matched_pairs"], 0)
+        self.assertIn("comparable turns", different["reason"])
+
+    def test_matched_pace_completes_under_large_sample_volume(self):
+        def sample(idx, duration):
+            return {
+                "duration_s": duration, "ts": 1000000 + idx * 60,
+                "day": "2026-08-01",
+                "input_tokens": 100000, "peak_input_tokens": 100000,
+                "cache_read_tokens": 70000, "output_tokens": 2000,
+                "tool_calls": 4, "model_calls": 3,
+            }
+        left = [sample(i, 10) for i in range(2000)]
+        right = [sample(i, 20) for i in range(2000)]
+        session_rows = [
+            {
+                "id": f"ses_{i}", "provider": "opencode",
+                "runtime": "OpenCode", "project": f"project-{i % 10}",
+                "availability": {"cost": True, "tokens": True, "cache": True},
+                "model_stats": [
+                    {"model": f"model-{i % 3}", "cost": 1.0, "tokens": 5000,
+                     "input_tokens": 3000, "output_tokens": 2000,
+                     "executions": 10, "availability": {"cost": True, "tokens": True}},
+                ],
+                "_model_daily": [],
+                "_performance_samples": left if i == 0 else [],
+                "_wait_samples": [],
+                "_tool_evidence": meter.summarize_tool_evidence([]),
+            }
+            for i in range(50)
+        ]
+        session_rows.append({
+            "id": "ses_big", "provider": "opencode",
+            "runtime": "OpenCode", "project": "big-project",
+            "availability": {"cost": True, "tokens": True, "cache": True},
+            "model_stats": [
+                {"model": "model-0", "cost": 50.0, "tokens": 250000,
+                 "input_tokens": 150000, "output_tokens": 100000,
+                 "executions": 500, "availability": {"cost": True, "tokens": True}},
+            ],
+            "_model_daily": [],
+            "_performance_samples": right,
+            "_wait_samples": [],
+            "_tool_evidence": meter.summarize_tool_evidence([]),
+        })
+        start = time.time()
+        result = meter.aggregate_model_stats(session_rows)
+        elapsed = time.time() - start
+        self.assertLess(elapsed, 5.0,
+                        f"aggregate_model_stats took {elapsed:.1f}s with 4000 samples; "
+                        "matched_pace_comparison may be unbounded")
+        self.assertGreaterEqual(len(result.get("models", [])), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_opencode_sessions.py b/tests/test_opencode_sessions.py
new file mode 100644
index 00000000..7c9f36f2
--- /dev/null
+++ b/tests/test_opencode_sessions.py
@@ -0,0 +1,647 @@
+import datetime
+import json
+import sqlite3
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from token_meter.projections import agent_usage_projection
+from tests.opencode_test_support import OpenCodeCase
+
+
+class OpenCodeTests(OpenCodeCase):
+    def test_reported_cost_rejects_unrepresentable_numbers(self):
+        for value in (10 ** 400, float("inf"), float("nan"), -1, True, "1"):
+            self.assertEqual(meter._opencode_reported_cost({"cost": value}), (0.0, False))
+        self.assertEqual(meter._opencode_reported_cost({"cost": 0}), (0.0, True))
+        self.assertEqual(meter._opencode_reported_cost({"cost": 1.25}), (1.25, True))
+
+    def test_anthropic_model_uses_anthropic_rates_for_cache_savings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            state = self._pricing_state(tmp, "claude-sonnet-4-6", "anthropic")
+
+        self.assertEqual(state["executions"][0]["model_provider"], "anthropic")
+        self.assertAlmostEqual(state["total_cost"], 0.0123)
+        self.assertFalse(state["cost_approx"])
+        self.assertTrue(state["cache"]["savings_available"])
+        self.assertAlmostEqual(state["cache"]["saved"], 0.0135)
+        self.assertAlmostEqual(state["cache_saved"], 0.0135)
+        self.assertGreater(state["cache"]["cost"], 0)
+
+    def test_cache_savings_use_session_provider_without_messages(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            state = self._pricing_state(
+                tmp, "claude-sonnet-4-6", "anthropic", messages=False,
+            )
+
+        self.assertEqual(state["executions"], [])
+        self.assertTrue(state["cache"]["savings_available"])
+        self.assertAlmostEqual(state["cache"]["saved"], 0.0135)
+
+    def test_cost_unavailable_marks_cache_savings_unavailable(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            state = self._pricing_state(
+                tmp, "claude-sonnet-4-6", "anthropic", cost=None,
+            )
+
+        self.assertFalse(state["availability"]["cost"])
+        self.assertFalse(state["cache"]["savings_available"])
+        self.assertIsNone(state["cache"]["saved"])
+
+    def test_openai_model_uses_openai_rates_for_cache_savings(self):
+        for model in ("gpt-6-astra", "openai/gpt-6-astra"):
+            with self.subTest(model=model), tempfile.TemporaryDirectory() as tmp:
+                state = self._pricing_state(tmp, model, "openai")
+
+            self.assertAlmostEqual(state["total_cost"], 0.0123)
+            self.assertTrue(state["cache"]["savings_available"])
+            self.assertAlmostEqual(state["cache"]["saved"], 0.045)
+
+    def test_cursor_model_uses_cursor_rates_for_cache_savings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            state = self._pricing_state(tmp, "claude-opus-5-5", "cursor")
+
+        self.assertAlmostEqual(state["total_cost"], 0.0123)
+        self.assertTrue(state["cache"]["savings_available"])
+        self.assertAlmostEqual(state["cache"]["saved"], 0.019)
+
+    def test_explicit_opencode_price_overrides_upstream_fallback(self):
+        prices = {"opencode": {"claude-sonnet-4-6": {
+            "input": 9.0, "output": 9.0, "cache_write": 9.0, "cache_read": 1.0,
+        }}}
+        with tempfile.TemporaryDirectory() as tmp:
+            state = self._pricing_state(
+                tmp, "claude-sonnet-4-6", "anthropic", prices=prices,
+            )
+
+        self.assertAlmostEqual(state["total_cost"], 0.0123)
+        self.assertTrue(state["cache"]["savings_available"])
+        self.assertAlmostEqual(state["cache"]["saved"], 0.04)
+
+    def test_unpriced_opencode_models_report_unavailable_cache_savings(self):
+        for model, provider_id in (
+            ("mystery-model-9", "unknown-provider"),
+            ("claude-opus-4-8", "opencode"),
+            ("claude-opus-4-8", "opencode-go"),
+            ("claude-opus-4-8", "openrouter"),
+            ("claude-opus-4-8", "amazon-bedrock"),
+        ):
+            with self.subTest(model=model, provider_id=provider_id), \
+                    tempfile.TemporaryDirectory() as tmp:
+                state = self._pricing_state(tmp, model, provider_id)
+
+            self.assertAlmostEqual(state["total_cost"], 0.0123)
+            self.assertIsNone(state["cache"]["saved"])
+            self.assertFalse(state["cache"]["savings_available"])
+            self.assertIsNone(state["cache_saved"])
+            self.assertNotIn(
+                "cache-saved", {row.get("key") for row in state["insights"]},
+            )
+
+    def test_discovery_joins_all_session_sources(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
+                                    0.5, 1000, 200, 50, 300, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
+                          top["directory"], top["title"], top["version"], top["time_created"],
+                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
+                          top["cost"], top["tokens_input"], top["tokens_output"],
+                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
+                    mock.patch.object(meter, "CODEX_SESSIONS", str(root / "no-codex")), \
+                    mock.patch.object(meter, "CODEX_INDEX", str(root / "no-index")), \
+                    mock.patch.object(meter, "CURSOR_PROJECTS", str(root / "no-cursor")), \
+                    mock.patch.object(meter, "KIRO_SESSIONS", str(root / "no-kiro")), \
+                    mock.patch.object(meter, "KIRO_AGENT_STORAGE", str(root / "no-kiro-agent")), \
+                    mock.patch.object(meter, "PI_AGENT_DIR", str(root / "no-pi-agent")), \
+                    mock.patch.object(meter, "HERMES_STATE_DB", str(root / "no-hermes.db")), \
+                    mock.patch.object(meter, "AGY_BRAIN_DIR", str(root / "no-agy-brain")), \
+                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
+                    mock.patch.object(meter, "claude_desktop_index", return_value={}):
+                sources = meter.all_session_sources()
+        self.assertEqual([row["id"] for row in sources], ["ses_top"])
+        found = meter.find_session("ses_top", sources)
+        self.assertEqual(found["path"], "opencode:ses_top")
+
+    def test_discovery_signature_follows_message_and_part_updates(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            top = self._session_row("ses_top", "/repo", "Live", "model-a",
+                                    0, 0, 0, 0, 0, 0, base)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         tuple(top.values()))
+            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)",
+                         ("m1", "ses_top", base, base + 10_000,
+                          json.dumps({"role": "user"})))
+            conn.execute("INSERT INTO part VALUES (?,?,?,?,?,?)",
+                         ("p1", "m1", "ses_top", base, base + 20_000,
+                          json.dumps({"type": "text"})))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                source = meter.opencode_session_sources()[0]
+        self.assertEqual(source["mtime"], base / 1000)
+        self.assertEqual(source["signature_mtime"], (base + 20_000) / 1000)
+
+    def test_agent_record_never_projects_private_identity_or_content(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/secret/workdir", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            child = self._session_row("ses_child", "/secret/workdir", "Child", "model-a",
+                                      0.75, 300, 60, 0, 0, 0, base + 1000,
+                                      parent_id="ses_top", agent="explore")
+            self._insert_sessions(conn, (parent, child))
+            conn.execute(
+                "INSERT INTO message VALUES (?,?,?,?,?)",
+                ("m1", "ses_child", base, base,
+                 json.dumps({"role": "user", "content": "private prompt text"})),
+            )
+            conn.execute(
+                "INSERT INTO part VALUES (?,?,?,?,?,?)",
+                ("p1", "m1", "ses_child", base, base,
+                 json.dumps({"type": "tool", "tool": "read", "input": "secret arg"})),
+            )
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = {row["id"]: row for row in meter.opencode_session_sources()}
+                meter._summary_cache.clear()
+                record = self._child_agent_row(sources["ses_child"])
+                row = meter.session_summary(sources["ses_child"])
+                public = agent_usage_projection(
+                    meter._domain_aggregate_agent_usage(
+                        meter._domain_build_agent_groups([row])
+                    )
+                )
+
+        serialized = json.dumps({"record": record, "public": public}, default=str)
+        for private in (
+            "/secret/workdir", "private prompt text", "secret arg", "workdir",
+        ):
+            self.assertNotIn(private, serialized)
+        # The agent and parent identities are opaque digests, never raw ids.
+        self.assertNotIn("ses_child", record["id"])
+        self.assertNotIn("ses_top", record["parent_id"])
+        # The established public session id stays, so the row is navigable.
+        self.assertEqual(record["session_id"], "ses_child")
+
+    def test_discovery_reuses_idle_database_inventory(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Idle", "model-a",
+                                    0, 0, 0, 0, 0, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         tuple(top.values()))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_native_adapters", {}):
+                first = meter.opencode_session_sources()
+                with mock.patch.object(
+                    meter.OpenCodeRuntimeAdapter, "connection",
+                    side_effect=AssertionError("unchanged database should use the inventory cache"),
+                ):
+                    second = meter.opencode_session_sources()
+        self.assertEqual(first, second)
+
+    def test_opencode_paths_and_model_catalog_are_xdg_aware_and_refreshable(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            models_path = root / "models.json"
+            with mock.patch.object(meter, "OPENCODE_DATA_ROOT", str(root / "data" / "opencode")), \
+                    mock.patch.object(meter, "OPENCODE_DB", "relative.db"):
+                self.assertEqual(
+                    meter.opencode_db_path(), str(root / "data" / "opencode" / "relative.db")
+                )
+            with mock.patch.object(meter, "OPENCODE_MODELS_PATH", str(models_path)), \
+                    mock.patch.object(meter, "_opencode_native_adapters", {}):
+                self.assertEqual(meter._load_opencode_models(), {})
+                models_path.write_text(json.dumps({
+                    "provider-a": {"models": {"shared": {"limit": {"context": 100}}}},
+                    "provider-b": {"models": {"shared": {"limit": {"context": 200}}}},
+                }))
+                self.assertEqual(meter._opencode_model_window("shared", "provider-a"), 100)
+                self.assertEqual(meter._opencode_model_window("shared", "provider-b"), 200)
+                self.assertIsNone(meter._opencode_model_window("shared"))
+                models_path.write_text(json.dumps({
+                    "provider-a": {"models": {"shared": {"limit": {"context": 300}}}},
+                }))
+                self.assertEqual(meter._opencode_model_window("shared", "provider-a"), 300)
+                self.assertEqual(meter._opencode_model_window("shared"), 300)
+
+    def test_recompute_opencode_reads_authoritative_tokens_and_cost(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
+                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
+                          top["directory"], top["title"], top["version"], top["time_created"],
+                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
+                          top["cost"], top["tokens_input"], top["tokens_output"],
+                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
+            for mid, sid, created, updated, data in self._sample_messages():
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
+            conn.execute("INSERT INTO part VALUES ('p0','msg3','ses_top',1,1,?)", (json.dumps({
+                "type": "text", "text": "  Follow   up  ",
+            }),))
+            conn.execute("INSERT INTO part VALUES ('p1','msg1','ses_top',1,1,?)", (json.dumps({
+                "type": "tool", "tool": "read", "callID": "call-1",
+                "state": {"status": "completed", "input": {"filePath": "/repo/a.py"},
+                          "output": "line one\nline two"},
+            }),))
+            conn.execute("INSERT INTO part VALUES ('p2','msg1','ses_top',1,1,?)", (json.dumps({
+                "type": "reasoning", "text": "think", "time": {"start": 1_784_548_800_100, "end": 1_784_548_800_900},
+            }),))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=200000):
+                state = meter.recompute_opencode({
+                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
+                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                    "path": "opencode:ses_top", "project": "/repo",
+                })
+        self.assertEqual(state["provider"], "opencode")
+        self.assertEqual(state["turns"], 2)
+        self.assertEqual(state["tokens"], {"input": 1500, "cache_write": 0, "cache_read": 300, "output": 300})
+        self.assertEqual(state["total_tokens"], 2150)
+        self.assertAlmostEqual(state["total_cost"], 0.015, places=6)
+        self.assertEqual(state["primary_model"], "deepseek-v4-pro")
+        self.assertTrue(state["availability"]["tokens"])
+        self.assertTrue(state["availability"]["cost"])
+        self.assertTrue(state["availability"]["context"])
+        self.assertTrue(state["timing"]["duration_available"])
+        self.assertEqual(state["timing"]["execution_count"], 2)
+        # Bucket split preserves the authoritative total.
+        self.assertAlmostEqual(sum(state["cost"][k] for k in ("input", "cache_write", "cache_read", "output")),
+                               state["total_cost"], places=6)
+        self.assertEqual(len(state["executions"]), 2)
+        self.assertEqual(state["executions"][0]["tool_count"], 1)
+        self.assertEqual(state["executions"][0]["tools"][0]["name"], "read")
+        self.assertGreater(state["executions"][0]["tools"][0]["output_tokens"], 0)
+        self.assertEqual(state["executions"][0]["reasoning_tokens"], 50)
+        self.assertEqual(state["executions"][0]["context_tokens"], 1550)
+        self.assertEqual(state["executions"][0]["duration_ms"], 5000)
+        self.assertEqual([row["user_message"] for row in state["series"]], ["", "Follow up"])
+        self.assertEqual([row["user_input"] for row in state["executions"]], ["", "Follow up"])
+        user_events = [event for event in state["trace"] if event["kind"] == "user"]
+        self.assertEqual([event["detail"] for event in user_events], ["Follow up"])
+        self.assertGreater(state["throughput"]["available"], False)
+
+    def test_recompute_dispatch_routes_opencode(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
+                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
+                          top["directory"], top["title"], top["version"], top["time_created"],
+                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
+                          top["cost"], top["tokens_input"], top["tokens_output"],
+                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
+            for mid, sid, created, updated, data in self._sample_messages():
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
+                    mock.patch.object(meter, "CODEX_SESSIONS", str(root / "no-codex")), \
+                    mock.patch.object(meter, "CODEX_INDEX", str(root / "no-index")), \
+                    mock.patch.object(meter, "CURSOR_PROJECTS", str(root / "no-cursor")), \
+                    mock.patch.object(meter, "claude_desktop_index", return_value={}):
+                state = meter.recompute({
+                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
+                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                    "path": "opencode:ses_top", "project": "/repo",
+                })
+        self.assertIsNotNone(state)
+        self.assertEqual(state["provider"], "opencode")
+
+    def test_recompute_handles_empty_and_zero_cost_sessions(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            top = self._session_row("ses_top", "/repo", "New session", "model-a",
+                                    0, 0, 0, 0, 0, 0, base)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         tuple(top.values()))
+            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (
+                "u1", "ses_top", base, base,
+                json.dumps({"role": "user", "time": {"created": base}}),
+            ))
+            conn.commit()
+            conn.close()
+            source = {
+                "provider": "opencode", "id": "ses_top", "model": "model-a",
+                "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                "path": "opencode:ses_top", "project": "/repo",
+            }
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
+                empty_state = meter.recompute_opencode(source)
+            self.assertEqual(empty_state["turns"], 0)
+            self.assertFalse(empty_state["timing"]["duration_available"])
+            self.assertTrue(empty_state["availability"]["cost"])
+
+            conn = sqlite3.connect(root / "opencode.db")
+            data = {
+                "role": "assistant", "modelID": "model-a", "providerID": "provider-a",
+                "tokens": {"input": 1, "output": 0, "reasoning": 1,
+                           "cache": {"read": 0, "write": 0}},
+                "cost": 0.0, "time": {"created": base + 1000, "completed": base + 2000},
+            }
+            conn.execute("INSERT INTO message VALUES (?,?,?,?,?)",
+                         ("a1", "ses_top", base + 1000, base + 2000, json.dumps(data)))
+            conn.execute("UPDATE session SET tokens_input=1,tokens_reasoning=1,time_updated=? WHERE id=?",
+                         (base, "ses_top"))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
+                zero_state = meter.recompute_opencode(source)
+            self.assertTrue(zero_state["availability"]["cost"])
+            self.assertTrue(zero_state["executions"][0]["availability"]["cost"])
+            self.assertEqual(zero_state["total_cost"], 0)
+            self.assertEqual(zero_state["total_tokens"], 2)
+
+    def test_detail_history_reports_truncation(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Long", "deepseek-v4-pro",
+                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         tuple(top.values()))
+            for row in self._sample_messages():
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", row)
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "OPENCODE_DETAIL_MESSAGE_LIMIT", 1), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=200000):
+                state = meter.recompute_opencode({
+                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
+                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                    "path": "opencode:ses_top", "project": "/repo",
+                })
+        self.assertTrue(state["execution_history_truncated"])
+        self.assertEqual(state["execution_history_limit"], 1)
+        self.assertEqual(len(state["executions"]), 1)
+
+    def test_opencode_database_is_read_only_and_not_a_delete_target(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
+                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
+                          top["directory"], top["title"], top["version"], top["time_created"],
+                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
+                          top["cost"], top["tokens_input"], top["tokens_output"],
+                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
+            for mid, sid, created, updated, data in self._sample_messages():
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
+            conn.execute("INSERT INTO part VALUES ('p1','msg1','ses_top',1,1,'{}')")
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                conn = meter._opencode_db_connection()
+                with self.assertRaises(sqlite3.OperationalError):
+                    conn.execute("DELETE FROM session WHERE id='ses_top'")
+                self.assertEqual(conn.execute("SELECT COUNT(*) FROM message").fetchone()[0], 3)
+                conn.close()
+        self.assertFalse(hasattr(meter, "remove_opencode_session"))
+        self.assertIn("opencode", meter.session_action_capability()["read_only_providers"])
+
+    def test_opencode_summary_reports_latest_context_pct(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
+                                    0.015, 1500, 300, 50, 300, 0, 1_784_548_900_000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         (top["id"], top["project_id"], top["parent_id"], top["slug"],
+                          top["directory"], top["title"], top["version"], top["time_created"],
+                          top["time_updated"], top["time_archived"], top["agent"], top["model"],
+                          top["cost"], top["tokens_input"], top["tokens_output"],
+                          top["tokens_reasoning"], top["tokens_cache_read"], top["tokens_cache_write"]))
+            for mid, sid, created, updated, data in self._sample_messages():
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", (mid, sid, created, updated, data))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=200000):
+                row = meter.opencode_summary({
+                    "provider": "opencode", "id": "ses_top", "model": "deepseek-v4-pro",
+                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                    "path": "opencode:ses_top", "project": "/repo", "title": "Explain it",
+                    "mtime": 1_784_548_900.0,
+                })
+        self.assertEqual(row["context"]["window"], 200000)
+        self.assertEqual(row["context"]["latest"], 600)
+        self.assertAlmostEqual(row["context"]["latest_pct"], 600 / 200000)
+        self.assertFalse(row["context"]["estimated"])
+        self.assertEqual(row["_context_samples"], [1550, 600])
+        self.assertTrue(row["availability"]["context"])
+
+    def test_opencode_summary_processes_only_newest_500_messages_in_order(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_800_000
+            top = self._session_row(
+                "ses_top", "/repo", "Long history", "model-a",
+                5.01, 501, 501, 0, 0, 0, base + 501_000,
+            )
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         tuple(top.values()))
+            for index in range(501):
+                created = base + index * 1_000
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", self._message(
+                    f"a{index:04d}", "ses_top", {
+                        "role": "assistant", "modelID": "model-a",
+                        "providerID": "provider-a",
+                        "tokens": {"input": 1, "output": 1, "reasoning": 0,
+                                   "cache": {"read": 0, "write": 0}},
+                        "cost": 0.01,
+                        "time": {"created": created, "completed": created + 500},
+                    }, created,
+                ))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=1_000):
+                row = meter.opencode_summary({
+                    "provider": "opencode", "id": "ses_top", "model": "model-a",
+                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                    "path": "opencode:ses_top", "project": "/repo",
+                    "mtime": (base + 501_000) / 1_000,
+                })
+
+        self.assertEqual(row["turns"], 500)
+        self.assertEqual(len(row["_performance_samples"]), 500)
+        self.assertEqual(row["_performance_samples"][0]["ts"], (base + 1_500) / 1_000)
+        self.assertEqual(row["_performance_samples"][-1]["ts"], (base + 500_500) / 1_000)
+        self.assertEqual(row["tokens"], 1_002)
+
+    def test_opencode_summary_attributes_models_and_calendar_days_per_message(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            # Naive local noon, because the adapter groups cost by local day
+            # (time.localtime). A UTC-built instant lands on the next day east
+            # of UTC, which would move the cost out of the asserted bucket.
+            jan = int(datetime.datetime(2026, 1, 31, 12).timestamp() * 1000)
+            feb = int(datetime.datetime(2026, 2, 1, 12).timestamp() * 1000)
+            top = self._session_row("ses_top", "/repo", "Across months", "model-b",
+                                    0.1, 30, 7, 5, 3, 2, feb + 1000)
+            conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                         tuple(top.values()))
+            messages = [
+                self._message("a1", "ses_top", {
+                    "role": "assistant", "modelID": "model-a", "providerID": "provider-a",
+                    "tokens": {"input": 10, "output": 4, "reasoning": 2,
+                               "cache": {"read": 3, "write": 0}},
+                    "cost": 0.1, "time": {"created": jan, "completed": jan + 1000},
+                }, jan),
+                self._message("a2", "ses_top", {
+                    "role": "assistant", "modelID": "model-b", "providerID": "provider-b",
+                    "tokens": {"input": 20, "output": 3, "reasoning": 3,
+                               "cache": {"read": 0, "write": 2}},
+                    "cost": 0.0, "time": {"created": feb, "completed": feb + 1000},
+                }, feb),
+            ]
+            for row in messages:
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", row)
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
+                row = meter.opencode_summary({
+                    "provider": "opencode", "id": "ses_top", "model": "model-b",
+                    "label": "OpenCode", "runtime": "OpenCode", "session": "ses_top",
+                    "path": "opencode:ses_top", "project": "/repo", "mtime": feb / 1000,
+                })
+        self.assertEqual(row["turns"], 2)
+        self.assertEqual(row["tokens"], 47)
+        self.assertEqual(row["_day_cost"], {"2026-01-31": 0.1, "2026-02-01": 0.0})
+        self.assertEqual(row["_model_tok"], {"model-a": 19, "model-b": 28})
+        self.assertEqual({item["model"]: item["executions"] for item in row["model_stats"]},
+                         {"model-a": 1, "model-b": 1})
+        model_b = next(item for item in row["model_stats"] if item["model"] == "model-b")
+        model_a = next(item for item in row["model_stats"] if item["model"] == "model-a")
+        self.assertTrue(model_b["availability"]["cost"])
+        self.assertEqual((model_a["cache_read_tokens"], model_a["cache_write_tokens"]),
+                         (3, 0))
+        self.assertEqual((model_a["reasoning_tokens"], model_a["reasoning_output_tokens"]),
+                         (2, 6))
+        self.assertEqual(model_a["reasoning_executions"], 1)
+        self.assertEqual((model_b["cache_read_tokens"], model_b["cache_write_tokens"]),
+                         (0, 2))
+        self.assertEqual((model_b["reasoning_tokens"], model_b["reasoning_output_tokens"]),
+                         (3, 6))
+        self.assertEqual(model_b["reasoning_executions"], 1)
+        self.assertEqual({item["day"] for item in row["_model_daily"]},
+                         {"2026-01-31", "2026-02-01"})
+
+    def test_opencode_efficiency_denominators_exclude_uncovered_messages(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            ts = int(datetime.datetime(
+                2026, 8, 27, 12, tzinfo=datetime.timezone.utc,
+            ).timestamp() * 1000)
+            top = self._session_row(
+                "ses_coverage", "/repo", "Mixed evidence", "model-a",
+                0.1, 110, 110, 0, 0, 0, ts + 4000,
+            )
+            conn.execute(
+                "INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                tuple(top.values()),
+            )
+            messages = [
+                self._message("a1", "ses_coverage", {
+                    "role": "assistant", "modelID": "model-a",
+                    "tokens": {"input": 10, "output": 10}, "cost": 0.1,
+                    "time": {"created": ts, "completed": ts + 1000},
+                }, ts),
+                self._message("a2", "ses_coverage", {
+                    "role": "assistant", "modelID": "model-a",
+                    "tokens": {"input": 100, "output": 100},
+                    "time": {"created": ts + 1000, "completed": ts + 2000},
+                }, ts + 1000),
+                self._message("a3", "ses_coverage", {
+                    "role": "assistant", "modelID": "model-a",
+                    "time": {"created": ts + 2000, "completed": ts + 3000},
+                }, ts + 2000),
+                self._message("a4", "ses_coverage", {
+                    "role": "assistant", "modelID": "model-a", "tokens": {},
+                    "time": {"created": ts + 3000, "completed": ts + 3500},
+                }, ts + 3000),
+                self._message("a5", "ses_coverage", {
+                    "role": "assistant", "modelID": "model-a",
+                    "tokens": {"input": "50", "output": "20"},
+                    "time": {"created": ts + 3500, "completed": ts + 4000},
+                }, ts + 3500),
+            ]
+            for message in messages:
+                conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", message)
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")), \
+                    mock.patch.object(meter, "_opencode_model_window", return_value=1000):
+                session = meter.opencode_summary({
+                    "provider": "opencode", "id": "ses_coverage",
+                    "model": "model-a", "label": "OpenCode", "runtime": "OpenCode",
+                    "session": "ses_coverage", "path": "opencode:ses_coverage",
+                    "project": "/repo", "mtime": ts / 1000,
+                })
+
+        stats = session["model_stats"][0]
+        self.assertEqual(stats["executions"], 5)
+        self.assertEqual(stats["input_tokens"], 110)
+        self.assertEqual(stats["output_tokens"], 110)
+        self.assertEqual(stats["token_covered_executions"], 2)
+        self.assertEqual(stats["cache_covered_input_tokens"], 110)
+        self.assertEqual(stats["cost_covered_executions"], 1)
+        self.assertEqual(stats["cost_covered_output_tokens"], 10)
+        aggregate = meter.aggregate_model_stats([session])["models"][0]
+        self.assertEqual(aggregate["cost_covered_output_tokens"], 10)
+        self.assertEqual(aggregate["token_covered_executions"], 2)
+        self.assertFalse(aggregate["coverage"]["cost"]["complete"])
+        self.assertEqual(aggregate["daily"][0]["cost_covered_output_tokens"], 10)
+        self.assertEqual(aggregate["daily"][0]["token_covered_executions"], 2)
+        self.assertFalse(aggregate["daily"][0]["coverage"]["tokens"]["complete"])
+
+    def test_opencode_budget_defaults_and_distribute_cost(self):
+        with mock.patch.object(meter, "OPENCODE_DB", str(Path("/nonexistent/opencode.db"))):
+            settings = meter.normalize_budget_settings({"allocations": {}})
+        self.assertEqual(settings["allocations"]["opencode"], meter.DEFAULT_RUNTIME_BUDGET)
+        self.assertEqual(settings["allocations"]["kiro"], meter.DEFAULT_RUNTIME_BUDGET)
+        usage = {"input_tokens": 1000, "cache_creation_input_tokens": 0,
+                 "cache_read_input_tokens": 500, "output_tokens": 100, "reasoning_tokens": 50}
+        split = meter._opencode_distribute(0.02, usage)
+        self.assertAlmostEqual(sum(split.values()), 0.02, places=6)
+        self.assertEqual(meter._opencode_distribute(0.0, usage)["output"], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_opencode_subagents.py b/tests/test_opencode_subagents.py
new file mode 100644
index 00000000..8d3fc767
--- /dev/null
+++ b/tests/test_opencode_subagents.py
@@ -0,0 +1,889 @@
+import unittest
+import json
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from token_meter.projections import agent_usage_projection
+from tests.dashboard_page import DASHBOARD_PAGE
+from tests.opencode_test_support import OpenCodeCase
+
+
+class OpenCodeChildRunTests(OpenCodeCase):
+    def test_discovery_labels_roots_and_child_sessions_and_filters_archived(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            top = self._session_row("ses_top", "/repo", "Explain it", "deepseek-v4-pro",
+                                    0.5, 1000, 200, 50, 300, 0, 1_784_548_900_000)
+            child = self._session_row("ses_child", "/repo", "subagent work", "deepseek-v4-flash",
+                                      0.1, 100, 50, 0, 0, 0, 1_784_548_950_000, parent_id="ses_top")
+            archived = self._session_row("ses_arch", "/repo", "old", "deepseek-v4-pro",
+                                         0.2, 100, 50, 0, 0, 0, 1_784_548_980_000, archived=1_784_549_000_000)
+            for row in (top, child, archived):
+                conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                             (row["id"], row["project_id"], row["parent_id"], row["slug"],
+                              row["directory"], row["title"], row["version"], row["time_created"],
+                              row["time_updated"], row["time_archived"], row["agent"], row["model"],
+                              row["cost"], row["tokens_input"], row["tokens_output"],
+                              row["tokens_reasoning"], row["tokens_cache_read"], row["tokens_cache_write"]))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(db_path := root / "opencode.db")):
+                sources = meter.opencode_session_sources()
+        # Child sessions are discovered so their spend reaches totals, and only
+        # the archived session stays hidden.
+        self.assertEqual(
+            [row["id"] for row in sources], ["ses_child", "ses_top"],
+        )
+        by_id = {row["id"]: row for row in sources}
+        source = by_id["ses_top"]
+        self.assertEqual(source["provider"], "opencode")
+        self.assertEqual(source["label"], "OpenCode")
+        self.assertEqual(source["runtime"], "OpenCode")
+        self.assertEqual(source["model"], "deepseek-v4-pro")
+        self.assertEqual(source["project"], "/repo")
+        self.assertEqual(source["path"], "opencode:ses_top")
+        self.assertAlmostEqual(source["mtime"], 1_784_548_900.0)
+        self.assertEqual(source["signature_mtime"], source["mtime"])
+        self.assertEqual(meter.source_runtime_label(source), "OpenCode")
+
+        # A child records its private parent reference and role, and resolves its
+        # project from the parent root rather than its own agent column.
+        child_source = by_id["ses_child"]
+        self.assertEqual(child_source["agent_parent_id"], "ses_top")
+        self.assertEqual(child_source["agent_depth"], 1)
+        self.assertEqual(child_source["project"], "/repo")
+        self.assertEqual(child_source["path"], "opencode:ses_child")
+        self.assertNotIn("ses_arch", by_id)
+
+    def test_child_session_spend_is_additive_and_not_double_counted(self):
+        """Parent cost excludes child cost, so totals gain exactly the children."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            # The parent costs less than its children combined, matching the
+            # observed OpenCode shape where child spend is additive.
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       1.25, 1000, 200, 0, 0, 0, base)
+            child_a = self._session_row("ses_a", "/repo", "Child A", "model-a",
+                                        3.00, 100, 50, 0, 0, 0, base + 1000,
+                                        parent_id="ses_top", agent="gsd-planner")
+            child_b = self._session_row("ses_b", "/repo", "Child B", "model-b",
+                                        4.50, 200, 60, 0, 0, 0, base + 2000,
+                                        parent_id="ses_top", agent="explore")
+            self._insert_sessions(conn, (parent, child_a, child_b))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = meter.opencode_session_sources()
+                by_id = {row["id"]: row for row in sources}
+                meter._summary_cache.clear()
+                costs = {
+                    sid: meter.session_summary(row)["cost"]
+                    for sid, row in sorted(by_id.items())
+                }
+                rows = {sid: meter.session_summary(row) for sid, row in by_id.items()}
+                groups = meter._domain_build_agent_groups([
+                    rows[sid] for sid in sorted(rows)
+                ])
+                public = agent_usage_projection(
+                    meter._domain_aggregate_agent_usage(groups)
+                )
+
+        self.assertEqual(sorted(costs), ["ses_a", "ses_b", "ses_top"])
+        self.assertAlmostEqual(costs["ses_top"], 1.25)
+        self.assertAlmostEqual(costs["ses_a"], 3.00)
+        self.assertAlmostEqual(costs["ses_b"], 4.50)
+        # Additive, never folded into the parent headline.
+        self.assertAlmostEqual(sum(costs.values()), 8.75)
+        self.assertGreater(sum(costs.values()), costs["ses_top"])
+
+        # One group forms, and the subagent rollup counts children only.
+        self.assertEqual(len(groups), 1)
+        group = groups[0]
+        self.assertEqual(len(group["agents"]), 3)
+        self.assertAlmostEqual(group["totals"]["cost"], 8.75)
+        self.assertEqual(public["totals"]["agents"], 2)
+        self.assertAlmostEqual(public["totals"]["cost"], 7.50)
+        self.assertEqual(public["totals"]["parent_sessions"], 1)
+        # The parent's own work is never counted as subagent spend.
+        self.assertLess(
+            public["totals"]["cost"], group["totals"]["cost"],
+        )
+        roles = {row["role"] for row in public["roles"]}
+        self.assertIn("gsd-planner", roles)
+        self.assertIn("explore", roles)
+
+    def test_child_emits_one_spawned_record_with_opaque_identity(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            child = self._session_row("ses_child", "/repo", "Child", "model-a",
+                                      0.75, 300, 60, 0, 0, 0, base + 1000,
+                                      parent_id="ses_top", agent="gsd-executor")
+            self._insert_sessions(conn, (parent, child))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = {row["id"]: row for row in meter.opencode_session_sources()}
+                meter._summary_cache.clear()
+                record = self._child_agent_row(sources["ses_child"])
+
+        self.assertEqual(record["kind"], "spawned")
+        self.assertEqual(record["depth"], 1)
+        self.assertEqual(record["runtime"], "opencode")
+        self.assertEqual(record["role"], "gsd-executor")
+        self.assertTrue(record["id"].startswith("opencode-agent-"))
+        self.assertTrue(record["parent_id"].startswith("opencode-agent-"))
+        # Identity is a digest: neither the child nor the parent session id leaks.
+        self.assertNotIn("ses_child", record["id"])
+        self.assertNotIn("ses_top", record["parent_id"])
+        self.assertEqual(record["cost"], 0.75)
+        self.assertTrue(record["cost_available"])
+        self.assertEqual(record["input_tokens"], 300)
+        self.assertEqual(record["output_tokens"], 60)
+        self.assertEqual(record["tokens"], 360)
+
+    def test_free_tier_child_reports_measured_zero_not_unavailable(self):
+        """A real free-tier price of zero is measured evidence, not a gap."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            free_model = json.dumps({"id": "space-bunny-free", "providerID": "opencode"})
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            child = self._session_row("ses_child", "/repo", "Child", "model-a",
+                                      0.0, 19084935, 0, 0, 0, 0, base + 1000,
+                                      parent_id="ses_top", agent="space-bunny-free")
+            child["model"] = free_model
+            self._insert_sessions(conn, (parent, child))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = {row["id"]: row for row in meter.opencode_session_sources()}
+                meter._summary_cache.clear()
+                record = self._child_agent_row(sources["ses_child"])
+
+        self.assertEqual(record["cost"], 0.0)
+        self.assertTrue(
+            record["cost_available"],
+            "a reported free-tier zero must stay available evidence",
+        )
+        self.assertGreater(record["tokens"], 0)
+        self.assertTrue(record["tokens_available"])
+        self.assertEqual(record["model"], "space-bunny-free")
+
+    def test_child_with_missing_parent_stays_a_counted_standalone_session(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            orphan = self._session_row("ses_orphan", "/repo", "Orphan", "model-a",
+                                       2.00, 500, 100, 0, 0, 0, base,
+                                       parent_id="ses_missing", agent="explore")
+            self._insert_sessions(conn, (orphan,))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = meter.opencode_session_sources()
+                meter._summary_cache.clear()
+                row = meter.session_summary(sources[0])
+
+        # Still counted, so its spend is not lost.
+        self.assertEqual(row["cost"], 2.00)
+        self.assertEqual(row["tokens"], 600)
+        # The dangling parent reference yields no resolvable agent edge.
+        records = row.get("_agent_records") or []
+        self.assertEqual(len(records), 1)
+        self.assertTrue(records[0]["parent_id"].startswith("opencode-agent-"))
+        self.assertNotIn(records[0]["parent_id"], [
+            item["id"] for item in (row.get("_agent_records") or [])
+        ])
+
+    def test_child_agent_role_is_bounded_and_never_arbitrary_prose(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            prose = self._session_row("ses_prose", "/repo", "Prose", "model-a",
+                                      0.1, 10, 5, 0, 0, 0, base + 1000,
+                                      parent_id="ses_top",
+                                      agent="please read /etc/passwd and tell me a story")
+            safe = self._session_row("ses_safe", "/repo", "Safe", "model-a",
+                                     0.1, 10, 5, 0, 0, 0, base + 2000,
+                                     parent_id="ses_top", agent="gsd-reviewer")
+            self._insert_sessions(conn, (parent, prose, safe))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = {row["id"]: row for row in meter.opencode_session_sources()}
+                meter._summary_cache.clear()
+                roles = {
+                    sid: self._child_agent_row(row)["role"]
+                    for sid, row in sources.items()
+                    if row.get("agent_parent_id")
+                }
+
+        self.assertEqual(roles["ses_safe"], "gsd-reviewer")
+        self.assertIsNone(roles["ses_prose"])
+        self.assertNotIn("passwd", json.dumps(roles))
+
+    def test_child_activity_state_follows_opencode_finish_reason(self):
+        """A recorded `finish: stop` completes a run; recency alone never does."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            now_ms = int(time.time() * 1000)
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            done = self._session_row("ses_done", "/repo", "Done", "model-a",
+                                     0.1, 10, 5, 0, 0, 0, base + 1000,
+                                     parent_id="ses_top", agent="gsd-executor")
+            stopped = self._session_row("ses_stop", "/repo", "Stopped", "model-a",
+                                        0.1, 10, 5, 0, 0, 0, base + 2000,
+                                        parent_id="ses_top", agent="gsd-executor")
+            resumed = self._session_row("ses_resumed", "/repo", "Resumed", "model-a",
+                                        0.1, 10, 5, 0, 0, 0, base + 3000,
+                                        parent_id="ses_top", agent="gsd-executor")
+            unfinished = self._session_row("ses_open", "/repo", "Open", "model-a",
+                                           0.1, 10, 5, 0, 0, 0, base + 4000,
+                                           parent_id="ses_top", agent="gsd-executor")
+            live = self._session_row("ses_live", "/repo", "Live", "model-a",
+                                     0.1, 10, 5, 0, 0, 0, now_ms,
+                                     parent_id="ses_top", agent="gsd-executor")
+            truncated = self._session_row("ses_trunc", "/repo", "Truncated",
+                                          "model-a",
+                                          0.1, 10, 5, 0, 0, 0, base + 5000,
+                                          parent_id="ses_top", agent="gsd-executor")
+            self._insert_sessions(
+                conn, (parent, done, stopped, resumed, unfinished, live, truncated),
+            )
+            for mid, sid, created, role, finish in (
+                ("done-u", "ses_done", base, "user", None),
+                ("done-a", "ses_done", base + 10, "assistant", "stop"),
+                ("stop-u", "ses_stop", base + 1000, "user", None),
+                ("stop-a", "ses_stop", base + 1010, "assistant", "tool-calls"),
+                ("resumed-u", "ses_resumed", base + 2000, "user", None),
+                ("resumed-a", "ses_resumed", base + 2010, "assistant", "stop"),
+                ("resumed-u2", "ses_resumed", base + 2020, "user", None),
+                ("open-u", "ses_open", base + 3000, "user", None),
+                ("open-a", "ses_open", base + 3010, "assistant", None),
+                ("live-u", "ses_live", now_ms - 1000, "user", None),
+                ("live-a", "ses_live", now_ms - 500, "assistant", "tool-calls"),
+                ("trunc-u", "ses_trunc", base + 4000, "user", None),
+                ("trunc-a", "ses_trunc", base + 4010, "assistant", "length"),
+            ):
+                data = {"role": role, "time": {"created": created}}
+                if finish is not None:
+                    data["finish"] = finish
+                conn.execute(
+                    "INSERT INTO message VALUES (?,?,?,?,?)",
+                    (mid, sid, created, created, json.dumps(data)),
+                )
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = {row["id"]: row for row in meter.opencode_session_sources()}
+                meter._summary_cache.clear()
+                states = {
+                    sid: self._child_agent_row(row)["activity_state"]
+                    for sid, row in sources.items()
+                    if row.get("agent_parent_id")
+                }
+
+        # `stop` is the only confirmed finish, and only when nothing resumes it.
+        self.assertEqual(states["ses_done"], "complete")
+        self.assertEqual(states["ses_resumed"], "incomplete")
+        # Mid-loop, missing, and length-truncated turns stay nonterminal.
+        self.assertEqual(states["ses_stop"], "incomplete")
+        self.assertEqual(states["ses_open"], "incomplete")
+        # A nonterminal run that is still active reads as working, not complete.
+        self.assertEqual(states["ses_live"], "working")
+        # A length-truncated turn is not a confirmed finish either.
+        self.assertEqual(states["ses_trunc"], "incomplete")
+
+    def test_child_sessions_reach_aggregate_totals_without_a_second_session(self):
+        """canonical_agent_sources selects each child once and keeps accounting."""
+        sources = [
+            {"provider": "opencode", "id": "ses_top", "path": "opencode:ses_top",
+             "mtime": 10.0, "signature_mtime": 10.0},
+            {"provider": "opencode", "id": "ses_child", "path": "opencode:ses_child",
+             "mtime": 20.0, "signature_mtime": 20.0,
+             "agent_parent_id": "ses_top", "agent_depth": 1},
+            {"provider": "claude", "id": "claude-1", "path": "/trace.jsonl",
+             "mtime": 5.0, "signature_mtime": 5.0},
+        ]
+        selected = meter.canonical_agent_sources(sources)
+
+        self.assertEqual(
+            sorted(row["id"] for row in selected),
+            ["claude-1", "ses_child", "ses_top"],
+        )
+        # Accounting sources are untouched by the agent selection.
+        self.assertEqual(
+            sorted(row["id"] for row in meter.canonical_aggregation_sources(sources)),
+            ["claude-1", "ses_child", "ses_top"],
+        )
+
+    def test_old_child_reports_incomplete_not_complete(self):
+        """A child with no terminal evidence is a stale nonterminal trace."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            # One hour old: past the working window, with no terminal evidence.
+            old_child = self._session_row("ses_old", "/repo", "Old child", "model-a",
+                                          0.1, 10, 5, 0, 0, 0, base - 3_600_000,
+                                          parent_id="ses_top", agent="explore")
+            self._insert_sessions(conn, (parent, old_child))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = {row["id"]: row for row in meter.opencode_session_sources()}
+                meter._summary_cache.clear()
+                record = self._child_agent_row(sources["ses_old"])
+
+        self.assertEqual(record["activity_state"], "incomplete")
+        self.assertNotEqual(record["activity_state"], "complete")
+        self.assertNotEqual(record["activity_state"], "recent")
+
+    def test_parent_with_only_archived_children_emits_no_root_record(self):
+        """A parent whose children are all archived has no live child group."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            conn = self._build_db(root)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            archived_child = self._session_row(
+                "ses_arch", "/repo", "Archived child", "model-a",
+                0.1, 10, 5, 0, 0, 0, base + 1000,
+                parent_id="ses_top", agent="explore", archived=base + 2000,
+            )
+            self._insert_sessions(conn, (parent, archived_child))
+            conn.commit()
+            conn.close()
+            with mock.patch.object(meter, "OPENCODE_DB", str(root / "opencode.db")):
+                sources = meter.opencode_session_sources()
+                meter._summary_cache.clear()
+                rows = [meter.session_summary(s) for s in sources]
+
+        # The archived child is not discovered, so the parent has no live
+        # children and must not emit a root record for a group that cannot form.
+        self.assertEqual([row["id"] for row in rows], ["ses_top"])
+        self.assertFalse(rows[0].get("_agent_records"))
+
+    def test_child_parent_id_stays_out_of_allowlisted_projections(self):
+        """Raw parent linkage never reaches sessions, /logs rows, or Subagents."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       0.5, 100, 20, 0, 0, 0, base)
+            child = self._session_row("ses_child", "/repo", "Child", "model-a",
+                                      0.75, 300, 60, 0, 0, 0, base + 1000,
+                                      parent_id="ses_top", agent="explore")
+            orphan = self._session_row("ses_orphan", "/repo", "Orphan", "model-a",
+                                       0.25, 30, 6, 0, 0, 0, base + 2000,
+                                       parent_id="ses_private_missing", agent="explore")
+            db_path = self._family_db(root, base, (parent, child, orphan))
+            _sources, cross, family_rows = self._cross(db_path)
+
+        by_id = {row["id"]: row for row in cross["sessions"]}
+        public = json.dumps({
+            "sessions": cross["sessions"], "family": family_rows,
+            "agent_usage": agent_usage_projection(cross["agent_usage"]),
+        }, default=str)
+        self.assertNotIn("child_parent_id", public)
+        # The unlisted parent reference of an orphan never leaves the server.
+        self.assertNotIn("ses_private_missing", public)
+        # Only the resolved, listed root id is published on a child row.
+        self.assertEqual(by_id["ses_child"]["root_session_id"], "ses_top")
+        self.assertTrue(by_id["ses_child"]["is_child_session"])
+        self.assertNotIn("root_session_id", by_id["ses_orphan"])
+        self.assertNotIn("root_session_id", by_id["ses_top"])
+
+    def test_archived_root_excludes_its_whole_family_from_totals(self):
+        """An archived root hides its children and grandchildren, as before."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = 1_784_548_900_000
+            rows = (
+                self._session_row("ses_arch", "/old", "Archived", "model-a",
+                                  1.00, 10, 5, 0, 0, 0, base, archived=base + 9000),
+                self._session_row("ses_arch_child", "/old", "Archived child", "model-a",
+                                  2.00, 10, 5, 0, 0, 0, base + 1000,
+                                  parent_id="ses_arch", agent="explore"),
+                self._session_row("ses_arch_grand", "/old", "Archived grandchild", "model-a",
+                                  4.00, 10, 5, 0, 0, 0, base + 2000,
+                                  parent_id="ses_arch_child", agent="explore"),
+                self._session_row("ses_live", "/repo", "Live", "model-a",
+                                  0.50, 10, 5, 0, 0, 0, base + 3000),
+                self._session_row("ses_live_child", "/repo", "Live child", "model-a",
+                                  0.25, 10, 5, 0, 0, 0, base + 4000,
+                                  parent_id="ses_live", agent="explore"),
+            )
+            db_path = self._family_db(root, base, rows)
+            sources, cross, _family = self._cross(db_path)
+
+        ids = sorted(row["id"] for row in sources)
+        self.assertEqual(ids, ["ses_live", "ses_live_child"])
+        self.assertAlmostEqual(cross["total_cost"], 0.75)
+        self.assertEqual(cross["total_sessions"], 2)
+        # Nothing is left looking like an unattributed child of an archived parent.
+        self.assertEqual(cross["agent_usage"]["totals"]["unresolved_agents"], 0)
+        self.assertNotIn("ses_arch", json.dumps(cross["sessions"]))
+
+    def test_missing_parent_is_the_only_unresolved_family(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = 1_784_548_900_000
+            rows = (
+                self._session_row("ses_live", "/repo", "Live", "model-a",
+                                  0.50, 10, 5, 0, 0, 0, base),
+                self._session_row("ses_orphan", "/repo", "Orphan", "model-a",
+                                  0.40, 10, 5, 0, 0, 0, base + 1000,
+                                  parent_id="ses_gone", agent="explore"),
+            )
+            db_path = self._family_db(root, base, rows)
+            _sources, cross, _family = self._cross(db_path)
+
+        self.assertAlmostEqual(cross["total_cost"], 0.90)
+        self.assertEqual(cross["agent_usage"]["totals"]["unresolved_agents"], 1)
+        self.assertAlmostEqual(
+            cross["agent_usage"]["totals"]["unresolved_known_cost"], 0.40,
+        )
+
+    def test_grandchild_resolves_root_project_depth_and_root_session(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = 1_784_548_900_000
+            rows = (
+                self._session_row("ses_root", "/repo/root", "Root", "model-a",
+                                  0.50, 10, 5, 0, 0, 0, base),
+                self._session_row("ses_mid", "/repo/mid", "Mid", "model-a",
+                                  0.25, 10, 5, 0, 0, 0, base + 1000,
+                                  parent_id="ses_root", agent="explore"),
+                self._session_row("ses_leaf", "/repo/leaf", "Leaf", "model-a",
+                                  0.125, 10, 5, 0, 0, 0, base + 2000,
+                                  parent_id="ses_mid", agent="gsd-reviewer"),
+            )
+            db_path = self._family_db(root, base, rows)
+            sources, cross, _family = self._cross(db_path)
+            with mock.patch.object(meter, "OPENCODE_DB", str(db_path)):
+                meter._summary_cache.clear()
+                by_source = {row["id"]: row for row in sources}
+                leaf_record = self._child_agent_row(by_source["ses_leaf"])
+                meter._summary_cache.clear()
+
+        by_source = {row["id"]: row for row in sources}
+        self.assertEqual(by_source["ses_leaf"]["project"], "/repo/root")
+        self.assertEqual(by_source["ses_mid"]["project"], "/repo/root")
+        self.assertEqual(by_source["ses_leaf"]["agent_depth"], 2)
+        self.assertEqual(by_source["ses_mid"]["agent_depth"], 1)
+        self.assertEqual(by_source["ses_leaf"]["agent_root_id"], "ses_root")
+        self.assertTrue(by_source["ses_mid"]["agent_has_children"])
+        self.assertEqual(leaf_record["depth"], 2)
+        sessions = {row["id"]: row for row in cross["sessions"]}
+        self.assertEqual(sessions["ses_leaf"]["root_session_id"], "ses_root")
+        self.assertEqual(sessions["ses_leaf"]["child_depth"], 2)
+        self.assertAlmostEqual(cross["total_cost"], 0.875)
+        self.assertEqual(cross["agent_usage"]["totals"]["unresolved_agents"], 0)
+        self.assertEqual(cross["agent_usage"]["totals"]["agents"], 2)
+
+    def test_parent_cost_excludes_children_so_headline_is_parent_plus_children(self):
+        """Pin the additive assumption against message-level parent evidence."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = 1_784_548_900_000
+            rows = (
+                self._session_row("ses_top", "/repo", "Root", "model-a",
+                                  1.25, 10, 5, 0, 0, 0, base),
+                self._session_row("ses_a", "/repo", "A", "model-a",
+                                  3.00, 10, 5, 0, 0, 0, base + 1000,
+                                  parent_id="ses_top", agent="explore"),
+            )
+            db_path = self._family_db(root, base, rows)
+            _sources, cross, family = self._cross(db_path)
+
+        costs = {row["id"]: row["cost"] for row in cross["sessions"]}
+        self.assertAlmostEqual(costs["ses_top"], 1.25)
+        self.assertAlmostEqual(cross["total_cost"], 4.25)
+        self.assertFalse(any("_cost_includes_children" in row for row in family))
+
+    def test_parent_cost_above_own_messages_is_kept_and_children_added(self):
+        """A parent reporting more than its own message sum is never reduced.
+
+        Reverted messages leave a parent's session cost above its remaining
+        message-level cost; that gap must not be read as included child spend.
+        """
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = 1_784_548_900_000
+            parent = self._session_row("ses_top", "/repo", "Root", "model-a",
+                                       3.00, 10, 5, 0, 0, 0, base)
+            child = self._session_row("ses_a", "/repo", "A", "model-a",
+                                      0.50, 10, 5, 0, 0, 0, base + 1000,
+                                      parent_id="ses_top", agent="explore")
+            conn = self._build_db(root)
+            self._insert_sessions(conn, (parent, child))
+            self._assistant(conn, "m-top", "ses_top", 1.00, base)
+            self._assistant(conn, "m-a", "ses_a", 0.50, base + 1)
+            conn.commit()
+            conn.close()
+            _sources, cross, family = self._cross(root / "opencode.db")
+
+        costs = {row["id"]: row["cost"] for row in cross["sessions"]}
+        self.assertAlmostEqual(costs["ses_top"], 3.00)
+        self.assertAlmostEqual(costs["ses_a"], 0.50)
+        self.assertAlmostEqual(sum(row["cost"] for row in family), 3.50)
+
+    def test_live_child_runs_fold_into_one_current_root_session(self):
+        """Root + active child + grandchild form one current session and one cap."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            now_ms = int(time.time() * 1000)
+            # The root itself is idle; only its descendants are active.
+            rows = (
+                self._session_row("ses_root", "/repo", "Root", "model-a",
+                                  1.00, 10, 5, 0, 0, 0, now_ms - 40 * 60_000),
+                self._session_row("ses_child", "/repo", "Child", "model-a",
+                                  2.00, 20, 10, 0, 0, 0, now_ms - 30_000,
+                                  parent_id="ses_root", agent="explore"),
+                self._session_row("ses_grand", "/repo", "Grand", "model-a",
+                                  4.00, 40, 20, 0, 0, 0, now_ms - 20_000,
+                                  parent_id="ses_child", agent="explore"),
+            )
+            db_path = self._family_db(root, now_ms - 50 * 60_000, rows)
+            sources, cross, family = self._cross(db_path)
+
+        current = cross["current_sessions"]
+        self.assertEqual([row["id"] for row in current], ["ses_root"])
+        self.assertAlmostEqual(current[0]["cost"], 7.00)
+        self.assertEqual(current[0]["turns"], 3)
+        self.assertNotIn("subagent_runs", current[0])
+        self.assertFalse(current[0]["cost_partial"])
+        self.assertEqual(current[0]["activity_state"], "working")
+
+        # The native recent-session list offers the root, never a child run.
+        recent = meter.menubar_recent_sessions(sources, summaries=current)
+        self.assertEqual([row["id"] for row in recent], ["ses_root"])
+        # The watcher's live source is the root even though a child is newest.
+        self.assertEqual(meter.newest_current_source(sources)["id"], "ses_root")
+
+        # A child run has no separate cap: it reports the root's cap, and the
+        # root cap's spend includes every child run.
+        settings = meter.normalize_budget_settings({})
+        with mock.patch.dict(meter._xsess, {"sessions": family}):
+            root_snapshot = meter.session_budget_snapshot(
+                {"id": "ses_root"}, {"total_cost": 1.0, "availability": {"cost": True}},
+                settings,
+            )
+            child_snapshot = meter.session_budget_snapshot(
+                {"id": "ses_grand"}, {"total_cost": 4.0, "availability": {"cost": True}},
+                settings,
+            )
+        self.assertEqual(root_snapshot["id"], "ses_root")
+        self.assertAlmostEqual(root_snapshot["spend_usd"], 7.0)
+        self.assertNotIn("subagent_runs", root_snapshot)
+        self.assertFalse(root_snapshot["cost_partial"])
+        self.assertEqual(child_snapshot["id"], "ses_root")
+        self.assertAlmostEqual(child_snapshot["spend_usd"], 7.0)
+
+    def test_session_cap_spend_combines_family_cost_availability(self):
+        """Measured family spend is kept and any unavailable member is partial."""
+        def family(root_available, child_available):
+            return [
+                {"id": "ses_root", "provider": "opencode", "cost": 1.0,
+                 "availability": {"cost": root_available}},
+                {"id": "ses_child", "provider": "opencode", "cost": 2.5,
+                 "is_child_session": True, "root_session_id": "ses_root",
+                 "availability": {"cost": child_available}},
+            ]
+
+        settings = meter.normalize_budget_settings({})
+        with mock.patch.dict(meter._xsess, {"sessions": family(False, True)}):
+            unavailable_root = meter.session_budget_snapshot(
+                {"id": "ses_root"},
+                {"total_cost": 0.0, "availability": {"cost": False}},
+                settings,
+            )
+        self.assertAlmostEqual(unavailable_root["spend_usd"], 2.5)
+        self.assertTrue(unavailable_root["cost_available"])
+        self.assertTrue(unavailable_root["cost_partial"])
+
+        with mock.patch.dict(meter._xsess, {"sessions": family(True, False)}):
+            unavailable_child = meter.session_budget_snapshot(
+                {"id": "ses_root"},
+                {"total_cost": 1.0, "availability": {"cost": True}},
+                settings,
+            )
+        self.assertAlmostEqual(unavailable_child["spend_usd"], 1.0)
+        self.assertTrue(unavailable_child["cost_partial"])
+
+        with mock.patch.dict(meter._xsess, {"sessions": family(False, False)}):
+            unmeasured = meter.session_budget_snapshot(
+                {"id": "ses_root"},
+                {"total_cost": 0.0, "availability": {"cost": False}},
+                settings,
+            )
+        self.assertIsNone(unmeasured["spend_usd"])
+        self.assertFalse(unmeasured["cost_available"])
+        self.assertEqual(unmeasured["threshold_state"], "unavailable")
+
+        # A session with no child runs keeps its existing payload shape.
+        with mock.patch.dict(meter._xsess, {"sessions": []}):
+            solo = meter.session_budget_snapshot(
+                {"id": "ses_solo"},
+                {"total_cost": 1.0, "availability": {"cost": True}},
+                settings,
+            )
+        self.assertNotIn("cost_partial", solo)
+
+
+class OpenCodeSubagentDashboardContractTests(unittest.TestCase):
+    """The All sessions view keeps child runs out of the list but shows them."""
+
+    def setUp(self):
+        self.page = Path(DASHBOARD_PAGE).read_text(
+            encoding="utf-8"
+        )
+
+    def test_child_sessions_are_filtered_from_the_default_list(self):
+        self.assertIn("const view=allSessionsView(workRows,{showChildren:globalShowChildren", self.page)
+        self.assertIn("rows=(all||[]).filter(s=>!s.is_child_session&&", self.page)
+        self.assertIn("let globalShowChildren=localStorage.getItem('tm_global_children')", self.page)
+        self.assertIn("data-gchildren=hide", self.page)
+        self.assertIn("data-gchildren=show", self.page)
+        # The preference is a stored browser preference and is restored on load.
+        self.assertIn("paintGlobalChildren();", self.page)
+        # The control matches the g-sort segmented buttons: plain tab-reachable
+        # buttons with pressed state, not an ARIA radio group without arrow keys.
+        control = re.search(r'id=g-children[^>]*>(.*?)</div>', self.page, re.S).group(0)
+        self.assertNotIn("role=radio", control)
+        self.assertIn("type=button aria-pressed=true data-gchildren=hide", control)
+        self.assertIn("type=button aria-pressed=false data-gchildren=show", control)
+        self.assertNotIn("role=radiogroup", self.page)
+        self.assertIn("b.setAttribute('aria-pressed',on?'true':'false');", self.page)
+
+    def test_hidden_child_spend_is_still_reported_in_the_row_count_line(self):
+        # Filtering rows out of a list must not imply their spend was excluded.
+        self.assertIn("renderAllSessionStats(view.statsRows);", self.page)
+        self.assertIn("setLogText($('g-count'),allSessionsCountText(view));", self.page)
+        self.assertIn("counted, ${parentNote}", self.page)
+        self.assertIn("listed under parents", self.page)
+        self.assertIn("with no parent session", self.page)
+
+    def test_current_session_card_marks_partial_family_cost_as_lower_bound(self):
+        self.assertIn("const costPartial=costAvailable&&!!row.cost_partial;", self.page)
+        self.assertIn("costLabel=costPartial?'Cost, at least':'Cost'", self.page)
+        self.assertNotIn("(costPartial?'≥':'')", self.page)
+        self.assertIn(
+            "Cost is a lower bound: some runs in this session family have no cost evidence.",
+            self.page,
+        )
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_session_cap_display_and_alert_use_family_spend(self):
+        """An OpenCode family cap reports and alerts on root plus child spend."""
+        page_path = Path(DASHBOARD_PAGE)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const metricAvailable=(row,metric)=>row?.availability?.[metric]!==false,money=n=>'$'+Number(n).toFixed(2);
+const nodes={{}},el=id=>nodes[id]||(nodes[id]={{value:'',max:'',min:'0.5',textContent:'',style:{{setProperty(){{}}}}}});
+const $=el,defaultSessionBudget=10,SESSION_BUDGET_SLIDER_MIN=0.5,SESSION_BUDGET_SLIDER_BASE_MAX=50,formatBudgetInput=n=>String(n);
+let cap=10;const dollarInputValue=()=>cap;
+eval(extract('sessionCapSpend'));
+eval(extract('sessionBudgetSliderMax'));
+eval(extract('syncSessionBudgetControls'));
+eval(extract('sessionAlert'));
+const family=(partial,rootAvailable=true)=>({{provider:'opencode',source:{{id:'ses_root'}},total_cost:1,availability:{{cost:rootAvailable}},
+ session_budget:{{id:'ses_root',budget_usd:10,spend_usd:10.5,cost_available:true,cost_partial:partial}}}});
+const out={{}};
+const complete=family(false);syncSessionBudgetControls(10,complete);
+out.familySpend=el('session-budget-spend').textContent;out.familyAlert=sessionAlert(complete);
+const partial=family(true,false);syncSessionBudgetControls(10,partial);
+out.partialSpend=el('session-budget-spend').textContent;out.partialAlert=sessionAlert(partial);
+const claude={{provider:'claude',source:{{id:'c1'}},total_cost:1,availability:{{cost:true}},
+ session_budget:{{id:'c1',budget_usd:10,spend_usd:1,cost_available:true}}}};
+syncSessionBudgetControls(10,claude);out.claudeSpend=el('session-budget-spend').textContent;out.claudeAlert=sessionAlert(claude);
+const claudeOver={{...claude,total_cost:12,session_budget:undefined}};out.claudeOverAlert=sessionAlert(claudeOver);
+const unmeasured={{...claude,availability:{{cost:false}}}};syncSessionBudgetControls(10,unmeasured);
+out.unmeasuredSpend=el('session-budget-spend').textContent;out.unmeasuredAlert=sessionAlert(unmeasured);
+process.stdout.write(JSON.stringify(out));
+"""
+        completed = subprocess.run(["node", "-e", script], capture_output=True, text=True)
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        out = json.loads(completed.stdout)
+        self.assertEqual(out["familySpend"], "Session spend $10.50")
+        self.assertEqual(out["familyAlert"]["type"], "budget")
+        self.assertEqual(out["familyAlert"]["current"], 10.5)
+        self.assertIn("now $10.50", out["familyAlert"]["msg"])
+        # A measured lower bound is still available and is labeled as such.
+        self.assertEqual(out["partialSpend"], "Session spend at least $10.50")
+        self.assertIn("now at least $10.50", out["partialAlert"]["msg"])
+        # Sessions without a folded family keep their own-cost behavior.
+        self.assertEqual(out["claudeSpend"], "Session spend $1.00")
+        self.assertEqual(out["claudeAlert"]["msg"], "")
+        self.assertIn("now $12.00", out["claudeOverAlert"]["msg"])
+        self.assertEqual(out["unmeasuredSpend"], "Session spend unavailable")
+        self.assertEqual(out["unmeasuredAlert"]["msg"], "")
+
+    @unittest.skipUnless(shutil.which("node"), "Node.js is required for dashboard JavaScript")
+    def test_all_sessions_view_counts_children_and_respects_filters(self):
+        page_path = Path(DASHBOARD_PAGE)
+        script = f"""
+const fs=require('fs');
+const page=fs.readFileSync({json.dumps(str(page_path))},'utf8');
+function extract(name){{let start=page.indexOf(`function ${{name}}(`);if(start<0)throw Error(`missing ${{name}}`);let i=page.indexOf('{{',start),depth=0;for(;i<page.length;i++){{if(page[i]==='{{')depth++;else if(page[i]==='}}'&&--depth===0)return page.slice(start,i+1);}}throw Error(`unclosed ${{name}}`);}}
+const appFilterGroup=s=>s.provider,projectFilterValue=p=>p||'',metricAvailable=(row,key)=>row?.availability?.[key]!==false,hasLocalEstimate=()=>false;
+const f=n=>String(n),money=n=>'$'+Number(n).toFixed(2),countWord=(n,w)=>n===1?w:w+'s';
+eval(extract('childRootId'));eval(page.slice(page.indexOf('function allSessionsView('),page.indexOf('function allSessionsCountText(')));eval(extract('allSessionsCountText'));
+const all=[
+ {{id:'root',provider:'opencode',project:'/a',title:'Root work',cost:1,mtime:100}},
+ {{id:'mid',provider:'opencode',project:'/a',title:'Mid run',cost:2,mtime:200,is_child_session:true,root_session_id:'root',child_depth:1}},
+ {{id:'leaf',provider:'opencode',project:'/a',title:'Needle leaf',cost:4,mtime:300,is_child_session:true,root_session_id:'root',child_depth:2}},
+ {{id:'orphan',provider:'opencode',project:'/a',title:'Orphan',cost:8,mtime:300,is_child_session:true}},
+ {{id:'other',provider:'claude',project:'/b',title:'Other',cost:16,mtime:400}},
+];
+const hidden=allSessionsView(all,{{}});
+const listed=allSessionsView(all,{{showChildren:true}});
+const project=allSessionsView(all,{{project:'/b'}});
+const search=allSessionsView(all,{{query:'needle'}});
+const spend=v=>v.statsRows.filter(r=>metricAvailable(r,'cost')).reduce((a,b)=>a+(b.cost||0),0);
+const filters={{search:{{query:'needle'}},time:{{rangeStart:250}},project:{{project:'/a'}},searchTime:{{query:'leaf',rangeStart:250}},none:{{}}}};
+const parity=Object.fromEntries(Object.entries(filters).map(([name,opts])=>{{
+ const h=allSessionsView(all,opts),l=allSessionsView(all,{{...opts,showChildren:true}});
+ return [name,{{hidden:spend(h),listed:spend(l),hiddenCovered:h.statsRows.length,listedCovered:l.statsRows.length}}];
+}}));
+const time=allSessionsView(all,{{rangeStart:250}});
+console.log(JSON.stringify({{
+ parity,searchText:allSessionsCountText(search),listedText:allSessionsCountText(listed),
+ time:{{rows:time.rows.map(r=>r.id),text:allSessionsCountText(time)}},
+ hiddenRows:hidden.rows.map(r=>r.id),hiddenStatsCost:hidden.statsRows.reduce((a,b)=>a+b.cost,0),
+ listedStatsCost:listed.statsRows.reduce((a,b)=>a+b.cost,0),listedRows:listed.rows.length,
+ hidden:{{children:hidden.children,underParent:hidden.underParent,unparented:hidden.unparented,total:hidden.total}},
+ hiddenText:allSessionsCountText(hidden),
+ project:{{rows:project.rows.map(r=>r.id),children:project.children,text:allSessionsCountText(project)}},
+ search:{{rows:search.rows.map(r=>r.id),children:search.children,underParent:search.underParent}},
+}}));
+"""
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        data = json.loads(result.stdout)
+        self.assertEqual(data["hiddenRows"], ["root", "other"])
+        # Header stats include hidden child spend, identical to Listed mode.
+        self.assertEqual(data["hiddenStatsCost"], 31)
+        self.assertEqual(data["listedStatsCost"], 31)
+        self.assertEqual(data["listedRows"], 5)
+        # The grandchild counts under its root card even though its parent is hidden.
+        self.assertEqual(data["hidden"], {"children": 3, "underParent": 2, "unparented": 1, "total": 2})
+        self.assertIn("2 of 2 sessions · $31.00 covered spend · 5 of 5 cost-covered", data["hiddenText"])
+        # Hidden and Listed header spend and coverage are equal under every filter,
+        # and a root surfaced only by a matching child adds none of its own cost.
+        for name, row in data["parity"].items():
+            self.assertEqual(row["hidden"], row["listed"], name)
+            self.assertEqual(row["hiddenCovered"], row["listedCovered"], name)
+        self.assertEqual(data["parity"]["search"]["hidden"], 4)
+        self.assertEqual(data["parity"]["time"]["hidden"], 28)
+        self.assertEqual(data["parity"]["searchTime"]["hidden"], 4)
+        self.assertIn("0 of 2 sessions · $4.00 covered spend · 1 of 1 cost-covered", data["searchText"])
+        self.assertIn("1 parent card shown for matching runs", data["searchText"])
+        self.assertIn("2 of 2 sessions + 3 subagent runs · $31.00 covered spend · 5 of 5 cost-covered", data["listedText"])
+        self.assertNotIn("parent card shown", data["listedText"])
+        self.assertEqual(data["time"]["rows"], ["root", "other"])
+        self.assertIn("1 of 2 sessions · $28.00 covered spend · 3 of 3 cost-covered", data["time"]["text"])
+        self.assertIn("3 subagent runs ($14.00) counted, 2 shown under parent cards · 1 with no parent session", data["hiddenText"])
+        # The hidden-children note respects the active project filter.
+        self.assertEqual(data["project"]["rows"], ["other"])
+        self.assertEqual(data["project"]["children"], 0)
+        self.assertNotIn("subagent", data["project"]["text"])
+        # Search in Hidden mode finds a child run by surfacing its root card.
+        self.assertEqual(data["search"], {"rows": ["root"], "children": 1, "underParent": 1})
+
+    def test_parent_card_renders_an_accessible_child_subsection(self):
+        self.assertIn("function childAgentSubsection(s)", self.page)
+        self.assertIn('class=subagents', self.page)
+        self.assertIn('class=subagentRow type=button data-open-session="${esc(sessionRowKey(child))}"', self.page)
+        # Children are real buttons with a complete accessible name, so depth
+        # and identity are never carried by indentation alone.
+        self.assertIn('aria-label="Open subagent run ${esc(title)}"', self.page)
+        # The role is provider-reported metadata, surfaced verbatim and bounded.
+        self.assertIn('class=subagentRole>${esc(child.child_agent_role)}<', self.page)
+        self.assertIn("Unreported role", self.page)
+
+    def test_child_rows_navigate_without_double_firing_the_parent(self):
+        self.assertIn("const childButton=event.target.closest('[data-open-session]');", self.page)
+        self.assertIn("event.stopPropagation();", self.page)
+        self.assertIn("selectSession(sessionRowKey(childRow))", self.page)
+
+    def test_measured_free_tier_zero_is_not_presented_as_unavailable(self):
+        # A real free-tier price renders as $0.0, distinct from missing billing.
+        self.assertIn("child.cost>0?costValueHtml", self.page)
+        self.assertIn("Measured free-tier price", self.page)
+        self.assertIn("cost unavailable", self.page)
+
+    def test_child_subsection_is_bounded_and_reports_the_hidden_count(self):
+        self.assertIn("const CHILD_SECTION_LIMIT=6;", self.page)
+        self.assertIn("const shown=children.slice(0,CHILD_SECTION_LIMIT);", self.page)
+        self.assertIn("more ${countWord(hidden,'run')} not shown", self.page)
+
+    def test_child_changes_invalidate_the_cached_parent_row(self):
+        self.assertIn("childAgentsFor(s).map(c=>[c.id,c.cost,c.tokens", self.page)
+        self.assertIn("function indexChildSessions(rows)", self.page)
+        # Every descendant is keyed by its published root id, never a raw parent id.
+        self.assertIn("const key=childRootId(row);", self.page)
+        self.assertNotIn("child_parent_id", self.page)
+
+    def test_subagents_page_discloses_unattributed_child_runs(self):
+        # A child run whose parent was never discovered is counted in totals but
+        # has no parent card, so the explorer must disclose the gap rather than
+        # let the rollup look complete.
+        self.assertIn('id=subagent-coverage-note', self.page)
+        self.assertIn("usage?.totals?.unresolved_agents", self.page)
+        self.assertIn("usage?.totals?.unresolved_known_cost", self.page)
+        self.assertIn("has':'have'} no parent session; left out of the rollups above.", self.page)
+        self.assertIn("counted in global totals", self.page)
+        # Archived families are excluded from discovery, so the only remaining
+        # cause is a missing parent record; the copy must not blame archiving.
+        self.assertNotIn("usually because the parent session was archived", self.page)
+        self.assertIn("parent session record is missing", self.page)
+        self.assertIn(".subagentCoverageNote[hidden]{display:none}", self.page)
+
+    def test_parent_row_with_children_uses_top_aligned_metrics(self):
+        # A parent with a tall child subsection must not center its own
+        # headline metrics beside the middle of that subsection.
+        self.assertIn(".srow.hasChildren{align-items:start}", self.page)
+        self.assertIn("const hasChildren=childAgentsFor(s).length>0;", self.page)
+        self.assertIn("${hasChildren?' hasChildren':''}", self.page)
+
+    def test_subagent_subsection_never_overflows_its_parent_at_laptop_width(self):
+        # Long role/model/time text must truncate inside the grid track rather
+        # than push the page wider at the 1024px laptop width.
+        self.assertIn(".subagentMain{min-width:0;overflow:hidden}", self.page)
+        self.assertIn(
+            ".subagentMain .meta{font-size:var(--fs-11);color:var(--faint);margin-top:2px;"
+            "display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;"
+            "min-width:0}",
+            self.page,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_pi_sessions.py b/tests/test_pi_sessions.py
new file mode 100644
index 00000000..4dd58a0a
--- /dev/null
+++ b/tests/test_pi_sessions.py
@@ -0,0 +1,1286 @@
+import unittest
+import datetime
+import json
+import tempfile
+from pathlib import Path
+from unittest import mock
+import meter
+from token_meter.contracts import DiscoveryContext
+from token_meter.runtimes import pi as pi_runtime
+
+
+class PiDocumentationTests(unittest.TestCase):
+    def test_docs_explain_pi_evidence_and_privacy_boundaries(self):
+        root = Path(__file__).resolve().parents[1]
+        guide = (root / "specs/USER_GUIDE.md").read_text()
+        architecture = (root / "specs/ARCHITECTURE.md").read_text()
+        security = (root / "specs/SECURITY.md").read_text()
+
+        self.assertIn("PI_CODING_AGENT_DIR", guide)
+        self.assertIn("Pi coding-agent sessions", guide)
+        self.assertIn("does not import cloud transcripts", guide)
+        guide_copy = " ".join(guide.split())
+        self.assertIn("Wait is inferred from the user-to-assistant timestamps", guide_copy)
+        self.assertIn("semantic token classification remain unavailable", guide_copy)
+        self.assertIn("Pi adapter", architecture)
+        self.assertIn("application-profile", architecture)
+        self.assertIn("application-profile", security)
+
+
+class PiRuntimeTests(unittest.TestCase):
+    """Pi sessions are local JSONL records with no content projection."""
+
+    def _write_session(self, agent_root, *, legacy=False, provider="anthropic",
+                       model="claude-test", result_error=False, reasoning_tokens=None):
+        directory = Path(agent_root) if legacy else (
+            Path(agent_root) / "sessions" / "--repo--"
+        )
+        directory.mkdir(parents=True)
+        path = directory / "pi-session.jsonl"
+        rows = [
+            {"type": "session", "version": 1, "id": "pi-session",
+             "timestamp": "2026-09-04T10:00:00Z", "cwd": "/repo"},
+            {"type": "model_change", "id": "model-change", "parentId": None,
+             "timestamp": "2026-09-04T10:00:01Z", "provider": provider,
+             "modelId": model},
+            {"type": "message", "id": "user", "parentId": "model-change",
+             "timestamp": "2026-09-04T10:00:02Z",
+             "message": {"role": "user", "content": []}},
+            {"type": "message", "id": "assistant", "parentId": "user",
+             "timestamp": "2026-09-04T10:00:05Z", "message": {
+                "role": "assistant", "model": model, "provider": provider,
+                 "content": [{"type": "toolCall", "id": "call", "name": "read",
+                              "arguments": {}}],
+                 "usage": {"input": 100, "output": 20, "cacheRead": 10,
+                           "cacheWrite": 5, "totalTokens": 135,
+                           "cost": {"input": 0.001, "output": 0.002,
+                                    "cacheRead": 0.0001, "cacheWrite": 0.0002}},
+             }},
+            {"type": "message", "id": "result", "parentId": "assistant",
+             "timestamp": "2026-09-04T10:00:06Z",
+             "message": {"role": "toolResult", "toolCallId": "call", "toolName": "read",
+                         **({"isError": True} if result_error else {})},
+             },
+        ]
+        if reasoning_tokens is not None:
+            rows[3]["message"]["usage"]["reasoning"] = reasoning_tokens
+        path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+        return path
+
+    def test_discovers_and_projects_pi_usage_as_a_local_cost_estimate(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                sources = meter.pi_session_sources()
+                state = meter.recompute(sources[0])
+                summary = meter.pi_summary(sources[0])
+
+        self.assertEqual(len(sources), 1)
+        self.assertEqual(sources[0]["provider"], "pi")
+        self.assertEqual(sources[0]["model"], "claude-test")
+        self.assertEqual(sources[0]["model_provider"], "anthropic")
+        self.assertEqual(sources[0]["project"], "/repo")
+        self.assertEqual(sources[0]["title"], "Pi session")
+        self.assertEqual(state["tokens"], {
+            "input": 100, "cache_write": 5, "cache_read": 10, "output": 20,
+        })
+        self.assertEqual(state["total_tokens"], 135)
+        self.assertAlmostEqual(state["total_cost"], 0.0033)
+        self.assertTrue(state["cost_approx"])
+        self.assertTrue(state["availability"]["cost"])
+        self.assertFalse(state["semantic_available"])
+        self.assertEqual(state["semantic"], {
+            "reasoning": 0, "output": 0, "retrieval": 0, "coordination": 0,
+        })
+        self.assertFalse(state["cache"]["savings_available"])
+        self.assertIsNone(state["cache"]["saved"])
+        self.assertIsNone(state["cache_saved"])
+        self.assertTrue(state["wait_time"]["available"])
+        self.assertEqual(state["executions"][0]["tools"][0]["name"], "read")
+        self.assertEqual(state["executions"][0]["context_tokens"], 115)
+        self.assertEqual(state["context"]["latest"], 115)
+        self.assertTrue(state["availability"]["context"])
+        self.assertTrue(state["availability"]["throughput"])
+        self.assertTrue(state["throughput"]["available"])
+        self.assertEqual(state["throughput"]["basis"], "end_to_end")
+        self.assertAlmostEqual(state["throughput"]["output_tps"], 20 / 3)
+        self.assertEqual(summary["context"]["latest"], 115)
+        self.assertEqual(summary["_context_samples"], [115])
+        self.assertTrue(summary["throughput"]["available"])
+        self.assertNotIn("arguments", json.dumps(state))
+
+    def test_redacts_pi_bedrock_application_profile_without_inferring_a_model(self):
+        raw_profile = (
+            "arn:aws:bedrock:us-west-2:123456789012:"
+            "application-inference-profile/private-profile"
+        )
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root, provider="amazon-bedrock", model=raw_profile)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                source = meter.pi_session_sources()[0]
+                state = meter.recompute(source)
+                summary = meter.pi_summary(source)
+
+        self.assertEqual(source["model"], "aws-bedrock-profile")
+        self.assertEqual(source["model_provider"], "amazon")
+        public = json.dumps({"source": source, "state": state, "summary": summary})
+        self.assertNotIn(raw_profile, public)
+        self.assertNotIn("123456789012", public)
+        self.assertTrue(state["cost_approx"])
+        self.assertTrue(summary["wait_time"]["available"])
+
+    def test_keeps_pi_cache_savings_unavailable_without_a_price_lookup(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                source = meter.pi_session_sources()[0]
+                with mock.patch.object(
+                    meter, "price_for",
+                    side_effect=AssertionError("Pi must not infer cache savings from pricing"),
+                ):
+                    state = meter.recompute(source)
+
+        self.assertFalse(state["cache"]["savings_available"])
+        self.assertIsNone(state["cache"]["saved"])
+
+    def test_discovers_legacy_pi_sessions_at_the_agent_root(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root, legacy=True)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}):
+                sources = meter.pi_session_sources()
+
+        self.assertEqual([source["id"] for source in sources], ["pi-session"])
+
+    def test_ignores_non_pi_jsonl_without_poisoning_discovery_cache(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            root.mkdir()
+            (root / "not-a-pi-session.jsonl").write_text("{}\n")
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}):
+                self.assertEqual(meter.pi_session_sources(), [])
+                self.assertEqual(meter.pi_session_sources(), [])
+
+    def test_records_pi_tool_result_errors_instead_of_successes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root, result_error=True)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                source = meter.pi_session_sources()[0]
+                state = meter.recompute(source)
+                native = meter._pi_native_adapter().discover(None)[0]
+                session = meter._pi_native_adapter().load(native, meter.DetailLevel.FULL)
+
+        self.assertTrue(state["executions"][0]["tools"][0]["error"])
+        self.assertTrue(state["tools"]["total_errors"])
+        self.assertEqual(state["executions"][0]["tools"][0]["result_available"], True)
+        self.assertEqual(session.tools[0].status, "error")
+        self.assertEqual(
+            [event["severity"] for event in state["trace"] if event["kind"] == "tool_call"],
+            ["warn"],
+        )
+
+    def test_keeps_successful_pi_tool_results_as_successes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                source = meter.pi_session_sources()[0]
+                state = meter.recompute(source)
+                native = meter._pi_native_adapter().discover(None)[0]
+                session = meter._pi_native_adapter().load(native, meter.DetailLevel.FULL)
+
+        self.assertFalse(state["executions"][0]["tools"][0]["error"])
+        self.assertFalse(state["tools"]["total_errors"])
+        self.assertEqual(session.tools[0].status, "success")
+
+    def test_projects_pi_reasoning_tokens_as_an_output_subset(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root, reasoning_tokens=12)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                source = meter.pi_session_sources()[0]
+                state = meter.recompute(source)
+
+        execution = state["executions"][0]
+        self.assertEqual(execution["reasoning_tokens"], 12)
+        self.assertEqual(state["series"][0]["reasoning"], 12)
+        self.assertTrue(state["series"][0]["think"])
+        # Reasoning is a reported subset of output, never an extra bucket.
+        self.assertEqual(state["total_tokens"], 135)
+        self.assertEqual(state["tokens"], {
+            "input": 100, "cache_write": 5, "cache_read": 10, "output": 20,
+        })
+
+    def test_clamps_pi_reasoning_tokens_to_reported_output(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_session(root, reasoning_tokens=999)
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                state = meter.recompute(meter.pi_session_sources()[0])
+
+        self.assertEqual(state["executions"][0]["reasoning_tokens"], 20)
+        self.assertTrue(state["series"][0]["think"])
+
+    def test_keeps_pi_context_and_pace_unavailable_without_usage(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            path = self._write_session(root)
+            rows = [json.loads(line) for line in path.read_text().splitlines()]
+            del rows[3]["message"]["usage"]
+            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                source = meter.pi_session_sources()[0]
+                state = meter.recompute(source)
+                summary = meter.pi_summary(source)
+
+        self.assertEqual(state["context"]["latest"], 0)
+        self.assertFalse(state["availability"]["context"])
+        self.assertFalse(state["throughput"]["available"])
+        self.assertFalse(state["availability"]["throughput"])
+        self.assertEqual(summary["context"]["latest"], 0)
+        self.assertFalse(summary["throughput"]["available"])
+
+    def test_keeps_cost_unavailable_when_a_pi_turn_lacks_its_local_estimate(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            path = self._write_session(root)
+            rows = [json.loads(line) for line in path.read_text().splitlines()]
+            del rows[3]["message"]["usage"]["cost"]
+            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+                state = meter.recompute(meter.pi_session_sources()[0])
+
+        self.assertFalse(state["availability"]["cost"])
+        self.assertEqual(state["total_cost"], 0)
+
+
+class PiSubagentTests(unittest.TestCase):
+    """Pi child runs live inside the parent transcript and must be accounted."""
+
+    CONTENT_CANARY = "PI-CONTENT-CANARY-7731"
+
+    @staticmethod
+    def _child_usage(input_tokens=1000, output_tokens=100, cache_read=0,
+                     cache_write=0, cost=0.25, turns=2, breakdown=False):
+        # The shipped subagent tool reports a scalar cost, so that is the
+        # default shape; breakdown=True is the documented Pi Usage object.
+        usage = {
+            "input": input_tokens,
+            "output": output_tokens,
+            "cacheRead": cache_read,
+            "cacheWrite": cache_write,
+            "cost": cost,
+            "contextTokens": input_tokens + cache_read + cache_write,
+            "turns": turns,
+        }
+        if breakdown:
+            usage["cost"] = {
+                "input": cost, "output": 0.0, "cacheRead": 0.0,
+                "cacheWrite": 0.0, "total": cost,
+            }
+        return usage
+
+    def _child_result(self, agent="probe", *, usage=None, exit_code=0,
+                      stop_reason="stop", model="opencode-go/deepseek-v4.1-flash",
+                      step=None):
+        result = {
+            "agent": agent,
+            "agentSource": "user",
+            "task": self.CONTENT_CANARY + "-task",
+            "exitCode": exit_code,
+            "messages": [{
+                "role": "assistant",
+                "content": [{"type": "text", "text": self.CONTENT_CANARY}],
+            }],
+            "stderr": self.CONTENT_CANARY + "-stderr",
+            "stopReason": stop_reason,
+            "model": model,
+        }
+        if usage is not None:
+            result["usage"] = usage
+        if step is not None:
+            result["step"] = step
+        return result
+
+    def _write_subagent_session(self, agent_root, *, results=None,
+                                top_usage=None, include_result=True,
+                                arguments=None, tool_name="subagent",
+                                mode="single", recent_seconds=None,
+                                stop_reason="stop", final_turn_usage=None):
+        directory = Path(agent_root) / "sessions" / "--repo--"
+        directory.mkdir(parents=True)
+        path = directory / "pi-subagent-session.jsonl"
+        if recent_seconds is None:
+            stamps = [
+                "2026-09-04T10:00:00Z", "2026-09-04T10:00:01Z",
+                "2026-09-04T10:00:02Z", "2026-09-04T10:00:05Z",
+                "2026-09-04T10:00:09Z", "2026-09-04T10:00:12Z",
+            ]
+        else:
+            base = (
+                datetime.datetime.now(datetime.timezone.utc)
+                - datetime.timedelta(seconds=recent_seconds)
+            )
+            stamps = [
+                (base + datetime.timedelta(seconds=offset)).isoformat()
+                .replace("+00:00", "Z")
+                for offset in (0, 1, 2, 5, 9, 12)
+            ]
+        tool_call = {
+            "type": "toolCall", "id": "call-subagent", "name": tool_name,
+            "arguments": arguments or {"agent": "probe", "task": self.CONTENT_CANARY},
+        }
+        assistant_message = {
+            "role": "assistant", "model": "claude-test", "provider": "anthropic",
+            "content": [tool_call],
+            "usage": {"input": 100, "output": 20, "cacheRead": 10,
+                      "cacheWrite": 5, "totalTokens": 135,
+                      "cost": {"input": 0.001, "output": 0.002,
+                               "cacheRead": 0.0001, "cacheWrite": 0.0002}},
+        }
+        if stop_reason is not None:
+            assistant_message["stopReason"] = stop_reason
+        rows = [
+            {"type": "session", "version": 3, "id": "pi-session",
+             "timestamp": stamps[0], "cwd": "/repo"},
+            {"type": "model_change", "id": "model-change", "parentId": None,
+             "timestamp": stamps[1], "provider": "anthropic",
+             "modelId": "claude-test"},
+            {"type": "message", "id": "user", "parentId": "model-change",
+             "timestamp": stamps[2],
+             "message": {"role": "user", "content": []}},
+            {"type": "message", "id": "assistant", "parentId": "user",
+             "timestamp": stamps[3], "message": assistant_message},
+        ]
+        if include_result:
+            message = {
+                "role": "toolResult", "toolCallId": "call-subagent",
+                "toolName": tool_name,
+                "content": [{"type": "text", "text": self.CONTENT_CANARY}],
+                "details": {
+                    "mode": mode, "agentScope": "user", "projectAgentsDir": None,
+                    "results": list(results if results is not None else []),
+                },
+            }
+            if top_usage is not None:
+                message["usage"] = top_usage
+            rows.append({
+                "type": "message", "id": "result", "parentId": "assistant",
+                "timestamp": stamps[4], "message": message,
+            })
+        if final_turn_usage is not None:
+            rows.append({
+                "type": "message", "id": "assistant-final",
+                "parentId": "result", "timestamp": stamps[5],
+                "message": {
+                    "role": "assistant", "model": "claude-test",
+                    "provider": "anthropic", "content": [],
+                    "stopReason": "stop", "usage": final_turn_usage,
+                },
+            })
+        path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+        return path
+
+    def _load(self, root):
+        with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                mock.patch.object(meter, "_pi_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            source = meter.pi_session_sources()[0]
+            return source, meter.recompute(source), meter.pi_summary(source)
+
+    def _records(self, summary):
+        return {record["kind"]: record for record in summary["_agent_records"]}
+
+    def test_single_child_run_adds_spend_and_emits_root_and_spawned_records(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=self._child_usage())],
+            )
+            source, state, summary = self._load(root)
+
+        # Parent turn 100/20/10/5 plus child 1000/100/0/0.
+        self.assertEqual(state["tokens"], {
+            "input": 1100, "output": 120, "cache_read": 10, "cache_write": 5,
+        })
+        self.assertEqual(state["total_tokens"], 1235)
+        self.assertAlmostEqual(state["total_cost"], 0.2533)
+        # Child work is not presented as a parent model call.
+        self.assertEqual(len(state["executions"]), 1)
+        self.assertEqual(summary["turns"], 1)
+
+        records = self._records(summary)
+        self.assertEqual(set(records), {"root", "spawned"})
+        root_record, child = records["root"], records["spawned"]
+        self.assertEqual(root_record["session_id"], source["id"])
+        self.assertEqual(root_record["tokens"], 135)
+        self.assertAlmostEqual(root_record["cost"], 0.0033)
+        self.assertTrue(root_record["tokens_available"])
+        self.assertEqual(child["parent_id"], root_record["id"])
+        self.assertEqual(child["depth"], 1)
+        self.assertEqual(child["role"], "probe")
+        self.assertEqual(child["model"], "opencode-go/deepseek-v4.1-flash")
+        self.assertEqual(child["tokens"], 1100)
+        self.assertAlmostEqual(child["cost"], 0.25)
+        self.assertTrue(child["tokens_available"])
+        self.assertTrue(child["cost_available"])
+        self.assertEqual(child["executions"], 2)
+        self.assertEqual(child["activity_state"], "complete")
+        self.assertEqual(child["started_at"], state["executions"][0]["ts"])
+        self.assertEqual(child["session_id"], None)
+        self.assertTrue(child["id"].startswith("pi-agent-"))
+        self.assertNotIn(source["id"], child["id"])
+        # Root plus child equals the session headline exactly.
+        self.assertEqual(
+            root_record["tokens"] + child["tokens"], state["total_tokens"],
+        )
+        self.assertAlmostEqual(
+            root_record["cost"] + child["cost"], state["total_cost"], places=9,
+        )
+
+    def test_shipped_extension_scalar_cost_shape_is_measured(self):
+        for reported in (0.0, 0.42):
+            with self.subTest(cost=reported), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                # Exact usage shape persisted by the shipped subagent example.
+                usage = {
+                    "input": 1461, "output": 27, "cacheRead": 0,
+                    "cacheWrite": 0, "cost": reported,
+                    "contextTokens": 1488, "turns": 1,
+                }
+                self._write_subagent_session(
+                    root, results=[self._child_result(usage=usage)],
+                )
+                _source, state, summary = self._load(root)
+
+                child = self._records(summary)["spawned"]
+                self.assertTrue(child["cost_available"])
+                self.assertEqual(child["cost"], reported)
+                self.assertTrue(state["availability"]["cost"])
+                self.assertAlmostEqual(
+                    state["total_cost"], 0.0033 + reported, places=6,
+                )
+
+    def test_reported_cost_breakdown_shape_is_still_supported(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, results=[
+                self._child_result(
+                    usage=self._child_usage(cost=0.25, breakdown=True),
+                ),
+            ])
+            _source, state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertTrue(child["cost_available"])
+        self.assertAlmostEqual(child["cost"], 0.25)
+        self.assertAlmostEqual(state["total_cost"], 0.2533)
+
+    def test_child_output_does_not_change_parent_pace_coverage(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=self._child_usage())],
+            )
+            _source, state, summary = self._load(root)
+
+        self.assertTrue(summary["throughput"]["available"])
+        self.assertAlmostEqual(
+            summary["throughput"]["timing_coverage"], 1.0,
+        )
+        self.assertAlmostEqual(summary["throughput"]["output_tps"], 20 / 3)
+        self.assertAlmostEqual(state["throughput"]["timing_coverage"], 1.0)
+
+    def test_parallel_child_results_each_emit_a_record_and_sum_once(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, mode="parallel", results=[
+                self._child_result("scout", usage=self._child_usage(600, 60, cost=0.1)),
+                self._child_result("reviewer", usage=self._child_usage(400, 40, cost=0.2)),
+            ])
+            _source, state, summary = self._load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertEqual(sorted(record["role"] for record in children),
+                         ["reviewer", "scout"])
+        self.assertEqual(sum(record["tokens"] for record in children), 1100)
+        self.assertAlmostEqual(sum(record["cost"] for record in children), 0.3)
+        self.assertEqual(state["total_tokens"], 1235)
+        self.assertAlmostEqual(state["total_cost"], 0.3033)
+        self.assertEqual(len({record["id"] for record in children}), 2)
+
+    def test_top_level_result_usage_without_details_emits_one_aggregate_run(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[], top_usage=self._child_usage(500, 50, cost=0.3),
+            )
+            _source, state, summary = self._load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertEqual(len(children), 1)
+        self.assertEqual(children[0]["role"], "probe")
+        self.assertEqual(children[0]["tokens"], 550)
+        self.assertAlmostEqual(children[0]["cost"], 0.3)
+        self.assertEqual(state["total_tokens"], 685)
+
+    def test_top_level_breakdown_usage_emits_aggregate_run(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[],
+                top_usage=self._child_usage(500, 50, cost=0.3, breakdown=True),
+            )
+            _source, state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertTrue(child["cost_available"])
+        self.assertAlmostEqual(child["cost"], 0.3)
+        self.assertEqual(state["total_tokens"], 685)
+
+    def test_reconciling_details_and_top_level_usage_count_spend_once(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, mode="parallel",
+                results=[
+                    self._child_result("scout", usage=self._child_usage(300, 30, cost=0.1)),
+                    self._child_result("worker", usage=self._child_usage(200, 20, cost=0.2)),
+                ],
+                top_usage=self._child_usage(500, 50, cost=0.3),
+            )
+            _source, state, summary = self._load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertEqual(sorted(record["role"] for record in children),
+                         ["scout", "worker"])
+        self.assertEqual(sum(record["tokens"] for record in children), 550)
+        self.assertEqual(state["total_tokens"], 685)
+        self.assertAlmostEqual(state["total_cost"], 0.3033)
+
+    def test_unreconciled_details_fall_back_to_one_aggregate_run(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, mode="parallel",
+                arguments={"tasks": [
+                    {"agent": "scout", "task": self.CONTENT_CANARY},
+                    {"agent": "worker", "task": self.CONTENT_CANARY},
+                ]},
+                results=[
+                    self._child_result("scout", usage=self._child_usage(300, 30, cost=0.1)),
+                    self._child_result("worker", usage=self._child_usage(200, 20, cost=0.2)),
+                ],
+                top_usage=self._child_usage(900, 90, cost=0.9),
+            )
+            _source, state, summary = self._load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertEqual(len(children), 1)
+        self.assertIsNone(children[0]["role"])
+        self.assertEqual(children[0]["tokens"], 990)
+        self.assertEqual(state["total_tokens"], 1125)
+        self.assertAlmostEqual(state["total_cost"], 0.9033)
+
+    def test_run_without_usage_reports_unavailable_not_zero(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, results=[self._child_result()])
+            _source, state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertFalse(child["tokens_available"])
+        self.assertFalse(child["cost_available"])
+        self.assertIsNone(child["tokens"])
+        self.assertIsNone(child["cost"])
+        self.assertFalse(summary["availability"]["cost"])
+        self.assertFalse(summary["availability"]["tokens"])
+        self.assertFalse(state["availability"]["cost"])
+        self.assertFalse(state["availability"]["tokens"])
+        self.assertEqual(state["total_tokens"], 135)
+
+    def test_failed_child_run_marks_incomplete_and_keeps_role(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, results=[
+                self._child_result("reviewer", usage=self._child_usage(cost=0.05),
+                                   exit_code=1, stop_reason="error"),
+            ])
+            _source, _state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertEqual(child["role"], "reviewer")
+        self.assertEqual(child["activity_state"], "incomplete")
+        self.assertEqual(child["failed_attempts"], 1)
+        self.assertIsNone(child["ended_at"])
+
+    def test_partial_failure_keeps_successful_sibling_complete(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            path = self._write_subagent_session(root, mode="parallel", results=[
+                self._child_result("scout", usage=self._child_usage(cost=0.1)),
+                self._child_result("worker", usage=self._child_usage(cost=0.0),
+                                   exit_code=1, stop_reason="error"),
+            ])
+            rows = [json.loads(line) for line in path.read_text().splitlines()]
+            rows[-1]["message"]["isError"] = True
+            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+            _source, _state, summary = self._load(root)
+
+        children = {
+            record["role"]: record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        }
+        self.assertEqual(children["scout"]["activity_state"], "complete")
+        self.assertEqual(children["worker"]["activity_state"], "incomplete")
+        self.assertEqual(children["worker"]["failed_attempts"], 1)
+
+    def test_zero_cost_child_is_a_measured_zero(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=self._child_usage(cost=0.0))],
+            )
+            _source, _state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertTrue(child["cost_available"])
+        self.assertEqual(child["cost"], 0.0)
+        self.assertTrue(summary["availability"]["cost"])
+
+    def test_unfinished_child_call_is_incomplete_without_invented_spend(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, include_result=False)
+            _source, state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertEqual(child["activity_state"], "incomplete")
+        self.assertEqual(child["failed_attempts"], 0)
+        self.assertFalse(child["tokens_available"])
+        self.assertFalse(child["cost_available"])
+        self.assertEqual(state["total_tokens"], 135)
+        self.assertEqual(state["total_cost"], 0.0033)
+
+    def test_fresh_unfinished_child_call_is_working(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, include_result=False, recent_seconds=10,
+            )
+            _source, _state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertEqual(child["activity_state"], "working")
+        self.assertEqual(child["failed_attempts"], 0)
+
+    def test_finished_session_root_reports_complete(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=self._child_usage())],
+            )
+            _source, _state, summary = self._load(root)
+
+        # Session-row liveness is intentionally unchanged for this PR.
+        self.assertFalse(summary["terminal"])
+        root_record = self._records(summary)["root"]
+        self.assertEqual(root_record["activity_state"], "complete")
+        self.assertEqual(
+            root_record["ended_at"], root_record["last_activity_at"],
+        )
+
+    def test_realistic_tool_use_then_stop_marks_root_complete(self):
+        final_usage = {
+            "input": 50, "output": 10, "cacheRead": 0, "cacheWrite": 0,
+            "totalTokens": 60,
+            "cost": {"input": 0.0005, "output": 0.0005,
+                     "cacheRead": 0.0, "cacheWrite": 0.0},
+        }
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, stop_reason="toolUse",
+                results=[self._child_result(usage=self._child_usage())],
+                final_turn_usage=final_usage,
+            )
+            _source, state, summary = self._load(root)
+
+        self.assertEqual(summary["turns"], 2)
+        self.assertEqual(
+            self._records(summary)["root"]["activity_state"], "complete",
+        )
+        self.assertAlmostEqual(state["total_cost"], 0.2543)
+
+    def test_nonterminal_session_root_stays_incomplete(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, stop_reason="toolUse",
+                results=[self._child_result(usage=self._child_usage())],
+            )
+            _source, _state, summary = self._load(root)
+
+        self.assertFalse(summary["terminal"])
+        root_record = self._records(summary)["root"]
+        self.assertEqual(root_record["activity_state"], "incomplete")
+        self.assertIsNone(root_record["ended_at"])
+
+    def test_empty_results_run_emits_no_agent_records(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, results=[])
+            _source, _state, summary = self._load(root)
+
+        self.assertNotIn("_agent_records", summary)
+
+    def test_child_role_rejects_paths_urls_credentials_and_prose(self):
+        bad_roles = [
+            "/Users/henry/agents/secret.md",
+            "https://example.test/agent",
+            "bearer abcdef",
+            "api_key=abcdef",
+            "a" * 80,
+            "two words here",
+            "scout\x00hidden",
+        ]
+        for bad in bad_roles:
+            with self.subTest(bad=bad), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                self._write_subagent_session(
+                    root, results=[self._child_result(bad, usage=self._child_usage())],
+                )
+                _source, state, summary = self._load(root)
+                child = self._records(summary)["spawned"]
+                self.assertIsNone(child["role"])
+                encoded = json.dumps({"summary": summary, "state": state})
+                self.assertNotIn(bad, encoded)
+
+    def test_child_model_rejects_credential_and_path_shapes(self):
+        for bad in ("sk-secret-value", "bearer abc", "/Users/henry/model",
+                    "https://example.test/model", "model with space",
+                    "probe?x=1", "models/llama-3.gguf",
+                    "Users/henry/.ssh/id_rsa", "a/../../etc/passwd",
+                    "example.com/secret", "localhost:8080/model",
+                    "home/henry/model", "C:/Users/henry/model",
+                    "example.com:8080/secret", "127.0.0.1:8000/model",
+                    "my-server.internal:8000/model", "10.0.0.5:9000/model"):
+            with self.subTest(model=bad), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                self._write_subagent_session(root, results=[
+                    self._child_result(
+                        usage=self._child_usage(), model=bad,
+                    ),
+                ])
+                _source, state, summary = self._load(root)
+
+                child = self._records(summary)["spawned"]
+                self.assertEqual(child["model"], "unknown-model")
+                encoded = json.dumps({"summary": summary, "state": state})
+                self.assertNotIn(bad, encoded)
+
+    def test_child_model_accepts_provider_prefixed_ids(self):
+        good_models = (
+            "@cf/meta/llama-3.1-8b-instruct",
+            "opencode-go/deepseek-v4.1-flash",
+            "anthropic/claude-opus-4-8",
+            "meta-llama/Llama-3.1-70B-Instruct",
+            "accounts/fireworks/models/llama-v3p1-70b-instruct",
+            "qwen2.5-coder:32b",
+            "amazon.nova-pro-v1:0",
+        )
+        for good in good_models:
+            with self.subTest(model=good), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                self._write_subagent_session(root, results=[
+                    self._child_result(usage=self._child_usage(), model=good),
+                ])
+                _source, _state, summary = self._load(root)
+
+                child = self._records(summary)["spawned"]
+                self.assertEqual(child["model"], good.lower())
+
+    def test_unreported_child_model_is_unknown_not_the_parent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(root, results=[
+                self._child_result(usage=self._child_usage(), model=""),
+            ])
+            _source, state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertEqual(child["model"], "unknown-model")
+        self.assertEqual(summary["primary_model"], "claude-test")
+        self.assertEqual(summary["_model_cost"]["unknown-model"], 0.25)
+        self.assertAlmostEqual(summary["_model_cost"]["claude-test"], 0.0033)
+        mix = {row["model"]: row["cost"] for row in state["analyses"]["model_mix"]}
+        self.assertEqual(mix["unknown-model"], 0.25)
+        self.assertAlmostEqual(mix["claude-test"], 0.0033)
+
+    def test_child_content_never_reaches_summary_state_or_records(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=self._child_usage())],
+            )
+            _source, state, summary = self._load(root)
+
+        # The records must exist for this to be a meaningful negative check.
+        self.assertTrue(summary.get("_agent_records"))
+        encoded = json.dumps({"summary": summary, "state": state})
+        self.assertNotIn(self.CONTENT_CANARY, encoded)
+        self.assertNotIn("stderr", encoded)
+        self.assertNotIn("agentSource", encoded)
+        self.assertNotIn("messages", encoded)
+
+    def test_non_subagent_tool_usage_is_ignored(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, tool_name="summarize",
+                results=[self._child_result(usage=self._child_usage())],
+            )
+            _source, state, summary = self._load(root)
+
+        self.assertEqual(state["total_tokens"], 135)
+        self.assertNotIn("_agent_records", summary)
+        # A non-subagent Pi session keeps its pre-existing session liveness.
+        self.assertFalse(summary["terminal"])
+
+    def _write_many_calls(self, agent_root, call_results, *, extra_rows=()):
+        """Write one parent turn issuing N subagent calls with given results."""
+        directory = Path(agent_root) / "sessions" / "--repo--"
+        directory.mkdir(parents=True)
+        path = directory / "pi-subagent-many.jsonl"
+        calls = [
+            {"type": "toolCall", "id": "call-{}".format(index),
+             "name": "subagent", "arguments": {"agent": "probe"}}
+            for index in range(len(call_results))
+        ]
+        rows = [
+            {"type": "session", "version": 3, "id": "pi-session",
+             "timestamp": "2026-09-04T10:00:00Z", "cwd": "/repo"},
+            {"type": "message", "id": "user", "timestamp": "2026-09-04T10:00:01Z",
+             "message": {"role": "user", "content": []}},
+            {"type": "message", "id": "assistant",
+             "timestamp": "2026-09-04T10:00:02Z",
+             "message": {
+                 "role": "assistant", "model": "claude-test",
+                 "provider": "anthropic", "stopReason": "stop",
+                 "content": calls,
+                 "usage": {"input": 100, "output": 20, "cacheRead": 10,
+                           "cacheWrite": 5,
+                           "cost": {"input": 0.001, "output": 0.002,
+                                    "cacheRead": 0.0001, "cacheWrite": 0.0002}},
+             }},
+        ]
+        for index, results in enumerate(call_results):
+            rows.append({
+                "type": "message", "id": "result-{}".format(index),
+                "timestamp": "2026-09-04T10:00:05Z",
+                "message": {
+                    "role": "toolResult", "toolCallId": "call-{}".format(index),
+                    "toolName": "subagent",
+                    "details": {"mode": "single", "results": results},
+                },
+            })
+        rows.extend(extra_rows)
+        path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+        return path
+
+    def _native_load(self, root):
+        adapter = pi_runtime.PiRuntimeAdapter(root)
+        source = adapter.discover(DiscoveryContext(home="/home/test"))[0]
+        return adapter.load(source, meter.DetailLevel.SUMMARY)
+
+    def test_call_cap_marks_nested_spend_partial_not_complete(self):
+        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(root, [one_cent] * 600)
+            _source, state, summary = self._load(root)
+            loaded = self._native_load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertLessEqual(len(children), pi_runtime.MAX_SUBAGENT_RUNS)
+        for payload in (state, summary):
+            self.assertFalse(payload["availability"]["cost"])
+            self.assertFalse(payload["availability"]["tokens"])
+            self.assertFalse(payload["availability"]["cache"])
+        self.assertIsNone(loaded.usage.cost_usd.value)
+        self.assertIsNone(loaded.usage.input_tokens.value)
+        self.assertIsNone(loaded.usage.cache_read_tokens.value)
+        self.assertIn("history_truncated",
+                      [warning.code for warning in loaded.warnings])
+
+    def test_per_call_details_respect_the_run_cap(self):
+        single = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
+        wide = [
+            self._child_result(usage=self._child_usage(10, 1, cost=0.01))
+            for _ in range(pi_runtime.MAX_SUBAGENT_RUNS)
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(
+                root, [single] * (pi_runtime.MAX_SUBAGENT_RUNS - 1) + [wide],
+            )
+            _source, state, summary = self._load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertEqual(len(children), pi_runtime.MAX_SUBAGENT_RUNS)
+        self.assertFalse(summary["availability"]["cost"])
+        self.assertFalse(state["availability"]["cost"])
+
+    def test_calls_within_the_cap_stay_complete(self):
+        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(root, [one_cent] * 3)
+            _source, state, summary = self._load(root)
+
+        self.assertTrue(summary["availability"]["cost"])
+        self.assertTrue(state["availability"]["cost"])
+        self.assertAlmostEqual(state["total_cost"], 0.0333)
+
+    def test_nonempty_results_without_valid_entries_is_an_unavailable_run(self):
+        for results in (["not-a-dict"], [None, 7], [["nested"]]):
+            with self.subTest(results=results), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                self._write_subagent_session(root, results=results)
+                _source, state, summary = self._load(root)
+
+                children = [
+                    record for record in summary.get("_agent_records", [])
+                    if record["kind"] == "spawned"
+                ]
+                self.assertEqual(len(children), 1)
+                self.assertFalse(children[0]["tokens_available"])
+                self.assertFalse(children[0]["cost_available"])
+                self.assertFalse(summary["availability"]["cost"])
+                self.assertFalse(state["availability"]["cost"])
+
+    def test_non_list_results_without_usage_is_an_unavailable_run(self):
+        for results in ("not-a-list", {"agent": "probe"}, 7):
+            with self.subTest(results=results), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                # Written raw: details.results is the malformed value itself.
+                self._write_many_calls(root, [results])
+                _source, state, summary = self._load(root)
+
+                children = [
+                    record for record in summary.get("_agent_records", [])
+                    if record["kind"] == "spawned"
+                ]
+                self.assertEqual(len(children), 1)
+                self.assertFalse(children[0]["tokens_available"])
+                self.assertFalse(children[0]["cost_available"])
+                self.assertFalse(summary["availability"]["cost"])
+                self.assertFalse(state["availability"]["cost"])
+
+    def test_call_cap_surfaces_in_cross_session_agent_inventory(self):
+        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(root, [one_cent] * 600)
+            _source, _state, summary = self._load(root)
+            cross = self._cross(root)
+
+        self.assertTrue(summary["_agent_records_partial"])
+        self.assertNotIn("_agent_records_truncated", summary)
+        usage = cross["agent_usage"]
+        self.assertEqual(usage["totals"]["agents"], pi_runtime.MAX_SUBAGENT_RUNS)
+        self.assertFalse(usage["totals"]["cost_available"])
+        self.assertFalse(usage["totals"]["tokens_available"])
+        self.assertIsNone(usage["totals"]["cost"])
+        self.assertAlmostEqual(
+            usage["totals"]["known_cost"], 0.01 * pi_runtime.MAX_SUBAGENT_RUNS,
+        )
+        # The run cap is partial coverage, not the inventory display limit.
+        self.assertFalse(usage["inventory_truncated"])
+        for row in usage["roles"] + usage["models"]:
+            self.assertFalse(row["cost_available"], row["id"])
+            self.assertEqual(
+                row["cost_covered_agents"], row["agents"], row["id"],
+            )
+        public = json.dumps(cross, default=str)
+        self.assertNotIn("_agent_records_partial", public)
+        self.assertNotIn("_coverage_partial", public)
+
+    def test_per_call_result_cap_surfaces_in_cross_session_inventory(self):
+        wide = [
+            self._child_result(usage=self._child_usage(10, 1, cost=0.01))
+            for _ in range(pi_runtime.MAX_SUBAGENT_RUNS + 5)
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(root, [wide])
+            cross = self._cross(root)
+
+        usage = cross["agent_usage"]
+        self.assertFalse(usage["inventory_truncated"])
+        self.assertFalse(usage["totals"]["cost_available"])
+        self.assertIsNone(usage["totals"]["cost"])
+        self.assertGreater(usage["totals"]["known_cost"], 0)
+
+    def test_calls_within_the_cap_keep_cross_session_inventory_complete(self):
+        one_cent = [self._child_result(usage=self._child_usage(10, 1, cost=0.01))]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(root, [one_cent] * 3)
+            _source, _state, summary = self._load(root)
+            cross = self._cross(root)
+
+        self.assertNotIn("_agent_records_truncated", summary)
+        self.assertNotIn("_agent_records_partial", summary)
+        usage = cross["agent_usage"]
+        self.assertEqual(usage["totals"]["agents"], 3)
+        self.assertTrue(usage["totals"]["cost_available"])
+        self.assertTrue(usage["totals"]["tokens_available"])
+        self.assertFalse(usage["inventory_truncated"])
+
+    def test_repeated_call_id_does_not_overwrite_finished_evidence(self):
+        repeat = {
+            "type": "message", "id": "assistant-repeat",
+            "timestamp": "2026-09-04T10:00:09Z",
+            "message": {
+                "role": "assistant", "model": "claude-test",
+                "provider": "anthropic", "stopReason": "stop",
+                "content": [{"type": "toolCall", "id": "call-0",
+                             "name": "subagent",
+                             "arguments": {"agent": "other"}}],
+                "usage": {"input": 1, "output": 1, "cacheRead": 0,
+                          "cacheWrite": 0,
+                          "cost": {"input": 0.0, "output": 0.0,
+                                   "cacheRead": 0.0, "cacheWrite": 0.0}},
+            },
+        }
+        result = [self._child_result(usage=self._child_usage(cost=0.25))]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_many_calls(root, [result], extra_rows=[repeat])
+            _source, state, summary = self._load(root)
+
+        children = [
+            record for record in summary["_agent_records"]
+            if record["kind"] == "spawned"
+        ]
+        self.assertEqual(len(children), 1)
+        self.assertEqual(children[0]["role"], "probe")
+        self.assertEqual(children[0]["activity_state"], "complete")
+        self.assertAlmostEqual(children[0]["cost"], 0.25)
+        self.assertTrue(state["availability"]["cost"])
+        self.assertAlmostEqual(state["total_cost"], 0.2533)
+
+    def test_child_without_cache_keys_is_not_a_complete_token_total(self):
+        usage = self._child_usage()
+        del usage["cacheRead"]
+        del usage["cacheWrite"]
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=usage)],
+            )
+            _source, state, summary = self._load(root)
+
+        child = self._records(summary)["spawned"]
+        self.assertFalse(child["cache_available"])
+        self.assertFalse(child["tokens_available"])
+        self.assertIsNone(child["tokens"])
+        self.assertFalse(summary["availability"]["cache"])
+        self.assertFalse(state["availability"]["cache"])
+
+    def _cross(self, root):
+        saved = dict(meter._xsess)
+        try:
+            meter._xsess.update({"data": None, "at": 0, "agent_groups": ()})
+            with mock.patch.object(meter, "PI_AGENT_DIR", str(root)), \
+                    mock.patch.object(meter, "_pi_native_adapters", {}), \
+                    mock.patch.object(meter, "_RUNTIME_REGISTRY", None), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                return meter.cross_session(sources=meter.pi_session_sources())
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved)
+
+    def test_child_model_sanitizer_table(self):
+        accepted = (
+            "claude-opus-5-5", "anthropic/claude-sonnet-5-5", "openai/gpt-5.6",
+            "gpt-5.6-sol", "grok-4.7", "llama3.1:8b", "qwen2.5-coder:32b",
+            "amazon.nova-pro-v1:0", "claude-opus-4@20250514",
+            "@cf/meta/llama-3.1-8b-instruct",
+            "us.anthropic.claude-sonnet-4-20250514-v1:0",
+            "us.anthropic.claude-opus-5-5-v1:0",
+            "eu.anthropic.claude-sonnet-5-5-v1:0",
+            "meta.llama3-70b-instruct-v1:0", "claude-sonnet-4@20250514",
+            "model@latest", "model@v2.1.0", "model@1.2", "model@v1",
+            "@cf/meta/llama-3-8b", "accounts/fireworks/models/x",
+            "openrouter/anthropic/claude-opus-5-5", "gemini-2.5-pro",
+            "deepseek-r1:70b", "qwen2.5-coder:7b", "gpt-oss:20b",
+            "phi3:3.8b", "model:latest", "hf.co/unsloth/model",
+            "huggingface.co/org/model",
+            # Short vendor prefixes followed by an ordinary word stay names.
+            "xai-researcher", "hf_transformers",
+        )
+        rejected = (
+            "internal.corp.example.com:8443", "10.0.0.5:11434", "10.0.0.5",
+            "localhost:8080", "internal.corp.example.com",
+            "alice@corp.example.com", "user@host", "model@corp.example.com",
+            "sk-proj-abc123", "openai/sk-proj-abc123",
+            "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.c2lnbmF0dXJl",
+            "ghp_abcdefghijklmnop", "gho_abcdefghijklmnop",
+            "github_pat_11ABCDEFG", "xoxb-1234-5678-abcd", "xoxp-1234-5678",
+            "AKIAIOSFODNN7EXAMPLE", "vendor/AKIAIOSFODNN7EXAMPLE",
+            # Host, IP, or host:port in any path segment.
+            "ollama/10.0.0.5:11434", "provider/host.example.com:8443/m",
+            "hf.co/10.0.0.5:8080/model", "vendor/gateway:8080",
+            # Account or host after @ instead of a version.
+            "bob@10.0.0.5", "model@1.2.3.4", "a@1host.corp.com",
+            "ollama@192.168.1.4", "model@2.example.com",
+            # Single-label host with a port-shaped tag.
+            "myhost:11434", "gateway:8080",
+            # Additional vendor credential prefixes, any case.
+            "hf_AbCdEfGhIjKlMnOpQrStUvWx", "HF_AbCdEfGhIjKlMnOpQrStUvWx",
+            "xai-AbCdEfGhIjKlMnOpQrStUv", "AIzaSyA1234567890abcdefghij",
+            "glpat-abcdefgh", "GLPAT-abcdefgh", "npm_AbCdEfGhIjKlMnOpQrStUv",
+            "sk_live_abc123", "sk_test_abc123", "pk_live_abc123",
+            "rk_live_abc123", "akiaiosfodnn7example",
+            "vendor/glpat-abcdefgh",
+        )
+        for value in accepted:
+            self.assertEqual(pi_runtime._subagent_model_id(value), value)
+        for value in rejected:
+            self.assertEqual(pi_runtime._subagent_model_id(value), "", value)
+        for value in rejected:
+            with self.subTest(model=value), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                self._write_subagent_session(root, results=[
+                    self._child_result(usage=self._child_usage(), model=value),
+                ])
+                _source, state, summary = self._load(root)
+                cross = self._cross(root)
+
+                child = self._records(summary)["spawned"]
+                self.assertEqual(child["model"], "unknown-model")
+                encoded = json.dumps(
+                    {"summary": summary, "state": state, "cross": cross},
+                    default=str,
+                )
+                self.assertNotIn(value, encoded)
+                self.assertNotIn(value.lower(), encoded)
+
+    def test_child_role_rejects_secret_token_shapes(self):
+        accepted = (
+            "probe", "scout", "task-runner", "worker_2", "skeptic",
+            # Short prefixes need a 16+ character key-like run to count.
+            "xai-researcher", "hf_helper", "npm_runner", "aizawa",
+        )
+        rejected = (
+            "sk-abcdef", "my-sk-abcdef", "ghp_abcdef", "gho_abcdef",
+            "github_pat_11ABC", "xoxb-1234", "xoxp-1234",
+            "AKIAIOSFODNN7EXAMPLE", "akiaiosfodnn7example",
+            "hf_AbCdEfGhIjKlMnOpQr", "xai-AbCdEfGhIjKlMnOpQr",
+            "npm_AbCdEfGhIjKlMnOpQr", "AIzaSyA1234567890abcdef",
+            "glpat-abcdef", "sk_live_abc", "sk_test_abc", "pk_live_abc",
+            "rk_live_abc", "worker-glpat-x",
+        )
+        for value in accepted:
+            self.assertEqual(pi_runtime._safe_agent_role(value), value)
+        for value in rejected:
+            self.assertEqual(pi_runtime._safe_agent_role(value), "", value)
+        for value in rejected:
+            with self.subTest(role=value), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp) / "agent"
+                self._write_subagent_session(
+                    root, arguments={"agent": value},
+                    results=[self._child_result(value, usage=self._child_usage())],
+                )
+                _source, state, summary = self._load(root)
+                cross = self._cross(root)
+
+                self.assertIsNone(self._records(summary)["spawned"]["role"])
+                encoded = json.dumps(
+                    {"summary": summary, "state": state, "cross": cross},
+                    default=str,
+                )
+                self.assertNotIn(value, encoded)
+
+    def test_canonical_agent_sources_selects_pi_rows(self):
+        source = {
+            "id": "pi-session", "path": "/tmp/pi.jsonl", "provider": "pi",
+            "runtime": "Pi", "label": "Pi", "project": "/repo", "mtime": 1,
+        }
+        other = {
+            "id": "kiro-session", "path": "/tmp/kiro.json",
+            "provider": "kiro", "runtime": "Kiro", "label": "Kiro",
+            "project": "/repo", "mtime": 1,
+        }
+        selected = meter.canonical_agent_sources([source, other])
+        self.assertEqual(selected, [source])
+
+    def test_agent_group_and_inventory_include_pi_children(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "agent"
+            self._write_subagent_session(
+                root, results=[self._child_result(usage=self._child_usage())],
+            )
+            _source, _state, summary = self._load(root)
+
+        groups = meter._domain_build_agent_groups([summary])
+        usage = meter._agent_usage_projection(
+            meter._domain_aggregate_agent_usage(groups)
+        )
+        self.assertEqual(len(groups), 1)
+        self.assertEqual(usage["totals"]["agents"], 1)
+        self.assertAlmostEqual(usage["totals"]["cost"], 0.25)
+        self.assertEqual(usage["inventory"][0]["role"], "probe")
+        self.assertEqual(usage["inventory"][0]["runtime"], "pi")
+        self.assertEqual(
+            usage["models"][0]["id"],
+            "opencode-go/deepseek-v4.1-flash::pi::spawned",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_pricing.py b/tests/test_pricing.py
new file mode 100644
index 00000000..07f07d1f
--- /dev/null
+++ b/tests/test_pricing.py
@@ -0,0 +1,1153 @@
+import unittest
+import datetime
+import json
+import os
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from token_meter.contracts import DiscoveryContext
+from token_meter.runtimes.codex import CodexRuntimeAdapter
+
+
+class RemovedLanguageSignalTests(unittest.TestCase):
+    def test_language_signal_endpoints_return_not_found(self):
+        for path in ("/settings/language-signals", "/settings/frustration"):
+            with self.subTest(path=path):
+                handler = object.__new__(meter.H)
+                handler.path = path
+                errors, responses = [], []
+                handler.send_error = lambda status: errors.append(status)
+                handler._send = lambda *args, **kwargs: responses.append((args, kwargs))
+                handler.headers = {"Host": "127.0.0.1:8722"}
+                handler.do_POST()
+                self.assertEqual(errors, [404])
+                self.assertEqual(responses, [])
+
+    def test_language_signal_code_is_gone_from_backend_and_parsers(self):
+        for name in (
+            "language_signal_settings", "set_language_signal_terms", "frustration_settings",
+            "set_frustration_terms", "analyze_language_signals", "analyze_language_signal_turns",
+            "attach_language_signals", "aggregate_language_signals", "aggregate_frustration",
+            "DEFAULT_FRUSTRATION_TERMS", "DEFAULT_POSITIVE_TERMS",
+        ):
+            self.assertFalse(hasattr(meter, name), name)
+        root = Path(meter.IMPLEMENTATION_FILE).parent
+        for path in sorted((root / "runtimes").glob("*.py")) + [root / "domain" / "aggregates.py"]:
+            source = path.read_text()
+            for marker in ("language_signal", "frustration", "signal_turns"):
+                self.assertNotIn(marker, source, f"{path.name}: {marker}")
+        self.assertNotIn('"language_signals"', Path(meter.IMPLEMENTATION_FILE).read_text())
+
+    def test_cross_session_payload_has_no_language_signal_fields(self):
+        def row(source):
+            return {
+                **source, "turns": 1, "cost": 1.0, "tokens": 100,
+                "input_tokens": 90, "output_tokens": 10,
+                "models": ["claude-test"], "token_estimate": False,
+                "availability": meter.metric_availability(
+                    "claude", cost=True, tokens=True,
+                    input_tokens=True, output_tokens=True,
+                ),
+                "_model_cost": {"claude-test": 1.0},
+                "_model_tok": {"claude-test": 100},
+                "_day_cost": {"2026-08-18": 1.0}, "model_stats": [],
+                "_model_daily": [], "_performance_samples": [],
+                "_wait_samples": [], "_tool_evidence": {},
+            }
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["data"], meter._xsess["at"] = None, 0
+            with mock.patch.object(meter, "session_summary", side_effect=row), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                result = meter.cross_session(sources=[{
+                    "id": "only", "path": "/tmp/only", "provider": "claude",
+                    "runtime": "Claude", "label": "Claude Desktop", "project": "/repo", "mtime": 1,
+                }])
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertNotIn("language_signals", result)
+        self.assertNotIn("frustration", result)
+        self.assertNotIn("language_signals", json.dumps(result))
+
+    def test_every_settings_write_drops_obsolete_language_signal_terms(self):
+        obsolete = {
+            "language_signal_terms": {"positive": ["great"], "friction": ["damn"]},
+            "frustration_terms": ["damn"],
+        }
+        writers = {
+            "updates": lambda path: meter.set_update_settings({"enabled": False, "auto_install": False}, path),
+            "budgets": lambda path: meter.set_budget_settings({"monthly_usd": 50}, path),
+            "session_budget": lambda path: meter.set_session_budget_override("session-a", 5, path=path),
+            "default_session_budget": lambda path: meter.set_default_session_budget_value(12, path=path),
+            "model_pricing": lambda path: meter.set_model_price(
+                "claude", "claude-sonnet-5",
+                {"input": 4, "output": 20, "cache_write": 5, "cache_read": 0.4},
+                effective_from=100, path=path,
+            ),
+            "work_insights": lambda path: meter.set_work_insights_settings({"pause_on_battery": False}, path),
+        }
+        for name, write in writers.items():
+            with self.subTest(writer=name), tempfile.TemporaryDirectory() as tmp:
+                path = Path(tmp) / "settings.json"
+                path.write_text(json.dumps({**obsolete, "unrelated": {"keep": True}}))
+                with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                    result = write(str(path))
+                saved = json.loads(path.read_text())
+                self.assertTrue(result.get("ok"), result)
+                self.assertNotIn("language_signal_terms", saved)
+                self.assertNotIn("frustration_terms", saved)
+                self.assertEqual(saved["unrelated"], {"keep": True})
+
+    def test_reading_settings_never_rewrites_obsolete_terms(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            original = json.dumps({"frustration_terms": ["damn"]})
+            path.write_text(original)
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                meter.update_settings(str(path))
+                meter.budget_settings(str(path))
+                meter.model_pricing_settings()
+            self.assertEqual(path.read_text(), original)
+
+
+class PricingTests(unittest.TestCase):
+    def test_builtin_pricing_exposes_reviewed_primary_sources(self):
+        pricing = meter.model_pricing_settings()
+        self.assertEqual(pricing["reviewed_on"], "2026-09-30")
+        self.assertEqual(
+            [source["provider"] for source in pricing["sources"]],
+            ["anthropic", "openai", "cursor", "google"],
+        )
+        self.assertEqual(
+            [source["url"] for source in pricing["sources"]],
+            [
+                "https://platform.claude.com/docs/en/about-claude/pricing",
+                "https://developers.openai.com/api/docs/models/compare",
+                "https://cursor.com/docs/models-and-pricing",
+                "https://ai.google.dev/gemini-api/docs/pricing",
+            ],
+        )
+
+    def test_current_anthropic_builtin_prices_match_primary_source(self):
+        self.assertEqual(meter.CLAUDE_PRICE["claude-fable-5"], {
+            "input": 10.0, "output": 50.0,
+            "cache_write": 12.5, "cache_read": 1.0,
+        })
+        self.assertEqual(meter.CLAUDE_PRICE["claude-opus-4-8"], {
+            "input": 5.0, "output": 25.0,
+            "cache_write": 6.25, "cache_read": 0.5,
+        })
+
+    def test_opus_5_uses_published_api_rates(self):
+        price, approximate = meter.price_for("claude-opus-5", "claude")
+        self.assertEqual(price, {
+            "input": 5.0, "output": 25.0, "cache_write": 6.25, "cache_read": 0.5,
+        })
+        self.assertFalse(approximate)
+        row = next(
+            item for item in meter.model_pricing_settings()["models"]
+            if item["provider"] == "claude" and item["model"] == "claude-opus-5"
+        )
+        self.assertTrue(row["builtin"])
+        self.assertFalse(row["overridden"])
+        self.assertEqual(row["source"], "built-in")
+
+    def test_sonnet_5_uses_current_standard_api_rates(self):
+        price, approximate = meter.price_for("claude-sonnet-5", "claude")
+        self.assertEqual(price, {"input": 2.0, "output": 10.0, "cache_write": 2.5, "cache_read": 0.2})
+        self.assertFalse(approximate)
+
+    def test_sonnet_5_5_uses_published_rates_in_settings_and_estimates(self):
+        expected = {
+            "input": 2.0, "output": 10.0,
+            "cache_write": 2.5, "cache_read": 0.2,
+        }
+        with tempfile.TemporaryDirectory() as tmp:
+            rows = [
+                item for item in meter.model_pricing_settings(
+                    path=str(Path(tmp) / "settings.json"),
+                )["models"]
+                if item["provider"] == "claude"
+                and item["model"] == "claude-sonnet-5-5"
+            ]
+        self.assertEqual(len(rows), 1)
+        row = rows[0]
+        self.assertEqual(row["prices"], expected)
+        self.assertTrue(row["builtin"])
+        self.assertEqual(row["source"], "built-in")
+        price, unavailable = meter.price_for("claude-sonnet-5-5", "claude")
+        self.assertEqual(price, expected)
+        self.assertFalse(unavailable)
+
+    def test_unknown_models_do_not_inherit_runtime_default_prices(self):
+        for provider, model, default_price in (
+            ("claude", "claude-future-unknown", meter.CLAUDE_PRICE[meter.DEFAULT_CLAUDE_MODEL]),
+            ("codex", "gpt-future-unknown", meter.OPENAI_PRICE[meter.DEFAULT_OPENAI_MODEL]),
+            ("opencode", "future-model", {
+                "input": 2.0, "output": 10.0,
+                "cache_write": 2.5, "cache_read": 0.2,
+            }),
+        ):
+            with self.subTest(provider=provider, model=model):
+                price, unavailable = meter.price_for(model, provider)
+                self.assertEqual(price, meter.ZERO_PRICE)
+                self.assertNotEqual(price, default_price)
+                self.assertTrue(unavailable)
+
+    def test_codex_path_discovery_does_not_invent_a_default_model(self):
+        path = os.path.expanduser("~/.codex/sessions/model-less.jsonl")
+        with (
+            mock.patch.object(meter, "all_session_sources", return_value=[]),
+            mock.patch.object(meter, "codex_meta", return_value={}),
+            mock.patch.object(meter, "safe_mtime", return_value=0),
+        ):
+            source = meter.source_from_path(path)
+
+        self.assertEqual(source["model"], "unknown-model")
+
+    def test_gpt_5_6_uses_current_sol_api_rates(self):
+        price, approximate = meter.price_for("gpt-5.6", "codex")
+        expected = {
+            "input": 4.0, "output": 20.0, "cache_write": 5.0, "cache_read": 0.4,
+        }
+        self.assertEqual(price, expected)
+        self.assertFalse(approximate)
+        explicit, explicit_approximate = meter.price_for("gpt-5.6-sol", "codex")
+        self.assertEqual(explicit, price)
+        self.assertFalse(explicit_approximate)
+        for model in ("gpt-5.6", "gpt-5.6-sol"):
+            with self.subTest(model=model):
+                row = next(
+                    item for item in meter.model_pricing_settings()["models"]
+                    if item["provider"] == "codex" and item["model"] == model
+                )
+                self.assertEqual(row["prices"], expected)
+                self.assertEqual(row["source"], "built-in")
+
+    def test_gpt_5_6_current_tier_prices_match_official_model_catalog(self):
+        expected = {
+            "gpt-5.6-terra": {
+                "input": 2.0, "output": 12.0, "cache_write": 2.5, "cache_read": 0.2,
+            },
+            "gpt-5.6-luna": {
+                "input": 0.2, "output": 1.2, "cache_write": 0.25, "cache_read": 0.02,
+            },
+        }
+        for model, prices in expected.items():
+            with self.subTest(model=model):
+                actual, approximate = meter.price_for(model, "codex")
+                self.assertEqual(actual, prices)
+                self.assertFalse(approximate)
+
+    def test_gpt_6_astra_uses_official_api_rates_and_appears_in_settings(self):
+        expected = {
+            "input": 10.0, "output": 50.0,
+            "cache_write": 12.5, "cache_read": 1.0,
+        }
+        actual, unavailable = meter.price_for("gpt-6-astra", "codex")
+
+        self.assertEqual(actual, expected)
+        self.assertFalse(unavailable)
+        row = next(
+            item for item in meter.model_pricing_settings()["models"]
+            if item["provider"] == "codex" and item["model"] == "gpt-6-astra"
+        )
+        self.assertTrue(row["builtin"])
+        self.assertFalse(row["overridden"])
+        self.assertEqual(row["source"], "built-in")
+        self.assertEqual(row["prices"], expected)
+
+    def test_gpt_5_6_price_cutover_preserves_older_session_estimates(self):
+        previous = {
+            "input": 5.0, "output": 30.0, "cache_write": 6.25, "cache_read": 0.5,
+        }
+        for model, current_input in (("gpt-5.6-terra", 2.0), ("gpt-5.6-luna", 0.2)):
+            with self.subTest(model=model):
+                old, old_approximate = meter.price_for(
+                    model, "codex", at=meter.GPT_56_PRICE_UPDATE_AT - 1,
+                )
+                current, current_approximate = meter.price_for(
+                    model, "codex", at=meter.GPT_56_PRICE_UPDATE_AT,
+                )
+                self.assertEqual(old, previous)
+                self.assertFalse(old_approximate)
+                self.assertEqual(current["input"], current_input)
+                self.assertFalse(current_approximate)
+
+    def test_gpt_5_6_long_context_multiplier_starts_at_price_cutover(self):
+        usage = {
+            "input_tokens": meter.GPT_56_LONG_CONTEXT_TOKENS + 1,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "output_tokens": 100_000,
+        }
+        old = meter.cost_of(
+            usage, "gpt-5.6-sol", "cursor", at=meter.GPT_56_PRICE_UPDATE_AT - 1,
+        )
+        current = meter.cost_of(
+            usage, "gpt-5.6-sol", "cursor", at=meter.GPT_56_PRICE_UPDATE_AT,
+        )
+        self.assertAlmostEqual(old["input"], usage["input_tokens"] * 5.0 / 1e6)
+        self.assertAlmostEqual(old["output"], 3.0)
+        self.assertAlmostEqual(current["input"], usage["input_tokens"] * 5.0 * 2.0 / 1e6)
+        self.assertAlmostEqual(current["output"], 4.5)
+
+    def test_codex_credit_pricing_has_no_long_context_surcharge(self):
+        from token_meter.models.catalog import GPT_56_SOL_PRICE_UPDATE_AT as at
+        usage = {
+            "input_tokens": meter.GPT_56_LONG_CONTEXT_TOKENS - 99_999,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 100_000,
+            "output_tokens": 100_000,
+        }
+        for model in ("gpt-5.6-sol", "gpt-6.1-sol"):
+            with self.subTest(model=model):
+                price, _ = meter.price_for(model, "codex", at=at)
+                codex = meter.cost_of(usage, model, "codex", at=at)
+                self.assertAlmostEqual(codex["input"], usage["input_tokens"] * price["input"] / 1e6)
+                self.assertAlmostEqual(codex["cache_read"], 100_000 * price["cache_read"] / 1e6)
+                self.assertAlmostEqual(codex["output"], 100_000 * price["output"] / 1e6)
+        cursor_price, _ = meter.price_for("gpt-5.6-sol", "cursor", at=at)
+        cursor = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=at)
+        self.assertAlmostEqual(
+            cursor["input"], usage["input_tokens"] * cursor_price["input"] * 2.0 / 1e6,
+        )
+        self.assertAlmostEqual(cursor["output"], 100_000 * cursor_price["output"] * 1.5 / 1e6)
+
+    def test_cursor_long_context_surcharge_boundary_and_cache_savings(self):
+        from token_meter.models.catalog import GPT_56_SOL_PRICE_UPDATE_AT as at
+        price, _ = meter.price_for("gpt-5.6-sol", "cursor", at=at)
+        # Cache writes and cache reads count toward the context threshold.
+        for context, multiplier in ((272_000, 1.0), (272_001, 2.0)):
+            with self.subTest(context=context):
+                usage = {
+                    "input_tokens": context - 2_000,
+                    "cache_creation_input_tokens": 1_000,
+                    "cache_read_input_tokens": 1_000,
+                    "output_tokens": 0,
+                }
+                cost = meter.cost_of(usage, "gpt-5.6-sol", "cursor", at=at)
+                self.assertAlmostEqual(
+                    cost["input"], (context - 2_000) * price["input"] * multiplier / 1e6,
+                )
+                self.assertAlmostEqual(
+                    cost["cache_write"], 1_000 * price["cache_write"] * multiplier / 1e6,
+                )
+                savings = meter.cache_savings({}, "cursor", "gpt-5.6-sol", [{
+                    "model": "gpt-5.6-sol", "ts": at,
+                    "tokens": {"fresh_input": context - 2_000,
+                               "cache_read": 1_000, "cache_write": 1_000},
+                }])
+                self.assertAlmostEqual(
+                    savings,
+                    1_000 * (price["input"] - price["cache_read"]) * multiplier / 1e6,
+                )
+
+    def test_custom_model_price_persists_and_drives_cost_calculation(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                result = meter.set_model_price(
+                    "openai", "gpt-custom-1",
+                    {"input": 1.25, "output": 6.5, "cache_write": 0, "cache_read": 0.2},
+                )
+                price, approximate = meter.price_for("gpt-custom-1", "codex")
+                cost = meter.cost_of({
+                    "input_tokens": 1_000_000,
+                    "output_tokens": 1_000_000,
+                    "cache_creation_input_tokens": 1_000_000,
+                    "cache_read_input_tokens": 1_000_000,
+                }, "gpt-custom-1", "codex")
+                saved = json.loads(path.read_text())
+        self.assertTrue(result["ok"])
+        self.assertEqual(price, {
+            "input": 1.25, "output": 6.5, "cache_write": 0.0, "cache_read": 0.2,
+        })
+        self.assertFalse(approximate)
+        self.assertEqual(cost, {
+            "input": 1.25, "output": 6.5, "cache_write": 0.0, "cache_read": 0.2,
+        })
+        self.assertIn("gpt-custom-1", saved["model_pricing"]["codex"])
+        self.assertIsInstance(saved["model_pricing"]["codex"]["gpt-custom-1"], list)
+        self.assertIsNotNone(
+            saved["model_pricing"]["codex"]["gpt-custom-1"][0]["effective_from"]
+        )
+
+    def test_model_price_batch_persists_multiple_rows_with_one_atomic_write(self):
+        changes = [
+            {
+                "provider": "claude", "model": "claude-opus-5",
+                "prices": {"input": 6, "output": 30, "cache_write": 7.5, "cache_read": 0.6},
+            },
+            {
+                "provider": "codex", "model": "gpt-5.4",
+                "prices": {"input": 3, "output": 18, "cache_write": 0, "cache_read": 0.3},
+            },
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            original_write = meter.atomic_write_text
+            with mock.patch.object(
+                    meter, "atomic_write_text", side_effect=original_write) as write:
+                result = meter.set_model_prices(
+                    changes, path=str(path), effective_from=100,
+                )
+            saved = json.loads(path.read_text())
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["effective_scope"], "selected_time")
+        self.assertEqual(len(result["changes"]), 2)
+        self.assertEqual(write.call_count, 1)
+        self.assertEqual(
+            saved["model_pricing"]["claude"]["claude-opus-5"][0]["effective_from"],
+            100.0,
+        )
+        self.assertEqual(
+            saved["model_pricing"]["codex"]["gpt-5.4"][0]["effective_from"],
+            100.0,
+        )
+
+    def test_invalid_model_price_batch_is_rejected_without_any_write(self):
+        changes = [
+            {
+                "provider": "codex", "model": "gpt-valid",
+                "prices": {"input": 1, "output": 4, "cache_write": 0, "cache_read": 0.1},
+            },
+            {
+                "provider": "codex", "model": "gpt-invalid",
+                "prices": {"input": -1, "output": 4, "cache_write": 0, "cache_read": 0.1},
+            },
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text('{"keep": "unchanged"}\n')
+            before = path.read_text()
+            with mock.patch.object(meter, "atomic_write_text") as write:
+                result = meter.set_model_prices(changes, path=str(path))
+            after = path.read_text()
+        self.assertFalse(result["ok"])
+        self.assertEqual(before, after)
+        write.assert_not_called()
+
+    def test_model_price_batch_rejects_duplicate_provider_model_entries(self):
+        price = {"input": 1, "output": 4, "cache_write": 0, "cache_read": 0.1}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            result = meter.set_model_prices([
+                {"provider": "openai", "model": "gpt-duplicate", "prices": price},
+                {"provider": "codex", "model": "gpt-duplicate", "prices": price},
+            ], path=str(path))
+        self.assertFalse(result["ok"])
+        self.assertIn("duplicate", result["error"].lower())
+        self.assertFalse(path.exists())
+
+    def test_builtin_override_can_be_restored_without_losing_other_settings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"frustration_terms": ["damn"], "unrelated": {"keep": True}}))
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                changed = meter.set_model_price(
+                    "claude", "claude-sonnet-5",
+                    {"input": 4, "output": 20, "cache_write": 5, "cache_read": 0.4},
+                    effective_from=100,
+                )
+                price, approximate = meter.price_for(
+                    "claude-sonnet-5", "claude", at=150,
+                )
+                pricing = meter.model_pricing_settings()
+                restored = meter.set_model_price(
+                    "claude", "claude-sonnet-5", remove=True,
+                    effective_from=200,
+                )
+                default_price, default_approximate = meter.price_for(
+                    "claude-sonnet-5", "claude", at=200,
+                )
+                historical_price, _ = meter.price_for(
+                    "claude-sonnet-5", "claude", at=150,
+                )
+                saved = json.loads(path.read_text())
+        row = next(
+            item for item in pricing["models"]
+            if item["provider"] == "claude" and item["model"] == "claude-sonnet-5"
+        )
+        self.assertTrue(changed["ok"])
+        self.assertEqual(price["input"], 4.0)
+        self.assertFalse(approximate)
+        self.assertEqual(row["source"], "override")
+        self.assertTrue(restored["ok"])
+        self.assertEqual(default_price, meter.CLAUDE_PRICE["claude-sonnet-5"])
+        self.assertFalse(default_approximate)
+        self.assertEqual(historical_price["input"], 4.0)
+        self.assertEqual(saved["unrelated"], {"keep": True})
+        self.assertNotIn("frustration_terms", saved)
+        periods = saved["model_pricing"]["claude"]["claude-sonnet-5"]
+        self.assertEqual(periods[0]["effective_from"], 100.0)
+        self.assertEqual(periods[1], {"effective_from": 200.0, "use_builtin": True})
+
+    def test_legacy_override_remains_all_history_and_migrates_on_next_edit(self):
+        legacy = {"input": 7, "output": 21, "cache_write": 8, "cache_read": 0.7}
+        updated = {"input": 4, "output": 12, "cache_write": 5, "cache_read": 0.4}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({
+                "model_pricing": {"codex": {"gpt-5.6-terra": legacy}},
+                "language_signal_terms": {"positive": ["great"], "friction": ["damn"]},
+                "unrelated": {"keep": True},
+            }))
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                before_migration, _ = meter.price_for("gpt-5.6-terra", "codex", at=1)
+                result = meter.set_model_price(
+                    "codex", "gpt-5.6-terra", updated, effective_from=500,
+                )
+                before_cutoff, _ = meter.price_for("gpt-5.6-terra", "codex", at=499)
+                at_cutoff, _ = meter.price_for("gpt-5.6-terra", "codex", at=500)
+                saved = json.loads(path.read_text())
+        self.assertTrue(result["ok"])
+        self.assertEqual(before_migration, {key: float(value) for key, value in legacy.items()})
+        self.assertEqual(before_cutoff, before_migration)
+        self.assertEqual(at_cutoff, {key: float(value) for key, value in updated.items()})
+        self.assertEqual(saved["unrelated"], {"keep": True})
+        self.assertNotIn("language_signal_terms", saved)
+        periods = saved["model_pricing"]["codex"]["gpt-5.6-terra"]
+        self.assertIsNone(periods[0]["effective_from"])
+        self.assertEqual(periods[1]["effective_from"], 500.0)
+
+    def test_custom_model_can_be_retired_without_losing_historical_price(self):
+        prices = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                added = meter.set_model_price(
+                    "codex", "gpt-retired", prices, effective_from=100,
+                )
+                retired = meter.set_model_price(
+                    "codex", "gpt-retired", remove=True, effective_from=200,
+                )
+                old, old_approximate = meter.price_for("gpt-retired", "codex", at=150)
+                current, current_approximate = meter.price_for("gpt-retired", "codex", at=200)
+                pricing = meter.model_pricing_settings()
+                saved = json.loads(path.read_text())
+        row = next(item for item in pricing["models"] if item["model"] == "gpt-retired")
+        self.assertTrue(added["ok"])
+        self.assertTrue(retired["ok"])
+        self.assertEqual(old, {key: float(value) for key, value in prices.items()})
+        self.assertFalse(old_approximate)
+        self.assertTrue(current_approximate)
+        self.assertNotEqual(current, old)
+        self.assertFalse(row["active"])
+        self.assertEqual(row["source"], "retired")
+        self.assertEqual(row["effective_from"], 200.0)
+        self.assertEqual(row["prices"], old)
+        self.assertEqual(pricing["retired_custom_models"], 1)
+        self.assertEqual(
+            saved["model_pricing"]["codex"]["gpt-retired"][-1],
+            {"effective_from": 200.0, "inactive": True},
+        )
+
+    def test_apply_to_all_history_is_explicit_and_replaces_timeline(self):
+        first = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
+        global_price = {"input": 2, "output": 6, "cache_write": 0, "cache_read": 0.2}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                meter.set_model_price("codex", "gpt-global", first, effective_from=100)
+                result = meter.set_model_price(
+                    "codex", "gpt-global", global_price, apply_to_all_history=True,
+                )
+                historical, approximate = meter.price_for("gpt-global", "codex", at=1)
+                saved = json.loads(path.read_text())
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["apply_to_all_history"])
+        self.assertIsNone(result["effective_from"])
+        self.assertFalse(approximate)
+        self.assertEqual(historical, {key: float(value) for key, value in global_price.items()})
+        self.assertEqual(len(saved["model_pricing"]["codex"]["gpt-global"]), 1)
+        self.assertIsNone(saved["model_pricing"]["codex"]["gpt-global"][0]["effective_from"])
+
+    def test_identical_current_price_does_not_add_redundant_period(self):
+        prices = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            first = meter.set_model_price(
+                "codex", "gpt-idempotent", prices, path=str(path), effective_from=100,
+            )
+            repeated = meter.set_model_price(
+                "codex", "gpt-idempotent", prices, path=str(path), effective_from=200,
+            )
+            saved = json.loads(path.read_text())
+        self.assertTrue(first["changed"])
+        self.assertFalse(repeated["changed"])
+        self.assertEqual(len(saved["model_pricing"]["codex"]["gpt-idempotent"]), 1)
+
+    def test_session_cost_can_span_manual_price_periods(self):
+        usage = {
+            "input_tokens": 1_000_000,
+            "output_tokens": 0,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+        }
+        override = {"input": 4, "output": 20, "cache_write": 5, "cache_read": 0.4}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                meter.set_model_price(
+                    "claude", "claude-sonnet-5", override, effective_from=100,
+                )
+                before = meter.cost_of(usage, "claude-sonnet-5", "claude", at=99)
+                after = meter.cost_of(usage, "claude-sonnet-5", "claude", at=100)
+        self.assertEqual(before["input"], 2.0)
+        self.assertEqual(after["input"], 4.0)
+        self.assertEqual(before["input"] + after["input"], 6.0)
+
+    def test_oversized_manual_history_is_ignored_without_repricing_builtin(self):
+        prices = {"input": 9, "output": 9, "cache_write": 9, "cache_read": 9}
+        periods = [
+            {"effective_from": index, "prices": prices}
+            for index in range(meter.MAX_MODEL_PRICE_PERIODS + 1)
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({
+                "model_pricing": {"claude": {"claude-sonnet-5": periods}},
+            }))
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(path)):
+                price, approximate = meter.price_for(
+                    "claude-sonnet-5", "claude", at=meter.MAX_MODEL_PRICE_PERIODS + 2,
+                )
+                row = next(
+                    item for item in meter.model_pricing_settings()["models"]
+                    if item["provider"] == "claude" and item["model"] == "claude-sonnet-5"
+                )
+        self.assertEqual(price, meter.CLAUDE_PRICE["claude-sonnet-5"])
+        self.assertFalse(approximate)
+        self.assertEqual(row["periods"], 0)
+
+    def test_model_pricing_http_action_forwards_bounded_scope_fields(self):
+        source = Path(meter.IMPLEMENTATION_FILE).read_text()
+        self.assertIn('if isinstance(payload.get("changes"), list)', source)
+        self.assertIn('set_model_prices(', source)
+        self.assertIn(
+            'apply_to_all_history=payload.get("apply_to_all_history") is True',
+            source,
+        )
+        self.assertIn('effective_from=payload.get("effective_from")', source)
+
+    def test_future_or_conflicting_effective_scope_is_rejected(self):
+        prices = {"input": 1, "output": 3, "cache_write": 0, "cache_read": 0.1}
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            future = meter.set_model_price(
+                "codex", "gpt-future", prices, path=str(path),
+                effective_from=meter.time.time() + 600,
+            )
+            conflicting = meter.set_model_price(
+                "codex", "gpt-conflict", prices, path=str(path),
+                effective_from=100, apply_to_all_history=True,
+            )
+        self.assertFalse(future["ok"])
+        self.assertIn("future", future["error"])
+        self.assertFalse(conflicting["ok"])
+        self.assertIn("either", conflicting["error"])
+        self.assertFalse(path.exists())
+
+    def test_invalid_custom_model_prices_are_rejected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            bad_model = meter.set_model_price(
+                "codex", "model with spaces",
+                {"input": 1, "output": 2, "cache_write": 0, "cache_read": 0},
+                path=str(path),
+            )
+            bad_price = meter.set_model_price(
+                "codex", "gpt-custom",
+                {"input": -1, "output": 2, "cache_write": 0, "cache_read": 0},
+                path=str(path),
+            )
+        self.assertFalse(bad_model["ok"])
+        self.assertFalse(bad_price["ok"])
+        self.assertFalse(path.exists())
+
+    def test_longest_model_prefix_wins(self):
+        price, approximate = meter.price_for("gpt-5.4-mini-2026-07-01", "codex")
+        self.assertEqual(price, meter.OPENAI_PRICE["gpt-5.4-mini"])
+        self.assertFalse(approximate)
+
+
+class CodexLineageAccountingTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name)
+        self.sessions = self.root / "sessions"
+        self.trace_root = self.sessions / "2026" / "08" / "11"
+        self.trace_root.mkdir(parents=True)
+        self.index = self.root / "session_index.jsonl"
+        self.index.write_text("")
+        self.context = DiscoveryContext(home=str(self.root))
+        self.adapter = CodexRuntimeAdapter(
+            self.sessions,
+            self.index,
+            compatibility=meter._codex_compatibility(),
+            default_model="gpt-5.6",
+        )
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def write_trace(self, name, rows, mtime):
+        path = self.trace_root / f"rollout-{name}.jsonl"
+        path.write_text("".join(json.dumps(row) + "\n" for row in rows))
+        os.utime(path, (mtime, mtime))
+        return path
+
+    @staticmethod
+    def meta(physical_id, logical_id="task-1", **extra):
+        return {
+            "timestamp": "2026-08-11T00:00:00.000Z",
+            "type": "session_meta",
+            "payload": {
+                "id": physical_id,
+                "session_id": logical_id,
+                "cwd": "/work/project",
+                **extra,
+            },
+        }
+
+    @staticmethod
+    def turn(timestamp):
+        return {
+            "timestamp": timestamp.replace("Z", ".000Z"),
+            "type": "turn_context",
+            "payload": {"model": "gpt-5.6", "cwd": "/work/project"},
+        }
+
+    @staticmethod
+    def tool(name, call_id, timestamp):
+        return {
+            "timestamp": timestamp.replace("Z", ".000Z"),
+            "type": "response_item",
+            "payload": {
+                "type": "function_call",
+                "name": name,
+                "call_id": call_id,
+                "arguments": {},
+            },
+        }
+
+    @staticmethod
+    def tokens(input_tokens, output_tokens, total_input, total_output, timestamp):
+        return {
+            "timestamp": timestamp.replace("Z", ".000Z"),
+            "type": "event_msg",
+            "payload": {"type": "token_count", "info": {
+                "last_token_usage": {
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                    "total_tokens": input_tokens + output_tokens,
+                },
+                "total_token_usage": {
+                    "input_tokens": total_input,
+                    "output_tokens": total_output,
+                    "total_tokens": total_input + total_output,
+                },
+            }},
+        }
+
+    def root_and_child_sources(self):
+        self.write_trace("root", [
+            self.meta("root-1"),
+            self.turn("2026-08-11T00:00:01Z"),
+            {"timestamp": "2026-08-11T00:00:01.000Z", "type": "event_msg",
+             "payload": {"type": "task_started"}},
+            self.tool("inherited_tool", "inherited-call", "2026-08-11T00:00:02Z"),
+            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:03Z"),
+            {"timestamp": "2026-08-11T00:00:04.000Z", "type": "event_msg",
+             "payload": {"type": "task_complete", "duration_ms": 3000}},
+        ], 10)
+        self.write_trace("child", [
+            self.meta("child-1", forked_from_id="root-1"),
+            self.meta("root-1"),
+            self.turn("2026-08-11T01:00:01Z"),
+            {"timestamp": "2026-08-11T01:00:01.000Z", "type": "event_msg",
+             "payload": {"type": "task_started"}},
+            self.tool("inherited_tool", "inherited-call", "2026-08-11T01:00:02Z"),
+            self.tokens(100, 10, 100, 10, "2026-08-11T01:00:03Z"),
+            {"timestamp": "2026-08-11T01:00:04.000Z", "type": "event_msg",
+             "payload": {"type": "task_complete", "duration_ms": 3000}},
+            self.turn("2026-08-11T02:00:01Z"),
+            {"timestamp": "2026-08-11T02:00:01.000Z", "type": "event_msg",
+             "payload": {"type": "task_started"}},
+            self.tool("child_tool", "child-call", "2026-08-11T02:00:02Z"),
+            self.tokens(50, 5, 150, 15, "2026-08-11T02:00:03Z"),
+        ], 20)
+        return {
+            source["physical_trace_id"]: source
+            for source in self.adapter.discover_legacy(self.context)
+        }
+
+    def root_child_and_grandchild_sources(self):
+        self.root_and_child_sources()
+        self.write_trace("grandchild", [
+            self.meta("grandchild-1", forked_from_id="child-1"),
+            self.turn("2026-08-11T03:00:01Z"),
+            {"timestamp": "2026-08-11T03:00:01.000Z", "type": "event_msg",
+             "payload": {"type": "task_started"}},
+            self.tool("inherited_tool", "inherited-call", "2026-08-11T03:00:02Z"),
+            self.tokens(100, 10, 100, 10, "2026-08-11T03:00:03Z"),
+            {"timestamp": "2026-08-11T03:00:04.000Z", "type": "event_msg",
+             "payload": {"type": "task_complete", "duration_ms": 3000}},
+            self.turn("2026-08-11T04:00:01Z"),
+            {"timestamp": "2026-08-11T04:00:01.000Z", "type": "event_msg",
+             "payload": {"type": "task_started"}},
+            self.tool("child_tool", "child-call", "2026-08-11T04:00:02Z"),
+            self.tokens(50, 5, 150, 15, "2026-08-11T04:00:03Z"),
+            {"timestamp": "2026-08-11T04:00:04.000Z", "type": "event_msg",
+             "payload": {"type": "task_complete", "duration_ms": 3000}},
+            self.turn("2026-08-11T05:00:01Z"),
+            {"timestamp": "2026-08-11T05:00:01.000Z", "type": "event_msg",
+             "payload": {"type": "task_started"}},
+            self.tool("grandchild_tool", "grandchild-call", "2026-08-11T05:00:02Z"),
+            self.tokens(20, 2, 170, 17, "2026-08-11T05:00:03Z"),
+        ], 30)
+        return {
+            source["physical_trace_id"]: source
+            for source in self.adapter.discover_legacy(self.context)
+        }
+
+    def test_legacy_detail_and_summary_use_the_same_corrected_child_rows(self):
+        sources = self.root_and_child_sources()
+
+        detail = self.adapter.recompute_legacy(sources["child-1"])
+        summary = self.adapter.summarize_legacy(sources["child-1"])
+
+        self.assertEqual(detail["total_tokens"], 55)
+        self.assertEqual(summary["tokens"], 55)
+        self.assertEqual(detail["total_tokens"], summary["tokens"])
+        self.assertAlmostEqual(detail["total_cost"], summary["cost"])
+        self.assertEqual(len(detail["executions"]), 1)
+        self.assertEqual(summary["turns"], 1)
+        self.assertEqual(
+            [tool["name"] for tool in detail["executions"][0]["tools"]],
+            ["child_tool"],
+        )
+        self.assertNotIn("complete", [event["kind"] for event in detail["trace"]])
+
+    def test_live_and_completed_throughput_use_only_corrected_child_rows(self):
+        sources = self.root_and_child_sources()
+
+        summary = self.adapter.summarize_legacy(sources["child-1"])
+
+        self.assertFalse(summary["throughput"]["available"])
+        self.assertTrue(summary["live_throughput"]["available"])
+        self.assertEqual(summary["live_throughput"]["completed_steps"], 1)
+        self.assertEqual(summary["live_throughput"]["measured_output_tokens"], 5)
+        self.assertEqual(summary["live_throughput"]["measured_seconds"], 2)
+        self.assertEqual(summary["live_throughput"]["output_tps"], 2.5)
+
+    def test_auto_review_child_inherits_its_linked_parent_model(self):
+        self.write_trace("parent", [
+            self.meta("parent-1"),
+            self.turn("2026-08-11T00:00:01Z"),
+        ], 10)
+        self.write_trace("auto-review", [
+            self.meta("auto-review-1", parent_thread_id="parent-1"),
+            {
+                "timestamp": "2026-08-11T01:00:01.000Z",
+                "type": "turn_context",
+                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
+            },
+            self.tokens(100, 10, 100, 10, "2026-08-11T01:00:02Z"),
+        ], 20)
+
+        sources = {
+            source["physical_trace_id"]: source
+            for source in self.adapter.discover_legacy(self.context)
+        }
+        native = next(
+            source for source in self.adapter.discover(self.context)
+            if source.locator.value.endswith("rollout-auto-review.jsonl")
+        )
+        detail = self.adapter.recompute_legacy(sources["auto-review-1"])
+        summary = self.adapter.summarize_legacy(sources["auto-review-1"])
+
+        self.assertEqual(sources["auto-review-1"]["model"], "gpt-5.6")
+        self.assertEqual(native.model_ref.model_id, "gpt-5.6")
+        self.assertEqual(detail["primary_model"], "gpt-5.6")
+        self.assertTrue(detail["availability"]["cost"])
+        self.assertGreater(detail["total_cost"], 0)
+        self.assertEqual(summary["primary_model"], "gpt-5.6")
+        self.assertTrue(summary["availability"]["cost"])
+        self.assertGreater(summary["cost"], 0)
+
+    def test_auto_review_child_without_a_linked_parent_stays_unknown(self):
+        self.write_trace("orphaned-auto-review", [
+            self.meta("orphaned-auto-review-1", parent_thread_id="missing-parent"),
+            {
+                "timestamp": "2026-08-11T01:00:01.000Z",
+                "type": "turn_context",
+                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
+            },
+        ], 20)
+
+        source = self.adapter.discover_legacy(self.context)[0]
+
+        self.assertEqual(source["model"], "unknown-model")
+
+    def test_auto_review_fork_without_a_desktop_parent_stays_unknown(self):
+        self.write_trace("parent", [
+            self.meta("parent-1"),
+            self.turn("2026-08-11T00:00:01Z"),
+        ], 10)
+        self.write_trace("forked-auto-review", [
+            self.meta("forked-auto-review-1", forked_from_id="parent-1"),
+            {
+                "timestamp": "2026-08-11T01:00:01.000Z",
+                "type": "turn_context",
+                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
+            },
+        ], 20)
+
+        sources = {
+            source["physical_trace_id"]: source
+            for source in self.adapter.discover_legacy(self.context)
+        }
+
+        self.assertEqual(sources["forked-auto-review-1"]["model"], "unknown-model")
+
+    def test_auto_review_child_with_a_cyclic_parent_stays_unknown(self):
+        self.write_trace("auto-review", [
+            self.meta("auto-review-1", parent_thread_id="parent-1"),
+            {
+                "timestamp": "2026-08-11T01:00:01.000Z",
+                "type": "turn_context",
+                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
+            },
+        ], 10)
+        self.write_trace("parent", [
+            self.meta("parent-1", parent_thread_id="auto-review-1"),
+            {
+                "timestamp": "2026-08-11T01:00:02.000Z",
+                "type": "turn_context",
+                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
+            },
+        ], 20)
+
+        sources = {
+            source["physical_trace_id"]: source
+            for source in self.adapter.discover_legacy(self.context)
+        }
+
+        self.assertEqual(sources["auto-review-1"]["model"], "unknown-model")
+
+    def test_auto_review_child_deduplicates_an_inherited_parent_token_row(self):
+        self.write_trace("parent", [
+            self.meta("parent-1"),
+            self.turn("2026-08-11T00:00:01Z"),
+            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:02Z"),
+        ], 10)
+        self.write_trace("auto-review", [
+            self.meta("auto-review-1", parent_thread_id="parent-1"),
+            {
+                "timestamp": "2026-08-11T01:00:01.000Z",
+                "type": "turn_context",
+                "payload": {"model": "codex-auto-review", "cwd": "/work/project"},
+            },
+            self.tokens(100, 10, 100, 10, "2026-08-11T01:00:02Z"),
+        ], 20)
+
+        sources = {
+            source["physical_trace_id"]: source
+            for source in self.adapter.discover_legacy(self.context)
+        }
+        summary = self.adapter.summarize_legacy(sources["auto-review-1"])
+
+        self.assertEqual(summary["tokens"], 0)
+        self.assertEqual(summary["turns"], 0)
+
+    def test_history_scan_rows_match_cross_session_internal_rows(self):
+        self.write_trace("root", [
+            self.meta("root-1"),
+            self.turn("2026-08-11T00:00:01Z"),
+            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:03Z"),
+        ], 10)
+        self.write_trace("root-resumed", [
+            self.meta("root-1"),
+            self.turn("2026-08-11T05:00:01Z"),
+            self.tokens(40, 4, 140, 14, "2026-08-11T05:00:03Z"),
+        ], 30)
+        self.write_trace("spawned", [
+            self.meta("spawned-1", parent_thread_id="root-1"),
+            self.turn("2026-08-11T06:00:01Z"),
+            self.tokens(20, 2, 20, 2, "2026-08-11T06:00:03Z"),
+        ], 40)
+        self.write_trace("empty", [self.meta("empty-1", logical_id="task-2")], 50)
+        sources = list(self.adapter.discover_legacy(self.context))
+        saved_xsess = dict(meter._xsess)
+        saved_summaries = dict(meter._summary_cache)
+
+        def key(row):
+            return (row["session"], row["turns"], row["tokens"], round(row["cost"], 9))
+
+        try:
+            meter._xsess.update({"data": None, "at": 0, "sessions": [], "internal_rows": (),
+                                 "project_model_stats": {}})
+            meter._summary_cache.clear()
+            with mock.patch.object(meter, "_codex_native_adapter", return_value=self.adapter):
+                meter.cross_session(sources=sources)
+                expected = [key(row) for row in meter._xsess["internal_rows"]]
+            meter._xsess.update({"data": None, "at": 0, "internal_rows": ()})
+            meter._summary_cache.clear()
+            with mock.patch.object(meter, "_codex_native_adapter", return_value=self.adapter), \
+                    mock.patch.object(meter, "all_session_sources", return_value=sources), \
+                    mock.patch.dict(meter._history_scan, {"progress": None, "last_complete": None}):
+                rows, coverage = meter.agent_history_rows(time.monotonic() + 10)
+                self.assertTrue(meter._history_scan["progress"]["done"].wait(10))
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_xsess)
+            meter._summary_cache.clear()
+            meter._summary_cache.update(saved_summaries)
+
+        self.assertTrue(coverage["complete"])
+        self.assertEqual(coverage["sessions_total"], coverage["sessions_scanned"])
+        self.assertEqual(len(expected), 3)
+        self.assertEqual([key(row) for row in rows], expected)
+
+    def test_all_session_rows_are_one_per_trace_file_with_exact_keys(self):
+        self.write_trace("root", [
+            self.meta("root-1"),
+            self.turn("2026-08-11T00:00:01Z"),
+            self.tokens(100, 10, 100, 10, "2026-08-11T00:00:03Z"),
+        ], 10)
+        self.write_trace("root-resumed", [
+            self.meta("root-1"),
+            self.turn("2026-08-11T05:00:01Z"),
+            self.tokens(40, 4, 140, 14, "2026-08-11T05:00:03Z"),
+        ], 30)
+        self.write_trace("spawned", [
+            self.meta("spawned-1", parent_thread_id="root-1"),
+            self.turn("2026-08-11T06:00:01Z"),
+            self.tokens(20, 2, 20, 2, "2026-08-11T06:00:03Z"),
+        ], 40)
+        sources = list(self.adapter.discover_legacy(self.context))
+        self.assertEqual({source["id"] for source in sources}, {"task-1"})
+        saved_xsess = dict(meter._xsess)
+        saved_summaries = dict(meter._summary_cache)
+        try:
+            meter._xsess.update({
+                "data": None, "at": 0, "sessions": [], "internal_rows": (),
+                "project_model_stats": {},
+            })
+            meter._summary_cache.clear()
+            with mock.patch.object(meter, "_codex_native_adapter", return_value=self.adapter):
+                result = meter.cross_session(sources=sources)
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_xsess)
+            meter._summary_cache.clear()
+            meter._summary_cache.update(saved_summaries)
+
+        rows = result["sessions"]
+        self.assertEqual(len(rows), 3)
+        self.assertEqual({row["id"] for row in rows}, {"task-1"})
+        keys = {row["session"] for row in rows}
+        self.assertEqual(keys, {
+            "rollout-root.jsonl", "rollout-root-resumed.jsonl", "rollout-spawned.jsonl",
+        })
+        self.assertEqual(sum(row["tokens"] for row in rows), result["total_tokens"])
+        self.assertEqual(result["total_tokens"], 176)
+        self.assertAlmostEqual(sum(row["cost"] for row in rows), result["total_cost"])
+        by_key = {row["session"]: row for row in rows}
+        self.assertTrue(by_key["rollout-spawned.jsonl"].get("subagent"))
+        self.assertNotIn("subagent", by_key["rollout-root.jsonl"])
+        for row in rows:
+            resolved = meter.find_session(row["session"], sources=sources)
+            self.assertEqual(resolved["path"], row["path"])
+
+    def test_cross_session_daily_models_spend_and_budget_share_corrected_totals(self):
+        sources = self.root_child_and_grandchild_sources()
+        saved_xsess = dict(meter._xsess)
+        saved_summaries = dict(meter._summary_cache)
+        budget_now = datetime.datetime(2026, 8, 11, tzinfo=datetime.timezone.utc)
+        original_budget_status = meter.monthly_budget_status
+        try:
+            meter._xsess.update({
+                "data": None,
+                "at": 0,
+                "sessions": [],
+                "internal_rows": (),
+                "project_model_stats": {},
+            })
+            meter._summary_cache.clear()
+            with mock.patch.object(
+                meter, "_codex_native_adapter", return_value=self.adapter,
+            ), mock.patch.object(
+                meter,
+                "monthly_budget_status",
+                side_effect=lambda months, settings: original_budget_status(
+                    months, settings, now=budget_now,
+                ),
+            ):
+                result = meter.cross_session(sources=list(sources.values()))
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_xsess)
+            meter._summary_cache.clear()
+            meter._summary_cache.update(saved_summaries)
+
+        self.assertEqual(result["total_tokens"], 187)
+        self.assertEqual(result["total_executions"], 3)
+        self.assertAlmostEqual(
+            result["total_cost"],
+            sum(session["cost"] for session in result["sessions"]),
+        )
+        self.assertEqual(sum(
+            row["input_tokens"] + row["output_tokens"]
+            for row in result["model_stats"]["models"]
+        ), 187)
+        self.assertEqual(sum(row["tokens"] for row in result["daily"]), 187)
+        self.assertAlmostEqual(
+            sum(row["cost"] for row in result["daily"]),
+            result["total_cost"],
+        )
+        self.assertAlmostEqual(
+            sum(row["cost"] for row in result["spend"]["days"]),
+            result["total_cost"],
+        )
+        self.assertAlmostEqual(
+            sum(row["cost"] for row in result["monthly"]),
+            result["total_cost"],
+        )
+        self.assertEqual(result["budget"]["month"], "2026-08")
+        self.assertAlmostEqual(result["budget"]["spend"], result["total_cost"])
+        encoded = json.dumps(result)
+        for private_field in (
+            "physical_trace_id",
+            "logical_session_id",
+            "forked_from_id",
+            "parent_thread_id",
+            "lineage_parent_id",
+            "lineage_revision",
+        ):
+            self.assertNotIn(private_field, encoded)
+
+    def test_legacy_cache_signature_changes_with_lineage_revision(self):
+        source = {
+            "path": str(self.trace_root / "rollout-child.jsonl"),
+            "mtime": 10,
+            "title": "Child",
+            "lineage_revision": ("unresolved", "parent-1"),
+        }
+
+        before = meter.source_revision_signature(source)
+        after = meter.source_revision_signature({
+            **source,
+            "lineage_revision": ("resolved", "parent-1", "1", "2"),
+        })
+
+        self.assertNotEqual(before, after)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_review_fixes.py b/tests/test_review_fixes.py
new file mode 100644
index 00000000..8740bb8c
--- /dev/null
+++ b/tests/test_review_fixes.py
@@ -0,0 +1,928 @@
+import unittest
+import datetime
+import json
+import os
+import sqlite3
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+from tests.dashboard_page import DASHBOARD_PAGE
+from token_meter.runtimes import hermes as hermes_runtime
+from tests.meter_support import LocalApiHttpBase, DiscountPricingFixture
+from tests.opencode_test_support import OpenCodeCase
+
+
+class ReviewFixHttpTests(LocalApiHttpBase):
+    """Fixes from the independent security and pricing review (HTTP surface)."""
+
+    RULE = {"op": "upsert", "rule": {"price_list": "openai", "channel": "any", "percent": 10}}
+
+    def test_s1_out_of_range_dates_are_rejected_by_the_api_and_resolve(self):
+        for start in (1e20, "9999-12-31T23:59:59-23:59"):
+            status, payload, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [
+                {"op": "upsert", "rule": {"price_list": "openai", "percent": 5, "start": start}}]})
+            self.assertEqual((status, payload["error"]), (400, "Start date must be between 1970 and 2100."))
+        self.assertEqual(self.request(
+            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=any&at=100000000000000000000")[0], 400)
+        self.assertEqual(self.request(
+            "GET", "/api/v1/cost-discounts/resolve?price_list=openai&channel=any&at=9999-12-31T23:59:59-23:59")[0], 400)
+
+    def test_s1_hand_edited_huge_date_is_ignored_not_fatal(self):
+        self.settings.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [
+            {"id": "d_huge0001", "price_list": "openai", "channel": "any", "percent": 5, "start": 1e20},
+            {"id": "d_fine0001", "price_list": "anthropic", "channel": "any", "percent": 5,
+             "start": "9999-12-31T23:59:59-23:59"},
+        ]}}))
+        meter._reset_cost_discount_cache()
+        view = meter.cost_discount_settings()
+        self.assertEqual((view["rules"], view["invalid_rules"]), ([], 2))
+        with mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
+            self.assertEqual(meter.cross_session(sources=[])["cost_discounts"]["invalid_rules"], 2)
+        self.assertEqual(self.request("GET", "/api/v1/cost-discounts")[0], 200)
+
+    def test_s2_invalid_stored_budgets_are_refused_not_reset(self):
+        stored = {"budgets": {"allocations": {"claude": -5}, "session_budgets": {"sid": 3}}}
+        self.settings.write_text(json.dumps(stored))
+        status, payload, _ = self.request("POST", "/api/v1/budgets", {"allocations": {"codex": 5}})
+        self.assertEqual((status, payload), (409, {"ok": False,
+                         "error": "Stored budgets are invalid; fix them in Token Meter first."}))
+        self.assertEqual(json.loads(self.settings.read_text()), stored)
+
+    def test_s3_deeply_nested_json_is_invalid_json(self):
+        # Whether the parser recurses out depends on the Python version, so force that path.
+        routes = (("/api/v1/cost-discounts", {}), ("/api/v1/budgets", {}),
+                  ("/settings/budgets", {"bearer": False, "action": True}))
+        real_loads = json.loads
+
+        def loads(text, *args, **kwargs):
+            if text in (b"[[1]]", "[[1]]"):
+                raise RecursionError
+            return real_loads(text, *args, **kwargs)
+
+        with mock.patch.object(meter.json, "loads", side_effect=loads):
+            for path, kwargs in routes:
+                with self.subTest(path=path, parser="recursion"):
+                    status, payload, _ = self.request("POST", path, raw=b"[[1]]", **kwargs)
+                    self.assertEqual((status, payload), (400, {"ok": False, "error": "Invalid JSON."}))
+        body = b"[" * 4000 + b"]" * 4000
+        for path, kwargs in routes:
+            with self.subTest(path=path, parser="real"):
+                status, payload, _ = self.request("POST", path, raw=body, **kwargs)
+                self.assertEqual(status, 400)
+                self.assertIn(payload["error"], ("Invalid JSON.", "Send a JSON object with ops.",
+                                                 "Send a JSON object.", "Budget settings must be an object."))
+
+    def test_s4_every_route_requires_the_loopback_host(self):
+        foreign = "rebind.example:{}".format(self.port)
+        with mock.patch.object(meter, "provider_quota_snapshots", return_value={}):
+            for path in ("/state", "/health", "/menubar", "/session?id=x", "/"):
+                with self.subTest(path=path):
+                    status, payload, _ = self.request("GET", path, host=foreign, bearer=False)
+                    self.assertEqual((status, payload), (403, {"ok": False, "error": "Forbidden."}))
+            self.assertEqual(self.request("GET", "/state", bearer=False)[0], 200)
+            self.assertEqual(self.request("GET", "/health", bearer=False,
+                                          host="localhost:{}".format(self.port))[0] in (200, 503), True)
+        status, _, _ = self.request("POST", "/settings/budgets", {"allocations": {}}, host=foreign,
+                                    bearer=False, action=True)
+        self.assertEqual(status, 403)
+        status, _, _ = self.request("HEAD", "/", host=foreign, bearer=False)
+        self.assertEqual(status, 403)
+
+    def test_s5_unknown_top_level_and_op_fields_are_rejected(self):
+        cases = (
+            ({"expected_revison": "r_x", "ops": [self.RULE]}, "Unknown field: expected_revison"),
+            ({"ops": [{**self.RULE, "extra": 1}]}, "Unknown field: extra"),
+            ({"ops": [{"op": "upsert", "rule": {"price_list": "openai", "pct": 5}}]}, "Unknown field: pct"),
+            ({"ops": [{"op": "delete", "id": "d_aaaaaaaa", "price_list": "openai"}]}, "Unknown field: price_list"),
+            ({"ops": [{"op": "replace_scope", "price_list": "openai", "channel": "any", "rules": [],
+                       "force": True}]}, "Unknown field: force"),
+            ({"ops": [{"op": "set_runtime_channels", "claude_cli": "bedrock"}]}, "Unknown field: claude_cli"),
+        )
+        for body, message in cases:
+            with self.subTest(body=body):
+                status, payload, _ = self.request("POST", "/api/v1/cost-discounts", body)
+                self.assertEqual((status, payload["error"]), (400, message))
+        self.assertFalse(self.settings.exists())
+
+    def test_s7_newer_file_version_is_read_only(self):
+        stored = {"cost_discounts": {"version": 2, "rules": [
+            {"id": "d_newer001", "price_list": "openai", "channel": "any", "percent": 20}]}}
+        self.settings.write_text(json.dumps(stored))
+        meter._reset_cost_discount_cache()
+        view = meter.cost_discount_settings()
+        self.assertTrue(view["read_only"])
+        self.assertEqual(len(view["rules"]), 1)
+        status, payload, _ = self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})
+        self.assertEqual((status, payload), (409, {"ok": False, "error": "Discounts were saved by a newer Token Meter."}))
+        self.assertEqual(json.loads(self.settings.read_text()), stored)
+
+
+class ReviewFixPricingTests(DiscountPricingFixture):
+    """Fixes from the independent pricing review."""
+
+    def test_p1_hermes_mixed_vendor_rows_are_kept_and_discounted_by_their_own_vendor(self):
+        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
+        db_path = HermesRuntimeAdapterTests._create_store(None, self.tmp, estimated_cost=3.0)
+        con = sqlite3.connect(db_path)
+        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
+        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", [
+            ("hermes-session", "claude-test", "anthropic", 50, 10, 5, 2, 1, 2.0, None, "estimated", "recorded", 1),
+            ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, 1.0, None, "estimated", "recorded", 1),
+        ])
+        con.commit()
+        con.close()
+        self.rules(("anthropic", "any", 25, None))
+        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
+                mock.patch.object(meter, "_hermes_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            summary = meter.hermes_summary(meter.hermes_session_sources()[0])
+        self.assertAlmostEqual(summary["cost"], 2.5)
+        self.assertAlmostEqual(summary["discount_usd"], 0.5)
+        self.assertEqual(len(summary["model_stats"]), 2)
+
+    def test_p2_summary_cache_reprices_when_rules_change_on_disk(self):
+        trace = self.tmp / "s.jsonl"
+        trace.write_text("\n".join(json.dumps(row) for row in (
+            {"type": "turn_context", "timestamp": "2026-09-02T10:00:00.000Z", "payload": {"model": "gpt-5.4"}},
+            {"timestamp": "2026-09-02T10:00:04.000Z", "payload": {"type": "token_count", "info": {
+                "last_token_usage": {"input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}},
+        )) + "\n")
+        source = {"id": "s", "path": str(trace), "provider": "codex", "client": "codex", "label": "Codex",
+                  "project": "/repo", "mtime": 1.0, "title": "t", "model": "gpt-5.4"}
+        with mock.patch.dict(meter._summary_cache, {}, clear=True):
+            listed = meter.session_summary(source)["cost"]
+            time.sleep(0.3)
+            self.rules(("openai", "any", 50, None))
+            meter._cost_discount_cache["checked_at"] = 0.0
+            repriced = meter.session_summary(source)["cost"]
+            state_key = meter.session_state_signature(source)
+        self.assertGreater(listed, 0)
+        self.assertAlmostEqual(repriced, listed * 0.5)
+        self.assertEqual(state_key[-1], meter.pricing_fingerprint())
+
+    def test_p4_cache_savings_without_executions_use_the_session_channel_and_time(self):
+        tot = {"cache_read": 1_000_000}
+        listed = meter.cache_savings(tot, "codex", "gpt-5.4", at=self.T0)
+        self.rules(("openai", "azure", 50, self.T0 - 10))
+        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", channel="azure", at=self.T0), listed * 0.5)
+        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", model_provider="azure", at=self.T0),
+                               listed * 0.5)
+        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", channel="azure", at=self.T0 - 20), listed)
+        self.assertAlmostEqual(meter.cache_savings(tot, "codex", "gpt-5.4", channel="direct", at=self.T0), listed)
+
+    def test_p6_kiro_session_cost_is_priced_per_turn_across_a_rule_boundary(self):
+        from token_meter.runtimes.kiro import KiroRuntimeAdapter, model_ref_for
+        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
+                                     compatibility=meter._kiro_compatibility())
+        model = model_ref_for("claude-sonnet-4-6")
+        turns = [{"input_tokens": 100_000, "output_tokens": 10_000, "end": self.T0 - 100},
+                 {"input_tokens": 100_000, "output_tokens": 10_000, "end": self.T0 + 100}]
+        listed = adapter._session_cost(model, turns)
+        self.rules(("kiro", "any", 50, self.T0))
+        self.assertAlmostEqual(adapter._session_cost(model, turns), listed * 0.75)
+        source = (Path(meter.__file__).resolve().parent / "token_meter" / "runtimes" / "kiro.py").read_text()
+        self.assertIn("cost = self._session_cost(source.model_ref, turns)", source)
+
+    def test_p7_missing_timestamps_never_take_todays_rate(self):
+        usage = {"input_tokens": 1_000_000, "output_tokens": 0}
+        self.rules(("openai", "any", 50, 100))
+        self.assertEqual(meter.cost_of(usage, "gpt-5.4", "codex", at=None).discount_usd, 0.0)
+        self.assertEqual(meter.discount_amount(1.0, "openai", "direct", None), (1.0, 0.0))
+        self.assertGreater(meter.cost_of(usage, "gpt-5.4", "codex", at=self.T0).discount_usd, 0)
+        self.rules(("openai", "any", 50, None))
+        self.assertAlmostEqual(meter.discount_amount(1.0, "openai", "direct", None)[0], 0.5)
+
+    def test_p3_vertex_claude_sessions_take_the_vertex_rule(self):
+        self.rules(("anthropic", "direct", 30, None), ("anthropic", "vertex", 10, None))
+        row = {"type": "assistant", "timestamp": "2026-09-02T10:00:00.000Z", "requestId": "req_vrtx_011abc",
+               "message": {"id": "m", "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
+                           "usage": {"input_tokens": 100_000, "output_tokens": 10_000,
+                                     "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0}}}
+        source = {"id": "c", "path": "/tmp/c.jsonl", "provider": "claude", "client": "claude_code",
+                  "label": "Claude", "project": "/repo", "mtime": 1, "title": "t", "model": None}
+        summary = meter.claude_summary(source, [row])
+        self.assertAlmostEqual(summary["discount_usd"] / (summary["cost"] + summary["discount_usd"]), 0.10)
+
+
+class ReviewRound2HttpTests(LocalApiHttpBase):
+    """Round-two review fixes on the HTTP surface."""
+
+    RULE = {"op": "upsert", "rule": {"price_list": "openai", "channel": "any", "percent": 10}}
+
+    def test_r1_state_carries_fresh_discounts_while_repricing_serves_the_old_snapshot(self):
+        stale = {"pricing_revision": "p_old", "cost_discounts": {"revision": "r_old", "rules": []}}
+        with mock.patch.object(meter, "STATE", {"ok": True, "xsession": stale}), \
+                mock.patch.dict(meter._pricing_recalc, {"running": True, "pending": False}):
+            written = self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})[1]
+            state = self.request("GET", "/state", bearer=False)[1]
+        self.assertEqual(state["xsession"]["cost_discounts"]["revision"], "r_old")
+        self.assertEqual(state["cost_discounts"]["revision"], written["revision"])
+        self.assertEqual([rule["percent"] for rule in state["cost_discounts"]["rules"]], [10])
+
+    def test_r3_any_version_but_integer_one_is_read_only(self):
+        for version in ("2", 2.0, "1", True, None):
+            with self.subTest(version=version):
+                stored = {"cost_discounts": {"version": version, "rules": []}}
+                self.settings.write_text(json.dumps(stored))
+                meter._reset_cost_discount_cache()
+                self.assertTrue(meter.cost_discount_settings()["read_only"])
+                self.assertEqual(self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})[0], 409)
+                self.assertEqual(json.loads(self.settings.read_text()), stored)
+        self.settings.write_text(json.dumps({"cost_discounts": {"rules": []}}))
+        meter._reset_cost_discount_cache()
+        self.assertFalse(meter.cost_discount_settings()["read_only"])
+
+    def test_r3_invalid_stored_rules_survive_a_write_verbatim(self):
+        broken = {"id": "broken", "percent": 500, "note": "hand edit"}
+        self.settings.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": [
+            {"id": "d_keep0001", "price_list": "anthropic", "channel": "any", "percent": 5}, broken]}}))
+        meter._reset_cost_discount_cache()
+        self.assertEqual(self.request("POST", "/api/v1/cost-discounts", {"ops": [self.RULE]})[0], 200)
+        rules = json.loads(self.settings.read_text())["cost_discounts"]["rules"]
+        self.assertIn(broken, rules)
+        self.assertEqual(len(rules), 3)
+        meter._reset_cost_discount_cache()
+        view = meter.cost_discount_settings()
+        self.assertEqual((len(view["rules"]), view["invalid_rules"]), (2, 1))
+
+    def test_r4_budgets_get_refuses_invalid_stored_budgets(self):
+        self.settings.write_text(json.dumps({"budgets": {"allocations": {"claude": -5}}}))
+        status, payload, _ = self.request("GET", "/api/v1/budgets")
+        self.assertEqual((status, payload), (409, {"ok": False,
+                         "error": "Stored budgets are invalid; fix them in Token Meter first."}))
+
+
+class ReviewRound2PricingTests(DiscountPricingFixture):
+    """Round-two review fixes on pricing."""
+
+    def codex_source(self, stamps):
+        trace = self.tmp / "codex-{}.jsonl".format(len(list(self.tmp.iterdir())))
+        rows = [{"type": "turn_context", "timestamp": stamps[0], "payload": {"model": "gpt-5.4"}}]
+        rows += [{"timestamp": stamp, "payload": {"type": "token_count", "info": {"last_token_usage": {
+            "input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}} for stamp in stamps]
+        trace.write_text("\n".join(json.dumps(row) for row in rows) + "\n")
+        return {"id": trace.stem, "session": trace.stem, "path": str(trace), "provider": "codex",
+                "client": "codex", "label": "Codex", "project": "/repo", "mtime": 1.0, "title": "t",
+                "model": "gpt-5.4"}
+
+    def test_r2_hermes_partial_model_costs_keep_list_equal_cost_plus_discount(self):
+        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
+        db_path = HermesRuntimeAdapterTests._create_store(None, self.tmp, estimated_cost=3.0)
+        con = sqlite3.connect(db_path)
+        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
+        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", [
+            ("hermes-session", "claude-test", "anthropic", 50, 10, 5, 2, 1, 2.0, None, "estimated", "recorded", 1),
+            ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, None, None, "unknown", "none", 1),
+        ])
+        con.commit()
+        con.close()
+        self.rules(("anthropic", "any", 25, None))
+        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
+                mock.patch.object(meter, "_hermes_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            summary = meter.hermes_summary(meter.hermes_session_sources()[0])
+        self.assertAlmostEqual(summary["cost"] + summary["discount_usd"], 3.0)
+        self.assertAlmostEqual(summary["discount_usd"], 0.5)
+        self.assertAlmostEqual(summary["cost"], 2.5)
+        # Two model rows plus the unattributed list-price share (round three, Q4).
+        self.assertEqual(len(summary["model_stats"]), 3)
+
+    def test_r7_opencode_prices_discounts_and_dates_a_message_with_one_time(self):
+        helper = OpenCodeCase()
+        conn = helper._build_db(self.tmp)
+        row_created = 1_788_000_000_000
+        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
+            helper._session_row("ses_t", "/repo", "Timed", "gpt-5.4", 1.0, 100, 10, 0, 0, 0,
+                                row_created + 86_400_000 * 3, provider_id="openai").values()))
+        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", helper._message("m0", "ses_t", {
+            "role": "assistant", "modelID": "gpt-5.4", "providerID": "openai", "cost": 1.0,
+            "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}}},
+            row_created))
+        conn.commit()
+        conn.close()
+        # Only the row's own creation time dates this message; the rule starts just before it.
+        self.rules(("openai", "any", 50, row_created / 1000 - 10))
+        source = {"provider": "opencode", "id": "ses_t", "model": "gpt-5.4", "label": "OpenCode",
+                  "runtime": "OpenCode", "session": "ses_t", "path": "opencode:ses_t",
+                  "project": "/repo", "title": "Timed", "mtime": 1.0}
+        with mock.patch.object(meter, "OPENCODE_DB", str(self.tmp / "opencode.db")), \
+                mock.patch.object(meter, "_opencode_native_adapters", {}):
+            row = meter.opencode_summary(source)
+            state = meter.recompute_opencode(source)
+        day = time.strftime("%Y-%m-%d", time.localtime(row_created / 1000))
+        self.assertAlmostEqual(row["discount_usd"], 0.5)
+        self.assertAlmostEqual(row["model_stats"][0]["discount_usd"], 0.5)
+        self.assertAlmostEqual(row["_day_cost"][day], 0.5)
+        self.assertAlmostEqual(state["total_cost"], 0.5)
+        self.assertAlmostEqual(state["executions"][0]["discount_usd"], 0.5)
+
+    def test_r7_kiro_prices_discounts_and_dates_a_start_only_turn_alike(self):
+        from token_meter.runtimes.kiro import KiroRuntimeAdapter
+        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
+                                     compatibility=meter._kiro_compatibility())
+        turn = {"index": 1, "input_tokens": 100_000, "output_tokens": 10_000, "start": self.T0 + 100,
+                "end": 0, "tools": (), "model": "claude-sonnet-4-6"}
+        self.rules(("kiro", "any", 50, self.T0))
+        source = {"id": "k", "path": str(self.tmp / "k.jsonl"), "provider": "kiro", "label": "Kiro",
+                  "project": "/repo", "mtime": 1.0, "title": "t", "model": "claude-sonnet-4-6"}
+        with mock.patch.object(adapter, "_legacy_rows", return_value=(turn,)):
+            row = adapter.summarize_legacy(source)
+        day = time.strftime("%Y-%m-%d", time.localtime(self.T0 + 100))
+        self.assertGreater(row["discount_usd"], 0)
+        self.assertAlmostEqual(row["discount_usd"], row["cost"])
+        self.assertAlmostEqual(row["_day_cost"][day], row["cost"])
+
+    def test_r8_whole_second_utc_stamps_parse_and_take_dated_rules(self):
+        self.assertEqual(meter.parse_iso("2026-10-29T12:00:00Z"), meter.parse_iso("2026-10-29T12:00:00.000Z"))
+        self.assertEqual(meter.parse_iso("2026-10-29T12:00:00+00:00"), 1793275200)
+        self.assertIsNone(meter.parse_iso("not a time"))
+        for value in (None, 1790000000, 1790000000.5, True, ""):
+            with self.subTest(value=value):
+                self.assertIsNone(meter.parse_iso(value))
+        numeric = self.codex_rows_for("2026-10-29T12:00:00Z")
+        numeric[0]["timestamp"] = 1790000000
+        meter.codex_summary(self.codex_source(["2026-10-29T12:00:00Z"]), numeric)
+        self.rules(("openai", "any", 50, meter.parse_iso("2026-10-01T00:00:00")))
+        for stamp in ("2026-10-29T12:00:00Z", "2026-10-29T12:00:00.250Z"):
+            with self.subTest(stamp=stamp):
+                row = meter.codex_summary(self.codex_source([stamp]), self.codex_rows_for(stamp))
+                self.assertAlmostEqual(row["discount_usd"], row["cost"])
+
+    def codex_rows_for(self, stamp):
+        return [{"type": "turn_context", "timestamp": stamp, "payload": {"model": "gpt-5.4"}},
+                {"timestamp": stamp, "payload": {"type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100_000, "output_tokens": 10_000, "total_tokens": 110_000}}}}]
+
+    def test_r9_build_state_cache_fallback_uses_the_claude_session_channel(self):
+        tot = {"input": 0, "cache_write": 0, "cache_read": 1_000_000, "output": 0}
+        cost = {"input": 0.0, "cache_write": 0.0, "cache_read": 0.0, "output": 0.0}
+        listed = meter.cache_block(tot, cost, [], "claude", "claude-sonnet-4-6", at=self.T0)["saved"]
+        self.rules(("anthropic", "bedrock", 40, None))
+        saved = meter.cache_block(tot, cost, [], "claude", "claude-sonnet-4-6",
+                                  channel="bedrock", at=self.T0)["saved"]
+        self.assertAlmostEqual(saved, listed * 0.6)
+        captured = []
+        real_build_state = meter.build_state
+
+        def capture(source, *args, **kwargs):
+            captured.append(dict(source))
+            return real_build_state(source, *args, **kwargs)
+        trace = self.tmp / "claude.jsonl"
+        trace.write_text(json.dumps({
+            "type": "assistant", "timestamp": "2026-09-02T10:00:00.000Z",
+            "requestId": "0b7c0a8e-3f7d-4c55-9b1e-6c2f6d1c9a10",
+            "message": {"id": "m", "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
+                        "usage": {"input_tokens": 10, "output_tokens": 5, "cache_creation_input_tokens": 0,
+                                  "cache_read_input_tokens": 1000}}}) + "\n")
+        with mock.patch.object(meter, "build_state", side_effect=capture):
+            adapter = meter.ClaudeRuntimeAdapter(str(self.tmp), (), compatibility=meter._claude_compatibility())
+            adapter.recompute_legacy({"id": "c", "session": "c", "path": str(trace), "provider": "claude",
+                                      "client": "claude_code",
+                                      "label": "Claude", "project": "/repo", "mtime": 1.0, "title": "t"})
+        self.assertEqual(captured[0]["discount_channel"], "bedrock")
+
+    def test_r9_kiro_load_prices_each_turn_at_its_own_time(self):
+        from token_meter.contracts import DetailLevel
+        from token_meter.runtimes.kiro import KiroRuntimeAdapter
+        adapter = KiroRuntimeAdapter(self.tmp, quote_resolver=meter.price_quote,
+                                     compatibility=meter._kiro_compatibility())
+        path = self.tmp / "messages.jsonl"
+        path.write_text("")
+        source = adapter._source_from_legacy({"id": "k", "path": str(path), "model": "claude-sonnet-4-6",
+                                              "mtime": 1.0, "label": "Kiro", "project": "/repo"})
+        turns = tuple({"index": index + 1, "input_tokens": 100_000, "output_tokens": 10_000,
+                       "start": stamp - 5, "end": stamp, "tools": ()}
+                      for index, stamp in enumerate((self.T0 - 100, self.T0 + 100)))
+        parsed = {"turns": turns, "corrupt": 0, "available": True, "truncated": False, "recognized": True}
+        with mock.patch.object(adapter, "_parsed", return_value=parsed):
+            listed = adapter.load(source, DetailLevel.SUMMARY).usage.cost_usd.value
+            self.rules(("kiro", "any", 50, self.T0))
+            discounted = adapter.load(source, DetailLevel.SUMMARY).usage.cost_usd.value
+        self.assertGreater(listed, 0)
+        self.assertAlmostEqual(discounted, listed * 0.75)
+
+    def test_r9_detail_state_is_repriced_when_rules_change(self):
+        source = self.codex_source(["2026-09-02T10:00:00.000Z"])
+        with mock.patch.dict(meter._session_state_cache, {}, clear=True):
+            listed = meter.cached_session_state(source)["total_cost"]
+            time.sleep(0.3)
+            self.rules(("openai", "any", 50, None))
+            meter._cost_discount_cache["checked_at"] = 0.0
+            repriced = meter.cached_session_state(source)["total_cost"]
+        self.assertGreater(listed, 0)
+        self.assertAlmostEqual(repriced, listed * 0.5)
+
+    def test_r9_budget_status_session_cap_and_spend_goal_use_the_discounted_cost(self):
+        from token_meter.services import goals as goal_service
+        source = self.codex_source(["2026-09-02T10:00:00.000Z"])
+        self.rules(("openai", "any", 50, None))
+        row = meter.codex_summary(source, self.codex_rows_for("2026-09-02T10:00:00.000Z"))
+        self.assertGreater(row["discount_usd"], 0)
+        when = datetime.datetime(2026, 9, 15, 12).astimezone()
+        status = meter.monthly_budget_status(meter.monthly_summaries([row]),
+                                             {"allocations": {"codex": 100}}, now=when)
+        self.assertAlmostEqual(status["spend"], row["cost"])
+        state = meter.recompute(source)
+        with mock.patch.dict(meter._xsess, {"sessions": []}):
+            cap = meter.session_budget_snapshot(source, state, {"default_session_budget": 10})
+        self.assertAlmostEqual(cap["spend_usd"], round(row["cost"], 4))
+        goal = goal_service.measure("spend", {"kind": "all", "key": ""}, "2026-09-01", "2026-09-30",
+                                    [row], meter.metric_available)
+        self.assertAlmostEqual(goal["value"], row["cost"])
+
+
+class ReviewRound3Tests(DiscountPricingFixture):
+    """Round-three review fixes."""
+
+    def store(self, rules, **extra):
+        self.path.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": rules}, **extra}))
+        meter._reset_cost_discount_cache()
+
+    CLASH = [
+        {"id": "d_keep0001", "price_list": "anthropic", "channel": "direct", "percent": 30},
+        {"id": "d_clash001", "price_list": "anthropic", "channel": "direct", "percent": 20, "start": 100},
+    ]
+
+    def saved_rules(self):
+        return json.loads(self.path.read_text())["cost_discounts"]["rules"]
+
+    def test_q1_clashing_entry_never_resurrects_after_delete(self):
+        self.store(self.CLASH)
+        self.assertEqual(meter.cost_discount_settings()["invalid_rules"], 1)
+        result = meter.apply_cost_discount_ops([{"op": "delete", "id": "d_keep0001"}])
+        self.assertTrue(result["ok"], result)
+        self.assertEqual(self.saved_rules(), [])
+        meter._reset_cost_discount_cache()
+        view = meter.cost_discount_settings()
+        self.assertEqual((view["rules"], view["invalid_rules"]), ([], 0))
+        self.assertEqual(view["revision"], result["revision"])
+
+    def test_q1_replace_scope_clears_the_scope_without_resurrecting(self):
+        self.store(self.CLASH)
+        result = meter.apply_cost_discount_ops(
+            [{"op": "replace_scope", "price_list": "anthropic", "channel": "direct", "rules": []}])
+        self.assertEqual(self.saved_rules(), [])
+        meter._reset_cost_discount_cache()
+        self.assertEqual(meter.cost_discount_settings()["rules"], [])
+        self.assertEqual(meter.cost_discount_settings()["revision"], result["revision"])
+
+    def test_q1_write_revision_equals_the_next_read_with_preserved_invalid_entries(self):
+        malformed = {"id": "d_bad00001", "price_list": "anthropic", "channel": "any", "percent": 500}
+        self.store([self.CLASH[0], malformed, self.CLASH[1]])
+        result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}])
+        self.assertIn(malformed, self.saved_rules())
+        self.assertNotIn(self.CLASH[1], self.saved_rules())
+        meter._reset_cost_discount_cache()
+        view = meter.cost_discount_settings()
+        self.assertEqual(view["revision"], result["revision"])
+        self.assertEqual(view["invalid_rules"], 1)
+
+    def test_q1_deleting_or_replacing_an_invalid_entry_clears_the_count(self):
+        malformed = {"id": "d_bad00001", "price_list": "anthropic", "channel": "any", "percent": 500}
+        self.store([malformed])
+        result = meter.apply_cost_discount_ops([{"op": "delete", "id": "d_bad00001"}])
+        self.assertTrue(result["changed"])
+        self.assertEqual(self.saved_rules(), [])
+        meter._reset_cost_discount_cache()
+        self.assertEqual(meter.cost_discount_settings()["invalid_rules"], 0)
+        self.store([malformed])
+        meter.apply_cost_discount_ops([{"op": "replace_scope", "price_list": "anthropic", "channel": "any", "rules": []}])
+        self.assertEqual(self.saved_rules(), [])
+
+    def test_q5_non_object_or_non_list_shapes_are_read_only(self):
+        for stored in ({"cost_discounts": "30% off"}, {"cost_discounts": {"version": 1, "rules": "x"}},
+                       {"cost_discounts": ["rule"]}):
+            with self.subTest(stored=stored):
+                self.path.write_text(json.dumps(stored))
+                meter._reset_cost_discount_cache()
+                self.assertTrue(meter.cost_discount_settings()["read_only"])
+                result = meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}])
+                self.assertTrue(result.get("newer_version"), result)
+                self.assertEqual(json.loads(self.path.read_text()), stored)
+                body, status = meter.cost_discount_write({"ops": [{"op": "delete", "id": "d_x0000000"}]}, "api", "x")
+                self.assertEqual(status, 409)
+
+    def hermes(self, session_status, rows):
+        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
+        root = self.tmp / "hermes-{}".format(len(list(self.tmp.iterdir())))
+        root.mkdir()
+        db_path = HermesRuntimeAdapterTests._create_store(None, root, estimated_cost=3.0)
+        con = sqlite3.connect(db_path)
+        if session_status == "actual":
+            con.execute("UPDATE sessions SET actual_cost_usd=3.0, estimated_cost_usd=NULL, cost_status='actual'")
+        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
+        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", rows)
+        con.commit()
+        con.close()
+        self.rules(("anthropic", "any", 25, None))
+        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
+                mock.patch.object(meter, "_hermes_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            return meter.hermes_summary(meter.hermes_session_sources()[0])
+
+    ROWS = [
+        ("hermes-session", "claude-test", "anthropic", 50, 10, 5, 2, 1, 2.0, None, "estimated", "recorded", 1),
+        ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, 1.0, None, "estimated", "recorded", 1),
+    ]
+
+    def test_q2_billed_hermes_session_is_never_discounted(self):
+        for rows in (self.ROWS, [self.ROWS[0], (*self.ROWS[1][:8], None, None, "unknown", "none", 1)]):
+            with self.subTest(rows=len([row for row in rows if row[8] is not None])):
+                summary = self.hermes("actual", rows)
+                self.assertAlmostEqual(summary["cost"], 3.0)
+                self.assertEqual(summary["discount_usd"], 0.0)
+                self.assertEqual(sum(row["discount_usd"] for row in summary["model_stats"]), 0.0)
+                self.assertAlmostEqual(sum(summary["_model_cost"].values()), 3.0)
+
+    def test_q4_unpriced_share_is_a_model_row_and_inconsistent_rows_fall_back(self):
+        partial = self.hermes("estimated", [self.ROWS[0], (*self.ROWS[1][:8], None, None, "unknown", "none", 1)])
+        self.assertAlmostEqual(partial["cost"], 2.5)
+        self.assertAlmostEqual(sum(partial["_model_cost"].values()), partial["cost"])
+        self.assertAlmostEqual(sum(row["cost"] for row in partial["model_stats"]), partial["cost"])
+        self.assertIn(hermes_runtime.UNATTRIBUTED_MODEL_KEY, partial["_model_cost"])
+        over = self.hermes("estimated", [(*self.ROWS[0][:8], 4.0, None, "estimated", "recorded", 1),
+                                         (*self.ROWS[1][:8], None, None, "unknown", "none", 1)])
+        self.assertAlmostEqual(over["cost"] + over["discount_usd"], 3.0)
+        self.assertAlmostEqual(over["cost"], 2.25)
+        self.assertAlmostEqual(sum(over["_model_cost"].values()), over["cost"])
+
+    def test_q6_opencode_summary_leaves_a_timeless_message_undated(self):
+        helper = OpenCodeCase()
+        conn = helper._build_db(self.tmp)
+        timed = 1_788_000_000_000
+        conn.execute("INSERT INTO session VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tuple(
+            helper._session_row("ses_u", "/repo", "Undated", "gpt-5.4", 2.0, 200, 20, 0, 0, 0,
+                                timed + 86_400_000 * 5, provider_id="openai").values()))
+        message = {"role": "assistant", "modelID": "gpt-5.4", "providerID": "openai", "cost": 1.0,
+                   "tokens": {"input": 100, "output": 10, "reasoning": 0, "cache": {"read": 0, "write": 0}}}
+        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)",
+                     ("m0", "ses_u", timed, timed, json.dumps({**message, "time": {"created": timed}})))
+        conn.execute("INSERT INTO message VALUES (?,?,?,?,?)", ("m1", "ses_u", None, None, json.dumps(message)))
+        conn.commit()
+        conn.close()
+        source = {"provider": "opencode", "id": "ses_u", "model": "gpt-5.4", "label": "OpenCode",
+                  "runtime": "OpenCode", "session": "ses_u", "path": "opencode:ses_u",
+                  "project": "/repo", "title": "Undated", "mtime": 1.0}
+        with mock.patch.object(meter, "OPENCODE_DB", str(self.tmp / "opencode.db")), \
+                mock.patch.object(meter, "_opencode_native_adapters", {}):
+            row = meter.opencode_summary(source)
+        self.assertEqual(set(row["_day_cost"]), {time.strftime("%Y-%m-%d", time.localtime(timed / 1000))})
+
+    def test_q6_build_state_passes_the_session_channel_and_last_time_to_the_cache_block(self):
+        tot = {"input": 0, "cache_write": 0, "cache_read": 1_000_000, "output": 0}
+        cost = {"input": 0.0, "cache_write": 0.0, "cache_read": 0.0, "output": 0.0}
+
+        def saved(channel, last_ts):
+            source = {"id": "c", "session": "c", "path": "/tmp/c.jsonl", "provider": "claude",
+                      "label": "Claude", "project": "/repo", "discount_channel": channel}
+            state = meter.build_state(
+                source, tot, cost, 1_000_000, 0.0, [], [], [],
+                {"reasoning": 0, "output": 0, "retrieval": 0, "coordination": 0}, {}, [],
+                last_ts - 10, last_ts, 0, None, 0, False, "claude-sonnet-4-6", "")
+            return state["cache"]["saved"]
+        listed = saved("bedrock", self.T0 + 10)
+        self.rules(("anthropic", "bedrock", 40, self.T0))
+        self.assertAlmostEqual(saved("bedrock", self.T0 + 10), listed * 0.6)
+        self.assertAlmostEqual(saved("direct", self.T0 + 10), listed)
+        self.assertAlmostEqual(saved("bedrock", self.T0 - 100), listed)
+
+
+class ReviewRound4Tests(DiscountPricingFixture):
+    """Round-four minor fixes."""
+
+    hermes = ReviewRound3Tests.hermes
+    ROWS = ReviewRound3Tests.ROWS
+    UNPRICED = ("hermes-session", "gpt-5.4", "openai", 50, 10, 5, 3, 1, None, None, "unknown", "none", 1)
+
+    def test_1_list_and_dict_timestamps_never_fail_a_build(self):
+        codex = self.tmp / "codex.jsonl"
+        codex.write_text("\n".join(json.dumps(row) for row in (
+            {"type": "turn_context", "timestamp": ["2026"], "payload": {"model": "gpt-5.4"}},
+            {"timestamp": {"at": 1}, "payload": {"type": "token_count", "info": {"last_token_usage": {
+                "input_tokens": 100, "output_tokens": 10, "total_tokens": 110}}}},
+            {"timestamp": "2026-09-02T10:00:00Z", "payload": {"type": "token_count", "info": {"last_token_usage": {
+                "input_tokens": 100, "output_tokens": 10, "total_tokens": 110}}}},
+        )) + "\n")
+        claude = self.tmp / "claude.jsonl"
+        claude.write_text("\n".join(json.dumps({
+            "type": "assistant", "timestamp": stamp, "message": {
+                "id": "m{}".format(index), "model": "claude-sonnet-4-6", "content": [], "stop_reason": "end_turn",
+                "usage": {"input_tokens": 10, "output_tokens": 5, "cache_creation_input_tokens": 0,
+                          "cache_read_input_tokens": 0}}})
+            for index, stamp in enumerate((["x"], {"y": 1}, "2026-09-02T10:00:00Z"))) + "\n")
+        sources = [
+            {"id": "cx", "session": "cx", "path": str(codex), "provider": "codex", "client": "codex",
+             "label": "Codex", "project": "/repo", "mtime": 1.0, "title": "t", "model": "gpt-5.4"},
+            {"id": "cl", "session": "cl", "path": str(claude), "provider": "claude", "client": "claude_code",
+             "label": "Claude", "project": "/repo", "mtime": 1.0, "title": "t"},
+        ]
+        self.assertIsNone(meter.parse_iso(["2026"]))
+        self.assertIsNone(meter.parse_iso({"at": 1}))
+        with mock.patch.dict(meter._summary_cache, {}, clear=True), \
+                mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
+            rows = [meter.session_summary(source) for source in sources]
+            cross = meter.cross_session(sources=sources)
+        self.assertEqual([row["turns"] for row in rows], [2, 3])
+        self.assertEqual(cross["total_sessions"], 2)
+
+    def test_2_billed_session_with_an_oversized_estimate_row_falls_back(self):
+        summary = self.hermes("actual", [(*self.ROWS[0][:8], 4.0, None, "estimated", "recorded", 1), self.UNPRICED])
+        self.assertAlmostEqual(summary["cost"], 3.0)
+        self.assertEqual(summary["discount_usd"], 0.0)
+        self.assertAlmostEqual(sum(row["cost"] for row in summary["model_stats"]), 3.0)
+        aggregate = meter._domain_aggregate_cross_session_rows([summary])
+        self.assertAlmostEqual(aggregate["total_cost"], summary["cost"])
+
+    def test_3_leftover_cost_is_a_keyed_row_that_the_models_page_keeps(self):
+        for rows in ([self.ROWS[0], self.UNPRICED],
+                     [self.ROWS[0], self.UNPRICED,
+                      ("hermes-session", "gpt-5.4-mini", "openai", 0, 0, 0, 0, 0, None, None, "unknown", "none", 1)]):
+            with self.subTest(unpriced=len(rows) - 1):
+                summary = self.hermes("estimated", rows)
+                gpt = [row for row in summary["model_stats"] if row["model"].endswith(":gpt-5.4")]
+                # The unpriced row stays uncovered (see test_mixed_model_cost_keeps_unknown_model_uncovered).
+                self.assertEqual(gpt[0]["cost"], 0.0)
+                self.assertFalse(gpt[0]["availability"]["cost"])
+                self.assertAlmostEqual(summary["_model_cost"][hermes_runtime.UNATTRIBUTED_MODEL_KEY], 1.0)
+                self.assertNotIn("unknown-model", summary["_model_cost"])
+                self.assertAlmostEqual(sum(summary["_model_cost"].values()), summary["cost"])
+                models = meter.aggregate_model_stats([summary])["models"]
+                self.assertAlmostEqual(sum(float(row.get("cost") or 0) for row in models), summary["cost"])
+                self.assertTrue(any(row["model"] == hermes_runtime.UNATTRIBUTED_MODEL_KEY for row in models))
+
+    def test_4_one_tolerance_for_reconciliation_and_leftover(self):
+        self.assertEqual(hermes_runtime.COST_TOLERANCE, 1e-9)
+        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
+        root = self.tmp / "tiny"
+        root.mkdir()
+        db_path = HermesRuntimeAdapterTests._create_store(None, root, estimated_cost=2.0000000005)
+        con = sqlite3.connect(db_path)
+        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
+        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                        [self.ROWS[0], self.UNPRICED])
+        con.commit()
+        con.close()
+        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
+                mock.patch.object(meter, "_hermes_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            summary = meter.hermes_summary(meter.hermes_session_sources()[0])
+        gpt = [row for row in summary["model_stats"] if row["model"].endswith(":gpt-5.4")]
+        self.assertEqual(gpt[0]["cost"], 0.0)
+        self.assertFalse(gpt[0]["availability"]["cost"])
+
+    def hermes_session(self, estimated_cost, rows):
+        from tests.runtimes.test_hermes_adapter import HermesRuntimeAdapterTests
+        root = self.tmp / "hermes-{}".format(len(list(self.tmp.iterdir())))
+        root.mkdir()
+        db_path = HermesRuntimeAdapterTests._create_store(None, root, estimated_cost=estimated_cost)
+        con = sqlite3.connect(db_path)
+        con.execute("CREATE TABLE session_model_usage (session_id TEXT, model TEXT, billing_provider TEXT, input_tokens INTEGER, output_tokens INTEGER, cache_read_tokens INTEGER, cache_write_tokens INTEGER, reasoning_tokens INTEGER, estimated_cost_usd REAL, actual_cost_usd REAL, cost_status TEXT, cost_source TEXT, api_call_count INTEGER)")
+        con.executemany("INSERT INTO session_model_usage VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", rows)
+        con.commit()
+        con.close()
+        with mock.patch.object(meter, "HERMES_STATE_DB", str(db_path)), \
+                mock.patch.object(meter, "_hermes_native_adapters", {}), \
+                mock.patch.object(meter, "_RUNTIME_REGISTRY", None):
+            return meter.hermes_summary(meter.hermes_session_sources()[0])
+
+    def test_leftover_row_never_collides_with_a_fully_unknown_usage_row(self):
+        unknown = ("hermes-session", None, None, 50, 10, 5, 3, 1, None, None, "unknown", "none", 1)
+        summary = self.hermes_session(3.0, [self.ROWS[0], unknown])
+        real_key = "unknown-model-provider:unknown-billing-route:unknown-model"
+        self.assertNotEqual(hermes_runtime.UNATTRIBUTED_MODEL_KEY, real_key)
+        real = [row for row in summary["model_stats"] if row["model"] == real_key]
+        self.assertEqual(len(real), 1)
+        self.assertEqual(real[0]["cost"], 0.0)
+        self.assertFalse(real[0]["availability"]["cost"])
+        self.assertNotIn(real_key, summary["_model_cost"])
+        self.assertAlmostEqual(summary["_model_cost"][hermes_runtime.UNATTRIBUTED_MODEL_KEY], 1.0)
+        models = meter.aggregate_model_stats([summary])["models"]
+        self.assertTrue(any(row["model"] == hermes_runtime.UNATTRIBUTED_MODEL_KEY and row["cost"] > 0
+                            for row in models))
+
+    def test_leftover_row_threshold_is_the_shared_cost_tolerance(self):
+        # A leftover below 1e-9 is rounding, not cost; above it, it is a row. Fails at 1e-12.
+        below = self.hermes_session(2.0 + 5e-10, [self.ROWS[0], self.UNPRICED])
+        above = self.hermes_session(2.0 + 5e-9, [self.ROWS[0], self.UNPRICED])
+        self.assertNotIn(hermes_runtime.UNATTRIBUTED_MODEL_KEY, below["_model_cost"])
+        self.assertIn(hermes_runtime.UNATTRIBUTED_MODEL_KEY, above["_model_cost"])
+
+    def test_5_non_object_entries_are_dropped_and_messages_name_the_reason(self):
+        malformed = {"id": "d_bad00001", "price_list": "anthropic", "percent": 500}
+        self.path.write_text(json.dumps({"cost_discounts": {"version": 1, "rules": ["junk", 5, None, malformed]}}))
+        meter._reset_cost_discount_cache()
+        self.assertEqual(meter.cost_discount_settings()["invalid_rules"], 4)
+        meter.apply_cost_discount_ops([{"op": "upsert", "rule": {"price_list": "openai", "percent": 5}}])
+        stored = json.loads(self.path.read_text())["cost_discounts"]["rules"]
+        self.assertEqual([entry for entry in stored if entry.get("percent") == 500], [malformed])
+        self.assertEqual(len(stored), 2)
+        for version, message in (("2", "Discounts in settings.json can't be changed by this version."),
+                                 (2, "Discounts were saved by a newer Token Meter.")):
+            with self.subTest(version=version):
+                self.path.write_text(json.dumps({"cost_discounts": {"version": version, "rules": []}}))
+                meter._reset_cost_discount_cache()
+                body, status = meter.cost_discount_write({"ops": [{"op": "delete", "id": "d_x0000000"}]}, "api", "x")
+                self.assertEqual((status, body["error"]), (409, message))
+        self.path.write_text(json.dumps({"cost_discounts": "off"}))
+        meter._reset_cost_discount_cache()
+        self.assertEqual(meter.cost_discount_settings()["read_only_reason"], "unsupported_format")
+
+
+class ReviewRound4PageTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        root = Path(meter.__file__).resolve().parent
+        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
+        cls.design = (root / "specs" / "2026-10-29-cost-discounts-design.md").read_text(encoding="utf-8")
+
+    def test_5_card_names_the_read_only_reason(self):
+        self.assertIn("discountSettings?.read_only_reason==='newer_version'", self.page)
+        self.assertIn("\"Discounts in settings.json can't be changed by this version.\"", self.page)
+
+    def test_6_clearing_the_add_row_resumes_live_renders(self):
+        self.assertIn("$('discount-form').addEventListener('input',()=>{discountFormDirty=discountAddRowHasInput();});",
+                      self.page)
+        start = self.page.index("function discountAddRowHasInput(){")
+        end = self.page.index("$('discount-form').addEventListener", start)
+        script = ("const fields={'d-pct':{value:''},'d-start':{value:''},'d-end':{value:''},'d-note':{value:'  '}};"
+                  "const $=id=>fields[id];" + self.page[start:end].replace("const DISCOUNT_ADD_FIELDS", "var DISCOUNT_ADD_FIELDS") +
+                  "const empty=discountAddRowHasInput();fields['d-pct'].value='30';const typed=discountAddRowHasInput();"
+                  "fields['d-pct'].value='';console.log([empty,typed,discountAddRowHasInput()].join(','))")
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        self.assertEqual(result.stdout.strip(), "false,true,false")
+
+    def test_7_design_doc_states_what_a_save_keeps(self):
+        self.assertIn("a malformed object entry (bad type, enum, date, or percent) is kept verbatim, while "
+                      "non-object, duplicate, clashing, and over-limit entries are discarded", self.design)
+
+
+class ReviewRound3PageTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
+
+    def test_q3_first_render_happens_even_when_the_percent_field_has_focus(self):
+        self.assertIn("if(xs?.cost_discounts&&!discountEditInProgress())renderDiscounts(xs.cost_discounts);", self.page)
+        opener = self.page[self.page.index("function openDiscounts(){"):]
+        self.assertLess(opener.index("renderDiscounts(settings)"), opener.index("$('d-pct').focus("))
+        self.assertIn("else if(!discountEditInProgress())renderDiscounts(state.cost_discounts);", self.page)
+        start = self.page.index("function discountEditInProgress(){")
+        logic = self.page[start:self.page.index("}", start) + 1]
+        script = ("let discountFormDirty=false,discountSettings={rules:[]};const $=()=>({});"
+                  "const viewInteractionActive=()=>true;" + logic +
+                  "const first=discountEditInProgress();discountFormDirty=true;const typed=discountEditInProgress();"
+                  "discountSettings=null;console.log([first,typed,discountEditInProgress()].join(','))")
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        self.assertEqual(result.stdout.strip(), "false,true,false")
+
+
+class ReviewRound2PageAndDocsTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        root = Path(meter.__file__).resolve().parent
+        cls.page = Path(DASHBOARD_PAGE).read_text(encoding="utf-8")
+        cls.docs = {name: (root / "specs" / name).read_text(encoding="utf-8")
+                    for name in ("ARCHITECTURE.md", "LOCAL-API.md", "2026-10-29-cost-discounts-design.md")}
+
+    def test_r1_editor_prefers_fresh_discounts_and_rereads_after_a_conflict(self):
+        self.assertIn(" if(state.xsession)state.xsession.cost_discounts=state.cost_discounts;", self.page)
+        self.assertEqual(self.page.count("adoptFreshDiscounts(state);LATEST=state;"), 2)
+        self.assertIn("if(response.status===409)await reloadDiscounts();", self.page)
+        self.assertIn("fetch('/api/v1/cost-discounts',{headers:{'X-Token-Meter-Action':token},cache:'no-store'})",
+                      self.page)
+
+    def test_r5_status_region_focus_after_remove_and_read_only_selects(self):
+        self.assertIn("<div class=discountCue id=discount-cue role=status hidden></div>", self.page)
+        self.assertNotIn("discountCueText role=status", self.page)
+        self.assertIn("(next||$('discount-title')).focus({preventScroll:true});", self.page)
+        self.assertIn("select.disabled=readOnly;", self.page)
+
+    def test_r6_docs_describe_the_server_wide_host_check_and_vertex_ids(self):
+        self.assertIn("This applies to every Token Meter route", self.docs["LOCAL-API.md"])
+        self.assertIn("custom `TOKEN_METER_URL`", self.docs["LOCAL-API.md"])
+        self.assertIn("Every HTTP route, including the dashboard page", self.docs["ARCHITECTURE.md"])
+        self.assertIn("`req_vrtx_…` means `vertex`", self.docs["ARCHITECTURE.md"])
+        self.assertNotIn("the file is never rewritten on read |", self.docs["2026-10-29-cost-discounts-design.md"])
+
+
+class ReviewFixPageTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
+
+    def test_s6_live_refresh_keeps_the_notice_and_card_stable_and_accessible(self):
+        # Round two moved role=status back to the stable container (see R5).
+        self.assertIn("<div class=discountCue id=discount-cue role=status hidden></div>", self.page)
+        self.assertIn("if(signature===discountCueSignature)return;", self.page)
+        self.assertIn("if(signature!==discountCardSignature){", self.page)
+        self.assertIn("restoreDiscountFocus(focus);", self.page)
+        self.assertIn('aria-label="${esc(`Remove ${discountRuleName(rule)}`)}"', self.page)
+        self.assertIn("return `${(DISCOUNT_LISTS[rule.price_list]||[rule.price_list])[0]} ${rule.percent}% discount`;",
+                      self.page)
+        self.assertIn('id=discount-invalid hidden', self.page)
+        self.assertIn("saved ${invalid===1?'discount is':'discounts are'} invalid and ignored", self.page)
+
+    def test_s6_remove_label_names_the_discount(self):
+        start = self.page.index("function discountRuleName(rule){")
+        script = ("const DISCOUNT_LISTS={openai:['OpenAI','codex']};"
+                  + self.page[start:self.page.index("function renderDiscounts", start)]
+                  + "console.log(`Remove ${discountRuleName({price_list:'openai',percent:62})}`)")
+        result = subprocess.run(["node", "-e", script], capture_output=True, text=True, check=True)
+        self.assertEqual(result.stdout.strip(), "Remove OpenAI 62% discount")
+
+
+class CostDiscountPageTests(unittest.TestCase):
+    """The Spend page carries the approved Discounts notice and card."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
+        if "id=spend-discounts" not in cls.page:
+            cls.page = (Path(DASHBOARD_PAGE)).read_text(encoding="utf-8")
+
+    def section(self, start, end):
+        begin = self.page.index(start)
+        return self.page[begin:self.page.index(end, begin)]
+
+    def test_route_and_palette_entry_keep_existing_budget_routes(self):
+        self.assertIn("h==='spend-budgets'||h==='spend-discounts'||h==='settings-budgets'||h==='budgets'", self.page)
+        self.assertIn("if(h==='spend-discounts')openDiscounts();", self.page)
+        self.assertIn("{id:'spend-discounts',label:'Spend · Discounts',", self.page)
+        self.assertIn("route:'spend-discounts'", self.page)
+        self.assertIn("{id:'spend-budgets',label:'Spend · Monthly budget'", self.page)
+
+    def test_notice_sits_in_the_budget_card_with_the_approved_copy(self):
+        lead = self.section('<section class="card budgetLead">', "<div class=budgetLeadBody>")
+        self.assertIn("id=discount-cue", lead)
+        for copy in ("Spend uses public list prices.",
+                     "Pay a negotiated or company rate? Add a discount so spend and budgets match your bill.",
+                     ">Add a discount</button>", ">Not now</button>", "Spend includes your discounts",
+                     "Costs before discounts are shown beside each total.", ">Manage discounts</button>",
+                     "tm_discount_cue_dismissed"):
+            self.assertIn(copy, self.page)
+        self.assertNotIn("mock", self.section("const DISCOUNT_LISTS=", "$('discount-rotate').onclick").lower())
+
+    def test_card_follows_the_budget_form_without_nesting_a_form(self):
+        editor = self.section("<div class=spendBudgetEditor>", "<div class=spendKpis>")
+        self.assertLess(editor.index("</form>"), editor.index("id=spend-discounts"))
+        card = editor[editor.index("id=spend-discounts"):]
+        self.assertNotIn("<form", card)
+        self.assertIn('id=discount-form role=group aria-label="Add a discount"', card)
+        for element in ("discount-tabs", "discount-rows", "discount-badge", "discount-status", "d-list",
+                        "d-channel", "d-pct", "d-start", "d-end", "d-note", "d-add", "d-claude-code",
+                        "d-claude-desktop", "discount-rotate"):
+            self.assertIn("id={}".format(element), card)
+        for copy in ("How Claude apps are billed", "Let other tools set discounts", "/api/v1/cost-discounts",
+                     "~/.token-meter/api-token", "Issue a new token", "Detect automatically"):
+            self.assertIn(copy, card)
+
+    def test_writes_use_the_dashboard_alias_and_recalculation_polling(self):
+        script = self.section("const DISCOUNT_LISTS=", "$('discount-rotate').onclick")
+        self.assertIn("fetch('/settings/cost-discounts',{method:'POST'", script)
+        self.assertIn("'X-Token-Meter-Action':token", script)
+        self.assertIn("Discount saved. Costs are being recalculated.", script)
+        self.assertIn("All costs were recalculated.", script)
+        self.assertIn("health.pricing_revision===target", script)
+        self.assertIn("op:'set_runtime_channels'", script)
+        self.assertIn("/api/v1/api-token/rotate", self.page)
+        self.assertIn("$('spend-discounts').hidden=!open;", self.page)
+
+    def test_totals_show_list_price_beside_discounted_spend(self):
+        self.assertIn("Estimate after discounts · list ${money(total+periodDiscount)}", self.page)
+        self.assertIn("After discounts · list ${money(Number(today.cost||0)+Number(today.discount_usd||0))}",
+                      self.page)
+
+    def test_card_cannot_widen_the_spend_page_at_laptop_width(self):
+        # The shared pricing table's 1030px minimum widened the whole budget editor at 1024px.
+        self.assertIn(".discountCard,.spendBudgetEditor{min-width:0}", self.page)
+        self.assertIn(".discountCard .modelPriceTable{min-width:760px}", self.page)
+        self.assertIn(".discountAdd{grid-template-columns:repeat(auto-fill,minmax(150px,1fr))}", self.page)
+        # The Add discount button sizes to its label instead of filling a grid column.
+        self.assertIn(".discountAdd .tbtn{justify-self:start;align-self:end;padding:6px 12px}", self.page)
+
+    def test_local_dates_are_sent_with_the_browser_offset(self):
+        script = self.section("function discountLocalMidnightIso", "function discountSay")
+        result = subprocess.run(["node", "-e", script + "console.log(discountLocalMidnightIso('2026-09-01'))"],
+                                capture_output=True, text=True, check=True, env={**os.environ, "TZ": "America/Los_Angeles"})
+        self.assertEqual(result.stdout.strip(), "2026-09-01T00:00:00-07:00")
+
+    def test_xsession_carries_discount_settings_but_never_the_api_token(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            token_path = Path(tmp) / "api-token"
+            with mock.patch.object(meter, "TOKEN_METER_SETTINGS", str(Path(tmp) / "settings.json")), \
+                    mock.patch.object(meter, "TOKEN_METER_API_TOKEN", str(token_path)), \
+                    mock.patch.dict(meter._xsess, {"data": None, "at": 0.0}):
+                meter._reset_cost_discount_cache()
+                token = meter.ensure_api_token()
+                cross = meter.cross_session(sources=[])
+            meter._reset_cost_discount_cache()
+        self.assertEqual(cross["cost_discounts"]["rules"], [])
+        self.assertIn("runtime_channels", cross["cost_discounts"])
+        self.assertNotIn(token, json.dumps(cross))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_session_live.py b/tests/test_session_live.py
new file mode 100644
index 00000000..275d7add
--- /dev/null
+++ b/tests/test_session_live.py
@@ -0,0 +1,781 @@
+import unittest
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class SessionDeleteTests(unittest.TestCase):
+    def test_moves_only_exact_discovered_jsonl_to_trash(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            source_dir = Path(tmp) / "logs"
+            trash_dir = Path(tmp) / "Trash"
+            source_dir.mkdir()
+            path = source_dir / "session-one.jsonl"
+            path.write_text('{"type":"test"}\n')
+            source = {
+                "id": "session-one", "session": path.name, "path": str(path),
+                "provider": "codex", "project": "/repo", "title": "One", "mtime": 1,
+            }
+            result = meter.trash_session_log("session-one", sources=[source], trash_dir=str(trash_dir))
+            trashed = trash_dir / result["trash_name"]
+            self.assertTrue(result["ok"])
+            self.assertFalse(path.exists())
+            self.assertTrue(trashed.exists())
+            self.assertEqual(trashed.read_text(), '{"type":"test"}\n')
+            self.assertNotIn(str(path), json.dumps(result))
+
+    def test_rejects_alias_and_unknown_session_ids(self):
+        source = {
+            "id": "canonical", "session": "alias.jsonl", "path": "/tmp/alias.jsonl",
+            "provider": "codex", "project": "/repo", "mtime": 1,
+        }
+        self.assertEqual(meter.trash_session_log("alias.jsonl", sources=[source])["error_code"], "not_found")
+        self.assertEqual(meter.trash_session_log("missing", sources=[source])["error_code"], "not_found")
+
+    def test_rejects_ambiguous_logical_id_without_deleting_either_trace(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            canonical = root / "canonical.jsonl"
+            duplicate = root / "duplicate.jsonl"
+            canonical.write_text('{}\n')
+            duplicate.write_text('{}\n')
+            source = {
+                "id": "shared", "session": canonical.name,
+                "path": str(canonical), "provider": "claude",
+                "project": "/repo", "mtime": 2,
+                "_aggregation_key": "claude:shared",
+                "_aggregation_canonical": True,
+                "_duplicate_paths": (str(canonical), str(duplicate)),
+            }
+
+            result = meter.trash_session_log(
+                "shared", sources=[source], trash_dir=str(root / "Trash")
+            )
+
+            self.assertFalse(result["ok"])
+            self.assertEqual(result["error_code"], "ambiguous_id")
+            self.assertTrue(canonical.exists())
+            self.assertTrue(duplicate.exists())
+
+    def rollout_pair(self, root):
+        first, second = root / "rollout-a.jsonl", root / "rollout-b.jsonl"
+        first.write_text('{"a":1}\n')
+        second.write_text('{"b":1}\n')
+        sources = [
+            {"id": "shared", "session": first.name, "path": str(first),
+             "provider": "codex", "project": "/repo", "mtime": 5},
+            {"id": "shared", "session": second.name, "path": str(second),
+             "provider": "codex", "project": "/repo", "mtime": 1},
+        ]
+        return first, second, sources
+
+    def test_logical_id_spanning_rollouts_is_ambiguous_without_trace(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            first, second, sources = self.rollout_pair(root)
+
+            result = meter.trash_session_log(
+                "shared", sources=sources, trash_dir=str(root / "Trash"),
+            )
+
+            self.assertEqual(result["error_code"], "ambiguous_id")
+            self.assertTrue(first.exists())
+            self.assertTrue(second.exists())
+
+    def test_trace_key_moves_exactly_the_selected_rollout(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            first, second, sources = self.rollout_pair(root)
+
+            result = meter.trash_session_log(
+                "shared", trace="rollout-b.jsonl", sources=sources,
+                trash_dir=str(root / "Trash"),
+            )
+
+            self.assertTrue(result["ok"])
+            self.assertTrue(first.exists())
+            self.assertFalse(second.exists())
+
+    def test_trace_key_must_belong_to_the_session_id(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            first, second, sources = self.rollout_pair(root)
+            for session_id, trace in (("other", "rollout-b.jsonl"), ("shared", "rollout-c.jsonl"),
+                                      ("shared", "../rollout-b.jsonl")):
+                result = meter.trash_session_log(
+                    session_id, trace=trace, sources=sources,
+                    trash_dir=str(root / "Trash"),
+                )
+                self.assertEqual(result["error_code"], "not_found")
+            self.assertTrue(first.exists())
+            self.assertTrue(second.exists())
+
+    def test_trace_key_longer_than_the_bound_is_rejected(self):
+        result = meter.trash_session_log("shared", trace="x" * 241, sources=[])
+        self.assertEqual(result["error_code"], "invalid_id")
+
+    def test_delete_route_checks_the_provider_of_the_exact_trace(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            first, second, sources = self.rollout_pair(root)
+            sources[1]["provider"] = "opencode"
+            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
+                    mock.patch.object(meter, "trash_session_log",
+                                      return_value={"ok": True}) as trash:
+                refused = meter.request_session_delete("shared", "rollout-b.jsonl")
+                allowed = meter.request_session_delete("shared", "rollout-a.jsonl")
+            self.assertEqual(refused["error_code"], "read_only_provider")
+            self.assertTrue(allowed["ok"])
+            trash.assert_called_once_with("shared", sources=sources, trace="rollout-a.jsonl")
+            self.assertTrue(first.exists())
+            self.assertTrue(second.exists())
+
+    def test_id_only_delete_of_a_read_only_multi_file_session_reports_read_only(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            first, second, sources = self.rollout_pair(Path(tmp))
+            for source in sources:
+                source["provider"] = "opencode"
+            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
+                    mock.patch.object(meter, "trash_session_log") as trash:
+                result = meter.request_session_delete("shared")
+            self.assertEqual(result["error_code"], "read_only_provider")
+            trash.assert_not_called()
+            self.assertTrue(first.exists())
+            self.assertTrue(second.exists())
+
+    def test_id_only_delete_of_a_mixed_provider_session_stays_ambiguous(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            first, second, sources = self.rollout_pair(root)
+            sources[1]["provider"] = "opencode"
+            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
+                    mock.patch.object(meter, "trash_session_log",
+                                      return_value={"ok": True}) as trash:
+                result = meter.request_session_delete("shared")
+            self.assertEqual(result["error_code"], "ambiguous_id")
+            trash.assert_not_called()
+            self.assertTrue(first.exists())
+            self.assertTrue(second.exists())
+
+    def test_delete_route_forwards_the_trace_key(self):
+        source = (Path(meter.__file__).resolve().parent / "token_meter" / "app.py").read_text()
+        self.assertIn(
+            'request_session_delete(payload.get("session_id"), payload.get("trace"))', source,
+        )
+
+    def test_trace_delete_keeps_the_claude_duplicate_guard(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            canonical, duplicate = root / "canonical.jsonl", root / "duplicate.jsonl"
+            canonical.write_text("{}\n")
+            duplicate.write_text("{}\n")
+            source = {
+                "id": "shared", "session": canonical.name, "path": str(canonical),
+                "provider": "claude", "project": "/repo", "mtime": 2,
+                "_aggregation_key": "claude:shared", "_aggregation_canonical": True,
+                "_duplicate_paths": (str(canonical), str(duplicate)),
+            }
+            result = meter.trash_session_log(
+                "shared", trace=canonical.name, sources=[source],
+                trash_dir=str(root / "Trash"),
+            )
+            self.assertEqual(result["error_code"], "ambiguous_id")
+            self.assertTrue(canonical.exists())
+            self.assertTrue(duplicate.exists())
+
+    def test_cursor_delete_moves_only_transcript_and_preserves_shared_database(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            transcript = root / "projects" / "repo" / "agent-transcripts" / "cursor-one" / "cursor-one.jsonl"
+            transcript.parent.mkdir(parents=True)
+            transcript.write_text('{"role":"user"}\n')
+            database = root / "state.vscdb"
+            database.write_bytes(b"shared cursor database")
+            source = {
+                "id": "cursor-one", "session": transcript.name, "path": str(transcript),
+                "provider": "cursor", "project": "/repo", "title": "Cursor", "mtime": 1,
+            }
+            result = meter.trash_session_log(
+                "cursor-one", sources=[source], trash_dir=str(root / "Trash")
+            )
+            self.assertTrue(result["ok"])
+            self.assertFalse(transcript.exists())
+            self.assertTrue(database.exists())
+            self.assertEqual(database.read_bytes(), b"shared cursor database")
+
+    def test_publish_after_delete_selects_newest_remaining_session(self):
+        sources = [{"id": "older", "path": "/tmp/older.jsonl", "mtime": 1},
+                   {"id": "newer", "path": "/tmp/newer.jsonl", "mtime": 2}]
+        published = []
+        with mock.patch.object(meter, "all_session_sources", return_value=sources), \
+                mock.patch.object(meter, "cross_session", return_value={"sessions": []}), \
+                mock.patch.object(meter, "recompute", return_value={"source": {"id": "newer"}}), \
+                mock.patch.object(meter, "publish", side_effect=published.append):
+            selected = meter.publish_after_session_delete()
+        self.assertEqual(selected, "newer")
+        self.assertEqual(published[0]["source"]["id"], "newer")
+
+
+class LiveCrossSessionRefreshTests(unittest.TestCase):
+    def test_membership_probe_uses_two_seconds_with_a_four_second_fallback(self):
+        self.assertFalse(meter.source_membership_probe_due(2.99, 1.0))
+        self.assertTrue(meter.source_membership_probe_due(3.0, 1.0))
+        self.assertFalse(meter.source_membership_fallback_due(4.99, 1.0))
+        self.assertTrue(meter.source_membership_fallback_due(5.0, 1.0))
+
+    def test_full_source_metadata_discovery_retains_the_ten_second_cadence(self):
+        self.assertTrue(meter.source_discovery_refresh_due(False, 1.0, 0.0))
+        self.assertFalse(meter.source_discovery_refresh_due(True, 10.99, 1.0))
+        self.assertTrue(meter.source_discovery_refresh_due(True, 11.0, 1.0))
+
+    def test_inventory_probe_ignores_active_growth_and_detects_a_resume(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            active = root / "project" / "active.jsonl"
+            inactive = root / "project" / "inactive.jsonl"
+            active.parent.mkdir()
+            active.write_text("{}\n")
+            inactive.write_text("{}\n")
+            sources = [
+                {"path": str(active), "provider": "codex"},
+                {"path": str(inactive), "provider": "codex"},
+            ]
+            targets = meter.source_inventory_probe_targets(
+                sources, roots=[str(root)], extra_files=[],
+            )
+            before = meter.source_inventory_probe_signature(
+                targets, current_path=str(active),
+            )
+
+            with active.open("a") as handle:
+                handle.write("{}\n")
+            active_only = meter.source_inventory_probe_signature(
+                targets, current_path=str(active),
+            )
+            with inactive.open("a") as handle:
+                handle.write("{}\n")
+            resumed = meter.source_inventory_probe_signature(
+                targets, current_path=str(active),
+            )
+
+        self.assertEqual(active_only, before)
+        self.assertNotEqual(resumed, before)
+
+    def test_inventory_probe_detects_a_new_nested_session_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            existing = root / "project" / "existing.jsonl"
+            existing.parent.mkdir()
+            existing.write_text("{}\n")
+            targets = meter.source_inventory_probe_targets(
+                [{"path": str(existing), "provider": "claude"}],
+                roots=[str(root)], extra_files=[],
+            )
+            before = meter.source_inventory_probe_signature(targets)
+
+            new_session = root / "project" / "new.jsonl"
+            new_session.write_text("{}\n")
+            after = meter.source_inventory_probe_signature(targets)
+
+        self.assertNotEqual(after, before)
+
+    def test_known_source_activity_refreshes_without_adapter_discovery(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            active_path = Path(tmp) / "active.jsonl"
+            inactive_path = Path(tmp) / "inactive.jsonl"
+            active_path.write_text("{}\n")
+            inactive_path.write_text("{}\n")
+            os.utime(active_path, (20, 20))
+            os.utime(inactive_path, (20, 20))
+            sources = [
+                {
+                    "provider": "codex", "id": "active",
+                    "path": str(active_path), "mtime": 10,
+                },
+                {
+                    "provider": "codex", "id": "inactive",
+                    "path": str(inactive_path), "mtime": 10,
+                },
+            ]
+
+            refreshed = meter.refresh_known_source_activity(
+                sources, current_path=str(active_path),
+            )
+
+        self.assertEqual(refreshed[0]["mtime"], 20)
+        self.assertEqual(refreshed[1]["mtime"], 10)
+        self.assertEqual(sources[0]["mtime"], 10)
+
+    def test_unchanged_known_activity_reuses_the_inventory_object(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            active_path = Path(tmp) / "active.jsonl"
+            active_path.write_text("{}\n")
+            os.utime(active_path, (20, 20))
+            sources = [{
+                "provider": "codex", "id": "active",
+                "path": str(active_path), "mtime": 20,
+            }]
+
+            refreshed = meter.refresh_known_source_activity(
+                sources, current_path=str(active_path),
+            )
+
+        self.assertIs(refreshed, sources)
+
+    def test_current_session_rebuilds_immediately_then_coalesces_changes(self):
+        initial = (100, 20)
+        changed = (101, 21)
+
+        self.assertTrue(meter.current_session_refresh_due(
+            initial, None, 10.0, 0.0,
+        ))
+        self.assertFalse(meter.current_session_refresh_due(
+            changed, initial, 11.49, 10.0,
+        ))
+        self.assertTrue(meter.current_session_refresh_due(
+            changed, initial, 11.5, 10.0,
+        ))
+        self.assertFalse(meter.current_session_refresh_due(
+            initial, initial, 20.0, 10.0,
+        ))
+
+    def test_session_detail_reuses_cached_cross_session_snapshot(self):
+        handler = object.__new__(meter.H)
+        handler.path = "/session?id=session-1"
+        handler.headers = {"Host": "127.0.0.1:8722"}
+        sent = []
+        handler._send = lambda body, *_args, **_kwargs: sent.append(json.loads(body))
+        cached = {"current_sessions": []}
+        rebuilder = mock.Mock(return_value={"current_sessions": []})
+        state = {"source": {"id": "session-1"}, "timing": {}}
+        source = {"id": "session-1", "path": "/logs/exact.jsonl"}
+        summary = {
+            "model_stats": [{"model": "exact-model", "executions": 2}],
+            "usage_basis": "reported",
+            "provenance": {"usage_basis": "reported"},
+        }
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["data"] = cached
+            with mock.patch.object(meter, "find_session", return_value=source), \
+                    mock.patch.object(meter, "cached_session_state", return_value=state), \
+                    mock.patch.object(meter, "session_summary", return_value=summary) as selected_summary, \
+                    mock.patch.object(meter, "cross_session", rebuilder), \
+                    mock.patch.object(meter, "attach_cross_session") as attach:
+                handler.do_GET()
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        rebuilder.assert_not_called()
+        attach.assert_called_once_with(state, cached)
+        selected_summary.assert_called_once_with(source)
+        self.assertEqual(sent[0]["selected_stats"], summary)
+
+    def test_full_sse_queue_keeps_subscriber_and_coalesces_to_latest_state(self):
+        q_ = meter.queue.Queue(maxsize=2)
+        q_.put_nowait("stale-one")
+        q_.put_nowait("stale-two")
+        self.assertTrue(meter.enqueue_latest(q_, "latest"))
+        self.assertEqual(q_.qsize(), 1)
+        self.assertEqual(q_.get_nowait(), "latest")
+
+    def test_source_signature_changes_when_a_background_log_changes(self):
+        before = meter.source_mtime_signature([
+            {"path": "/logs/current.jsonl", "mtime": 20},
+            {"path": "/logs/background.jsonl", "mtime": 10},
+        ])
+        after = meter.source_mtime_signature([
+            {"path": "/logs/current.jsonl", "mtime": 20},
+            {"path": "/logs/background.jsonl", "mtime": 11},
+        ])
+        self.assertNotEqual(before, after)
+
+    def test_session_membership_bypasses_the_cross_session_refresh_throttle(self):
+        before = meter.source_identity_signature([
+            {"id": "current", "provider": "codex", "path": "/logs/current.jsonl"},
+        ])
+        after = meter.source_identity_signature([
+            {"id": "current", "provider": "codex", "path": "/logs/current.jsonl"},
+            {"id": "new", "provider": "claude", "path": "/logs/new.jsonl"},
+        ])
+
+        self.assertNotEqual(before, after)
+        self.assertTrue(meter.cross_session_refresh_due(True, True, 10.1, 10.0))
+        self.assertFalse(meter.cross_session_refresh_due(True, False, 10.1, 10.0))
+        self.assertFalse(meter.cross_session_refresh_due(True, False, 24.9, 10.0))
+        self.assertTrue(meter.cross_session_refresh_due(True, False, 25.0, 10.0))
+
+    def test_publishing_inventory_evicts_only_disappeared_summary_paths(self):
+        cache = {
+            "/logs/live.jsonl": {"signature": (1, ""), "row": {"id": "live"}},
+            "/logs/stale.jsonl": {"signature": (1, ""), "row": {"id": "stale"}},
+        }
+        saved_inventory = dict(meter._SOURCE_INVENTORY)
+        try:
+            with mock.patch.object(meter, "_summary_cache", cache), \
+                    mock.patch.object(meter, "_RUNTIME_DISCOVERY_FAILURES", ()):
+                meter.publish_source_inventory([
+                    {"path": "/logs/live.jsonl", "provider": "codex"},
+                ])
+        finally:
+            meter._SOURCE_INVENTORY.clear()
+            meter._SOURCE_INVENTORY.update(saved_inventory)
+
+        self.assertEqual(list(cache), ["/logs/live.jsonl"])
+
+    def test_partial_discovery_failure_preserves_missing_summary_paths(self):
+        cache = {
+            "/logs/live.jsonl": {"signature": (1, ""), "row": {"id": "live"}},
+            "/logs/temporarily-missing.jsonl": {
+                "signature": (1, ""), "row": {"id": "missing"},
+            },
+        }
+        saved_inventory = dict(meter._SOURCE_INVENTORY)
+        try:
+            with mock.patch.object(meter, "_summary_cache", cache), \
+                    mock.patch.object(meter, "_RUNTIME_DISCOVERY_FAILURES", (object(),)):
+                meter.publish_source_inventory([
+                    {"path": "/logs/live.jsonl", "provider": "codex"},
+                ])
+        finally:
+            meter._SOURCE_INVENTORY.clear()
+            meter._SOURCE_INVENTORY.update(saved_inventory)
+
+        self.assertEqual(
+            list(cache), ["/logs/live.jsonl", "/logs/temporarily-missing.jsonl"],
+        )
+
+    def test_cross_session_refresh_replaces_cached_snapshot_before_publish(self):
+        saved_cache = dict(meter._xsess)
+        published = []
+        fresh = {"sessions": [{"id": "fresh"}], "capabilities": {}}
+        state = {"provider": "codex", "tools": {}, "source": {"id": "current"}}
+        try:
+            meter._xsess["data"], meter._xsess["at"] = {"sessions": [{"id": "stale"}]}, 123
+            result = meter.refresh_cross_session_state(
+                state, builder=lambda: fresh, publisher=published.append,
+            )
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertIs(result, fresh)
+        self.assertEqual(published[0]["xsession"]["sessions"][0]["id"], "fresh")
+
+    def test_logs_inventory_keeps_full_rows_beyond_state_preview(self):
+        saved_cache = dict(meter._xsess)
+        preview = [{"id": "recent"}]
+        full = [{"id": "recent"}, {"id": "older-claude", "client": "claude_code"}]
+        try:
+            meter._xsess.update({
+                "data": {"generated_at": 123, "sessions": preview, "total_sessions": 2},
+                "at": meter.time.time(),
+                "sessions": full,
+            })
+            result = meter.log_sessions_state()
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertEqual(result["sessions"], full)
+        self.assertEqual(result["total_sessions"], 2)
+        self.assertEqual(result["generated_at"], 123)
+
+    def test_logs_inventory_replaces_trace_paths_with_opaque_keys(self):
+        from token_meter.domain.compare import trace_key
+        saved_cache = dict(meter._xsess)
+        private = "/Users/private-user/.claude/projects/p/abc.jsonl"
+        full = [{"id": "abc", "path": private, "project": "~/p"}, {"id": "no-path"}]
+        try:
+            meter._xsess.update({
+                "data": {"generated_at": 1, "sessions": full[:1], "total_sessions": 2},
+                "at": meter.time.time(),
+                "sessions": full,
+            })
+            result = meter.log_sessions_state()
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertNotIn("private-user", json.dumps(result))
+        self.assertNotIn("path", result["sessions"][0])
+        self.assertEqual(result["sessions"][0]["key"], trace_key({"path": private}))
+        self.assertEqual(result["sessions"][0]["project"], "~/p")
+        self.assertEqual(result["sessions"][1], {"id": "no-path"})
+        self.assertEqual(full[0]["path"], private)
+
+    def test_logs_inventory_returns_loading_without_rebuilding_cold_history(self):
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess.update({"data": None, "at": 0, "sessions": []})
+            with mock.patch.object(
+                meter, "cross_session",
+                side_effect=AssertionError("logs request must not rebuild cold history"),
+            ):
+                result = meter.log_sessions_state()
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertTrue(result["loading"])
+        self.assertIsNone(result["total_sessions"])
+        self.assertEqual(result["sessions"], [])
+
+    def test_cross_session_separates_runtime_models_and_reported_alert_basis(self):
+        def row(source):
+            estimated = source["provider"] == "cursor"
+            cost = 2.0 if estimated else 1.0
+            tokens = 200 if estimated else 100
+            return {
+                **source, "turns": 1, "cost": cost, "tokens": tokens,
+                "input_tokens": tokens - 10, "output_tokens": 10,
+                "models": ["gpt-5.6"], "token_estimate": estimated,
+                "availability": meter.metric_availability(
+                    source["provider"], cost=True, tokens=True,
+                    input_tokens=True, output_tokens=True,
+                ),
+                "_model_cost": {"gpt-5.6": cost}, "_model_tok": {"gpt-5.6": tokens},
+                "_day_cost": {"2026-07-20": cost}, "model_stats": [],
+                "_model_daily": [], "_performance_samples": [], "_wait_samples": [],
+                "_tool_evidence": {},
+            }
+
+        sources = [
+            {"id": "codex", "path": "/tmp/codex", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/repo", "mtime": 2},
+            {"id": "cursor", "path": "/tmp/cursor", "provider": "cursor",
+             "runtime": "Cursor", "label": "Cursor", "project": "/repo", "mtime": 1},
+        ]
+        rows = {source["id"]: row(source) for source in sources}
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["data"], meter._xsess["at"] = None, 0
+            with mock.patch.object(meter, "all_session_sources", return_value=sources), \
+                    mock.patch.object(meter, "session_summary",
+                                      side_effect=lambda source: rows[source["id"]]), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                result = meter.cross_session()
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+        self.assertEqual({item["id"] for item in result["model_mix"]},
+                         {"gpt-5.6::Codex", "gpt-5.6::Cursor"})
+        self.assertEqual(result["usage_basis"], "mixed")
+        self.assertEqual(result["reported_cost"], 1.0)
+        self.assertEqual(result["estimated_cost"], 2.0)
+        self.assertEqual(result["trend"][0]["reported_cost"], 1.0)
+        self.assertEqual(result["trend"][0]["anomaly_basis"], "reported_only")
+
+    def test_cross_session_counts_adapter_owned_duplicate_identity_once(self):
+        def row(source):
+            return {
+                **source, "turns": 1, "cost": 1.0, "tokens": 100,
+                "input_tokens": 90, "output_tokens": 10,
+                "models": ["claude-test"], "token_estimate": False,
+                "availability": meter.metric_availability(
+                    "claude", cost=True, tokens=True,
+                    input_tokens=True, output_tokens=True,
+                ),
+                "_model_cost": {"claude-test": 1.0},
+                "_model_tok": {"claude-test": 100},
+                "_day_cost": {"2026-08-18": 1.0}, "model_stats": [],
+                "_model_daily": [], "_performance_samples": [],
+                "_wait_samples": [], "_tool_evidence": {},
+            }
+
+        canonical_path = "/tmp/claude-canonical.jsonl"
+        duplicate_path = "/tmp/claude-duplicate.jsonl"
+        sources = [
+            {
+                "id": "shared", "path": canonical_path, "provider": "claude",
+                "runtime": "Claude", "label": "Claude Desktop",
+                "project": "/repo", "mtime": 2,
+                "_aggregation_key": "claude:shared",
+                "_aggregation_canonical": True,
+            },
+            {
+                "id": "shared", "path": duplicate_path, "provider": "claude",
+                "runtime": "Claude", "label": "Claude Desktop",
+                "project": "/repo", "mtime": 1,
+                "_aggregation_key": "claude:shared",
+            },
+        ]
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess["data"], meter._xsess["at"] = None, 0
+            with mock.patch.object(meter, "session_summary", side_effect=row), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                result = meter.cross_session(sources=sources)
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(result["total_sessions"], 1)
+        self.assertEqual(result["total_cost"], 1.0)
+        self.assertEqual(result["total_tokens"], 100)
+        self.assertNotIn(duplicate_path, json.dumps(result))
+
+    def test_cross_session_projects_subagent_usage_and_selected_group(self):
+        sources = [
+            {"id": "root", "path": "/tmp/root", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/repo",
+             "mtime": 2},
+            {"id": "child", "path": "/tmp/child", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/repo",
+             "mtime": 3},
+        ]
+
+        def summary(source):
+            child = source["id"] == "child"
+            cost = 2.0 if child else 1.0
+            tokens = 200 if child else 100
+            agent_record = {
+                "id": source["id"],
+                "parent_id": "root" if child else None,
+                "session_id": source["id"],
+                "runtime": "codex", "client": "Codex",
+                "kind": "spawned" if child else "root",
+                "depth": 1 if child else 0, "label": "Worker" if child else "",
+                "role": "researcher" if child else None,
+                "model": "gpt-5.6-sol", "activity_state": "working" if child else "recent",
+                "started_at": 1, "ended_at": None, "last_activity_at": 2,
+                "tokens": tokens, "tokens_available": True,
+                "input_tokens": tokens - 10, "output_tokens": 10,
+                "cache_read_tokens": 0, "cache_write_tokens": 0,
+                "reasoning_tokens": 0, "cost": cost, "cost_available": True,
+                "executions": 1, "attempts": 1, "retries": 0,
+                "failed_attempts": 0, "tool_calls": 0,
+                "agent_path": "/private/agent.md",
+            }
+            return {
+                **source, "turns": 1, "cost": cost, "tokens": tokens,
+                "input_tokens": tokens - 10, "output_tokens": 10,
+                "models": ["gpt-5.6-sol"], "token_estimate": False,
+                "availability": meter.metric_availability(
+                    "codex", cost=True, tokens=True,
+                    input_tokens=True, output_tokens=True,
+                ),
+                "_model_cost": {"gpt-5.6-sol": cost},
+                "_model_tok": {"gpt-5.6-sol": tokens},
+                "_day_cost": {"2026-08-18": cost}, "model_stats": [],
+                "_model_daily": [], "_performance_samples": [],
+                "_wait_samples": [], "_tool_evidence": {},
+                "_agent_records": [agent_record],
+            }
+
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess.update({"data": None, "at": 0, "agent_groups": ()})
+            with mock.patch.object(meter, "session_summary", side_effect=summary), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                cross = meter.cross_session(sources=sources)
+            state = meter.attach_cross_session({"source": {"id": "child"}}, cross)
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(cross["total_cost"], 3.0)
+        self.assertEqual(cross["total_tokens"], 300)
+        self.assertEqual(cross["agent_usage"]["totals"]["agents"], 1)
+        self.assertEqual(cross["agent_usage"]["totals"]["cost"], 2.0)
+        self.assertEqual(
+            cross["agent_usage"]["models"][0]["id"],
+            "gpt-5.6-sol::codex::spawned",
+        )
+        self.assertEqual(
+            cross["agent_usage"]["inventory"][0]["role"], "researcher",
+        )
+        self.assertEqual(
+            cross["agent_usage"]["inventory"][0]["root_session_id"], "root",
+        )
+        self.assertFalse(cross["agent_usage"]["inventory_truncated"])
+        self.assertEqual(state["agent_group"]["root_session_id"], "root")
+        self.assertEqual(state["agent_group"]["selected_agent_id"], "child")
+        self.assertEqual(len(state["agent_group"]["agents"]), 2)
+        encoded = json.dumps({"cross": cross, "group": state["agent_group"]})
+        self.assertNotIn("agent_path", encoded)
+        self.assertNotIn("/private/agent.md", encoded)
+        self.assertNotIn("_all_agents", encoded)
+        self.assertNotIn("_session_ids", encoded)
+
+    def test_cross_session_uses_physical_agents_without_changing_accounting_totals(self):
+        sources = [
+            {"id": "shared", "path": "/tmp/root-old", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
+             "physical_trace_id": "physical-root", "mtime": 1},
+            {"id": "shared", "path": "/tmp/root-new", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
+             "physical_trace_id": "physical-root", "mtime": 2},
+            {"id": "shared", "path": "/tmp/child-a", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
+             "physical_trace_id": "physical-child-a", "mtime": 3},
+            {"id": "shared", "path": "/tmp/child-b", "provider": "codex",
+             "runtime": "Codex", "label": "Codex", "project": "/luna-3",
+             "physical_trace_id": "physical-child-b", "mtime": 4},
+        ]
+
+        def summary(source):
+            suffix = source["path"].rsplit("/", 1)[-1]
+            is_root = suffix.startswith("root")
+            cost = {"root-old": 1.0, "root-new": 2.0,
+                    "child-a": 3.0, "child-b": 4.0}[suffix]
+            tokens = int(cost * 100)
+            agent_id = "agent-root" if is_root else f"agent-{suffix}"
+            record = {
+                "id": agent_id,
+                "parent_id": None if is_root else "agent-root",
+                "session_id": "shared" if is_root else None,
+                "runtime": "codex", "client": "Codex",
+                "kind": "root" if is_root else "spawned",
+                "depth": 0 if is_root else 1,
+                "model": "gpt-5.6-sol", "activity_state": "recent",
+                "started_at": 1, "ended_at": 2, "last_activity_at": 2,
+                "tokens": tokens, "tokens_available": True,
+                "input_tokens": tokens - 10, "output_tokens": 10,
+                "cache_read_tokens": 0, "cache_write_tokens": 0,
+                "reasoning_tokens": 0, "cost": cost,
+                "cost_available": True, "executions": 1, "attempts": 1,
+                "retries": 0, "failed_attempts": 0, "tool_calls": 0,
+            }
+            return {
+                **source, "turns": 1, "cost": cost, "tokens": tokens,
+                "input_tokens": tokens - 10, "output_tokens": 10,
+                "models": ["gpt-5.6-sol"], "token_estimate": False,
+                "availability": meter.metric_availability(
+                    "codex", cost=True, tokens=True,
+                    input_tokens=True, output_tokens=True,
+                ),
+                "_model_cost": {"gpt-5.6-sol": cost},
+                "_model_tok": {"gpt-5.6-sol": tokens},
+                "_day_cost": {"2026-09-22": cost}, "model_stats": [],
+                "_model_daily": [], "_performance_samples": [],
+                "_wait_samples": [], "_tool_evidence": {},
+                "_agent_records": [record],
+            }
+
+        saved_cache = dict(meter._xsess)
+        try:
+            meter._xsess.update({"data": None, "at": 0, "agent_groups": ()})
+            with mock.patch.object(meter, "session_summary", side_effect=summary), \
+                    mock.patch.object(meter, "capability_inventory", return_value={}):
+                cross = meter.cross_session(sources=sources)
+        finally:
+            meter._xsess.clear()
+            meter._xsess.update(saved_cache)
+
+        self.assertEqual(cross["total_sessions"], 4)
+        self.assertEqual(cross["total_cost"], 10.0)
+        self.assertEqual(cross["total_tokens"], 1000)
+        self.assertEqual(cross["agent_usage"]["totals"]["agents"], 2)
+        self.assertEqual(cross["agent_usage"]["totals"]["cost"], 7.0)
+        project_scopes = [
+            scope for scope in cross["agent_usage"]["scopes"]
+            if scope.get("project") == "/luna-3"
+            and scope["window"] == "all" and scope["runtime"] == "codex"
+        ]
+        self.assertEqual(len(project_scopes), 1)
+        self.assertEqual(project_scopes[0]["totals"]["agents"], 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_session_summaries.py b/tests/test_session_summaries.py
new file mode 100644
index 00000000..943bd2d7
--- /dev/null
+++ b/tests/test_session_summaries.py
@@ -0,0 +1,1297 @@
+import unittest
+import json
+import os
+import tempfile
+import threading
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class SessionSummaryStatsTests(unittest.TestCase):
+    def source(self, provider, model=None):
+        return {
+            "id": "session", "path": "/tmp/session.jsonl", "provider": provider,
+            "client": provider, "label": provider.title(), "project": "/repo",
+            "mtime": 1, "title": "Summary stats", "model": model,
+        }
+
+    def test_claude_summary_exposes_input_output_and_model_stats(self):
+        objs = [{
+            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {
+                "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
+                "usage": {"input_tokens": 100, "cache_creation_input_tokens": 20,
+                          "cache_read_input_tokens": 30, "output_tokens": 10},
+                "stop_reason": "end_turn",
+            },
+        }]
+        row = meter.claude_summary(self.source("claude"), objs)
+        self.assertEqual(row["input_tokens"], 150)
+        self.assertEqual(row["output_tokens"], 10)
+        self.assertEqual(row["model_stats"][0]["model"], "claude-sonnet-4-6")
+        self.assertEqual(row["model_stats"][0]["executions"], 1)
+        self.assertEqual(row["model_stats"][0]["reasoning_executions"], 0)
+        self.assertEqual(row["model_stats"][0]["reasoning_unavailable_executions"], 1)
+        self.assertEqual(row["primary_model"], "claude-sonnet-4-6")
+        self.assertEqual(row["context"]["latest"], 150)
+        self.assertIsNone(row["context"]["window"])
+        self.assertEqual(row["_context_samples"], [150])
+        self.assertTrue(row["terminal"])
+        self.assertEqual(row["usage_basis"], "reported")
+
+    def test_claude_summary_keeps_thinking_visible_without_inventing_reasoning_tokens(self):
+        objs = [
+            {
+                "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+                "message": {
+                    "id": "msg-1", "model": "claude-opus-4-8",
+                    "content": [{"type": "thinking", "thinking": "hidden"}],
+                    "usage": {"input_tokens": 100, "output_tokens": 40},
+                    "stop_reason": "end_turn",
+                },
+            },
+            {
+                "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
+                "message": {
+                    "id": "msg-1", "model": "claude-opus-4-8",
+                    "content": [{"type": "text", "text": "answer"}],
+                    "usage": {"input_tokens": 100, "output_tokens": 40},
+                    "stop_reason": "end_turn",
+                },
+            },
+        ]
+
+        row = meter.claude_summary(self.source("claude"), objs)
+        stats = row["model_stats"][0]
+        self.assertEqual(stats["executions"], 1)
+        self.assertEqual(stats["reasoning_tokens"], 0)
+        self.assertEqual(stats["reasoning_output_tokens"], 0)
+        self.assertEqual(stats["reasoning_executions"], 0)
+        self.assertEqual(stats["reasoning_unavailable_executions"], 1)
+        self.assertEqual(stats["thinking_executions"], 1)
+        self.assertEqual(stats["thinking_covered_executions"], 0)
+        aggregate = meter.aggregate_model_stats([row])["models"][0]
+        self.assertEqual(aggregate["reasoning_tokens"], 0)
+        self.assertEqual(aggregate["reasoning_output_tokens"], 0)
+        self.assertFalse(aggregate["availability"]["reasoning_tokens"])
+        self.assertFalse(aggregate["coverage"]["reasoning_tokens"]["complete"])
+        self.assertEqual(aggregate["thinking_executions"], 1)
+        self.assertEqual(aggregate["thinking_covered_executions"], 0)
+        self.assertEqual(aggregate["daily"][0]["reasoning_tokens"], 0)
+        self.assertEqual(aggregate["daily"][0]["thinking_executions"], 1)
+        self.assertEqual(aggregate["daily"][0]["thinking_covered_executions"], 0)
+
+    def test_claude_summary_accepts_separate_thinking_token_stat(self):
+        row = meter.claude_summary(self.source("claude"), [{
+            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "thinking", "thinking": "hidden"}],
+                "usage": {
+                    "input_tokens": 100,
+                    "output_tokens": 40,
+                    "thinking_tokens": 30,
+                },
+                "stop_reason": "end_turn",
+            },
+        }])
+
+        stats = row["model_stats"][0]
+        self.assertEqual(stats["reasoning_tokens"], 30)
+        self.assertEqual(stats["reasoning_output_tokens"], 40)
+        self.assertEqual(stats["reasoning_executions"], 1)
+        self.assertEqual(stats["thinking_executions"], 1)
+        self.assertEqual(stats["thinking_covered_executions"], 1)
+
+    def test_claude_split_messages_preserve_separate_thinking_token_stat(self):
+        thinking = {
+            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "thinking", "thinking": "hidden"}],
+                "usage": {
+                    "input_tokens": 100,
+                    "output_tokens": 40,
+                    "thinking_tokens": 30,
+                },
+                "stop_reason": None,
+            },
+        }
+        answer = {
+            "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
+            "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "text", "text": "answer"}],
+                "usage": {"input_tokens": 100, "output_tokens": 40},
+                "stop_reason": "end_turn",
+            },
+        }
+
+        for records in ([thinking, answer], [answer, thinking]):
+            with self.subTest(exact_stat_first=records[0] is thinking):
+                row = meter.claude_summary(self.source("claude"), records)
+                stats = row["model_stats"][0]
+                self.assertEqual(stats["reasoning_tokens"], 30)
+                self.assertEqual(stats["reasoning_output_tokens"], 40)
+                self.assertEqual(stats["thinking_covered_executions"], 1)
+
+                with tempfile.TemporaryDirectory() as tmp:
+                    path = Path(tmp) / "claude-thinking.jsonl"
+                    path.write_text("".join(
+                        json.dumps(record) + "\n" for record in records
+                    ))
+                    selected = meter.recompute_claude({
+                        **self.source("claude"),
+                        "path": str(path),
+                        "session": path.name,
+                    })
+                self.assertEqual(selected["semantic"]["reasoning"], 30)
+                self.assertEqual(selected["semantic"]["output"], 10)
+
+    def test_claude_selected_session_never_substitutes_output_for_thinking_tokens(self):
+        def recompute(thinking_tokens=None, block_type="thinking"):
+            usage = {"input_tokens": 100, "output_tokens": 40}
+            if thinking_tokens is not None:
+                usage["thinking_tokens"] = thinking_tokens
+            records = [
+                {
+                    "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+                    "message": {
+                        "id": "msg-1", "model": "claude-opus-4-8",
+                        "content": [{"type": block_type, "thinking": "hidden"}],
+                        "usage": usage, "stop_reason": "end_turn",
+                    },
+                },
+                {
+                    "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
+                    "message": {
+                        "id": "msg-1", "model": "claude-opus-4-8",
+                        "content": [{"type": "text", "text": "answer"}],
+                        "usage": usage, "stop_reason": "end_turn",
+                    },
+                },
+            ]
+            with tempfile.TemporaryDirectory() as tmp:
+                path = Path(tmp) / "claude-thinking.jsonl"
+                path.write_text("".join(json.dumps(record) + "\n" for record in records))
+                return meter.recompute_claude({
+                    **self.source("claude"), "path": str(path), "session": path.name,
+                })
+
+        unavailable = recompute()
+        self.assertEqual(unavailable["semantic"]["reasoning"], 0)
+        self.assertEqual(unavailable["semantic"]["output"], 40)
+        self.assertEqual(unavailable["analyses"]["reasoning"]["tokens"], 0)
+        self.assertEqual(unavailable["analyses"]["reasoning"]["think_turns"], 0)
+        self.assertEqual(unavailable["series"][0]["reasoning"], 0)
+        self.assertEqual(unavailable["executions"][0]["reasoning_tokens"], 0)
+        self.assertEqual(unavailable["executions"][0]["tokens"]["reasoning"], 0)
+        self.assertFalse(any(
+            event["kind"] == "reasoning" for event in unavailable["trace"]
+        ))
+        message = next(
+            event for event in unavailable["trace"] if event["kind"] == "message"
+        )
+        self.assertEqual(message["reasoning_tokens"], 0)
+
+        redacted = recompute(block_type="redacted_thinking")
+        self.assertEqual(redacted["semantic"]["reasoning"], 0)
+        self.assertEqual(redacted["executions"][0]["reasoning_tokens"], 0)
+
+        exact = recompute(30)
+        self.assertEqual(exact["semantic"]["reasoning"], 30)
+        self.assertEqual(exact["semantic"]["output"], 10)
+        self.assertEqual(exact["analyses"]["reasoning"]["tokens"], 30)
+        self.assertEqual(exact["analyses"]["reasoning"]["think_turns"], 1)
+        self.assertEqual(exact["series"][0]["reasoning"], 30)
+        self.assertEqual(exact["executions"][0]["reasoning_tokens"], 30)
+        self.assertEqual(exact["executions"][0]["tokens"]["reasoning"], 30)
+
+    def test_claude_summary_keeps_missing_model_pricing_unavailable(self):
+        row = meter.claude_summary(self.source("claude"), [{
+            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {
+                "id": "msg-1", "content": [],
+                "usage": {"input_tokens": 100_000, "output_tokens": 1_000},
+                "stop_reason": "end_turn",
+            },
+        }])
+
+        self.assertEqual(row["primary_model"], "unknown-model")
+        self.assertFalse(row["availability"]["cost"])
+        self.assertEqual(row["cost"], 0.0)
+
+    def test_claude_and_codex_malformed_token_counts_fail_closed(self):
+        for value in ("bad", True, -1, 1.5, float("inf"), 10 ** 400):
+            with self.subTest(runtime="claude", value_type=type(value).__name__):
+                claude = meter.claude_summary(self.source("claude"), [
+                    {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
+                     "message": {"content": "start"}},
+                    {"type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
+                     "message": {
+                         "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
+                         "usage": {"input_tokens": value, "output_tokens": value},
+                         "stop_reason": "end_turn",
+                     }},
+                    {"type": "user", "timestamp": "2026-07-02T00:00:02.000Z",
+                     "message": {"content": "next"}},
+                ])
+                self.assertFalse(claude["availability"]["tokens"])
+                self.assertFalse(claude["availability"]["input_tokens"])
+                self.assertFalse(claude["availability"]["output_tokens"])
+                self.assertFalse(claude["availability"]["cost"])
+                self.assertEqual(claude["model_stats"][0]["token_covered_executions"], 0)
+                self.assertEqual(claude["model_stats"][0]["io_covered_executions"], 0)
+                self.assertEqual(claude["model_stats"][0]["cost_covered_executions"], 0)
+
+            with self.subTest(runtime="codex", value_type=type(value).__name__):
+                codex = meter.codex_summary(self.source("codex", "gpt-5.6-sol"), [{
+                    "timestamp": "2026-07-02T00:00:00.000Z",
+                    "type": "event_msg",
+                    "payload": {"type": "token_count", "info": {
+                        "last_token_usage": {
+                            "input_tokens": value, "output_tokens": value,
+                        },
+                    }},
+                }])
+                self.assertFalse(codex["availability"]["tokens"])
+                self.assertFalse(codex["availability"]["input_tokens"])
+                self.assertFalse(codex["availability"]["output_tokens"])
+                self.assertFalse(codex["availability"]["cost"])
+                self.assertEqual(codex["model_stats"][0]["token_covered_executions"], 0)
+                self.assertEqual(codex["model_stats"][0]["io_covered_executions"], 0)
+                self.assertEqual(codex["model_stats"][0]["cost_covered_executions"], 0)
+
+        output_only = meter.codex_summary(
+            self.source("codex", "gpt-5.6-sol"), [{
+                "timestamp": "2026-07-02T00:00:00.000Z",
+                "type": "event_msg",
+                "payload": {"type": "token_count", "info": {
+                    "last_token_usage": {"input_tokens": "bad", "output_tokens": 20},
+                }},
+            }],
+        )
+        self.assertFalse(output_only["availability"]["cache"])
+        self.assertFalse(output_only["model_stats"][0]["availability"]["cache"])
+        aggregate = meter.aggregate_model_stats([output_only])["models"][0]
+        self.assertFalse(aggregate["availability"]["cache"])
+        self.assertFalse(aggregate["coverage"]["cache"]["complete"])
+
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "claude-malformed.jsonl"
+            records = [
+                {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
+                 "message": {"content": "start"}},
+                {"type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
+                 "message": {
+                     "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
+                     "usage": {"input_tokens": "bad", "output_tokens": "bad"},
+                     "stop_reason": "end_turn",
+                 }},
+                {"type": "user", "timestamp": "2026-07-02T00:00:02.000Z",
+                 "message": {"content": "next"}},
+            ]
+            path.write_text("".join(json.dumps(record) + "\n" for record in records))
+            state = meter.recompute_claude({
+                **self.source("claude"), "path": str(path), "session": path.name,
+            })
+        self.assertIsNotNone(state)
+        self.assertFalse(state["availability"]["tokens"])
+        self.assertFalse(state["availability"]["cost"])
+
+    def test_claude_summary_keeps_priced_model_coverage_in_mixed_session(self):
+        def message(message_id, model, timestamp, output_tokens):
+            return {
+                "type": "assistant", "timestamp": timestamp,
+                "message": {
+                    "id": message_id, "model": model, "content": [],
+                    "usage": {
+                        "input_tokens": 100, "output_tokens": output_tokens,
+                    },
+                    "stop_reason": "end_turn",
+                },
+            }
+
+        row = meter.claude_summary(self.source("claude"), [
+            message("msg-known", "claude-sonnet-4-6", "2026-07-02T00:00:01.000Z", 20),
+            message("msg-unknown", "unknown-model", "2026-07-02T00:00:02.000Z", 30),
+        ])
+
+        self.assertFalse(row["availability"]["cost"])
+        stats = {item["model"]: item for item in row["model_stats"]}
+        self.assertTrue(stats["claude-sonnet-4-6"]["availability"]["cost"])
+        self.assertEqual(stats["claude-sonnet-4-6"]["cost_covered_executions"], 1)
+        self.assertEqual(stats["claude-sonnet-4-6"]["cost_covered_output_tokens"], 20)
+        self.assertFalse(stats["unknown-model"]["availability"]["cost"])
+        self.assertEqual(stats["unknown-model"]["cost_covered_executions"], 0)
+        daily = {item["model"]: item for item in row["_model_daily"]}
+        self.assertTrue(daily["claude-sonnet-4-6"]["availability"]["cost"])
+        self.assertFalse(daily["unknown-model"]["availability"]["cost"])
+
+        aggregate = {
+            item["model"]: item for item in meter.aggregate_model_stats([row])["models"]
+        }
+        known = aggregate["claude-sonnet-4-6"]
+        self.assertTrue(known["availability"]["cost"])
+        self.assertEqual(known["cost_covered_executions"], 1)
+        self.assertEqual(known["cost_covered_output_tokens"], 20)
+        self.assertTrue(known["daily"][0]["availability"]["cost"])
+        self.assertFalse(aggregate["unknown-model"]["availability"]["cost"])
+
+    def test_claude_summary_ignores_zero_usage_synthetic_marker_for_cost_coverage(self):
+        def message(message_id, model, input_tokens, output_tokens):
+            return {
+                "type": "assistant", "timestamp": "2026-07-02T00:00:01.000Z",
+                "message": {
+                    "id": message_id, "model": model, "content": [],
+                    "usage": {
+                        "input_tokens": input_tokens,
+                        "cache_read_input_tokens": 0,
+                        "cache_creation_input_tokens": 0,
+                        "output_tokens": output_tokens,
+                    },
+                    "stop_reason": "end_turn",
+                },
+            }
+
+        row = meter.claude_summary(self.source("claude"), [
+            message("msg-known", "claude-sonnet-4-6", 100, 20),
+            message("msg-synthetic", "<synthetic>", 0, 0),
+        ])
+
+        self.assertTrue(row["availability"]["cost"])
+        self.assertFalse(row["cost_approx"])
+        self.assertGreater(row["cost"], 0)
+        self.assertEqual(row["primary_model"], "claude-sonnet-4-6")
+        self.assertEqual(row["models"], ["sonnet-4-6"])
+        self.assertEqual(row["context"]["latest"], 100)
+        self.assertEqual(row["_context_samples"], [100])
+        self.assertEqual(row["turns"], 1)
+        self.assertTrue(row["terminal"])
+        from token_meter.domain.aggregates import aggregate_cross_session_rows
+        self.assertEqual(
+            aggregate_cross_session_rows([row])["total_executions"], 1,
+        )
+
+    def test_claude_summary_synthetic_marker_does_not_extend_timing(self):
+        synthetic = self.synthetic_record()
+        synthetic["timestamp"] = "2026-07-02T00:01:00.000Z"
+        row = meter.claude_summary(self.source("claude"), [{
+            "type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {"content": "test request"},
+        }, self.claude_usage_row("2026-07-02T00:00:01.000Z"), synthetic])
+
+        self.assertEqual(row["duration_s"], 1)
+        self.assertEqual(len(row["_wait_samples"]), 1)
+        self.assertEqual(row["_wait_samples"][0]["duration_s"], 1)
+        self.assertEqual(row["_wait_samples"][0]["model"], "claude-sonnet-4-6")
+
+    def synthetic_record(self, usage=None):
+        if usage is None:
+            usage = {
+                "input_tokens": 0, "cache_creation_input_tokens": 0,
+                "cache_read_input_tokens": 0, "output_tokens": 0,
+            }
+        return {
+            "type": "assistant", "timestamp": "2026-07-02T00:01:00.000Z",
+            "message": {
+                "id": "msg-synthetic", "model": "<synthetic>", "content": [],
+                "usage": usage,
+                "stop_reason": "stop_sequence",
+            },
+        }
+
+    def test_claude_synthetic_marker_requires_valid_complete_zero_usage(self):
+        cases = {
+            "malformed": {
+                "input_tokens": "bad", "cache_creation_input_tokens": 0,
+                "cache_read_input_tokens": 0, "output_tokens": "bad",
+            },
+            "missing-output": {
+                "input_tokens": 0, "cache_creation_input_tokens": 0,
+                "cache_read_input_tokens": 0,
+            },
+        }
+        for name, usage in cases.items():
+            with self.subTest(name=name):
+                objs = [self.claude_usage_row(), self.synthetic_record(usage)]
+
+                summary = meter.claude_summary(self.source("claude"), objs)
+                with tempfile.TemporaryDirectory() as tmp:
+                    path = Path(tmp) / "session.jsonl"
+                    path.write_text("".join(json.dumps(row) + "\n" for row in objs))
+                    state = meter.recompute_claude({
+                        **self.source("claude"), "path": str(path),
+                        "session": path.name,
+                    })
+
+                self.assertEqual(summary["turns"], 2)
+                self.assertEqual(summary["primary_model"], "<synthetic>")
+                self.assertFalse(summary["availability"]["cost"])
+                self.assertFalse(state["availability"]["cost"])
+                if name == "malformed":
+                    self.assertFalse(summary["availability"]["tokens"])
+                    self.assertFalse(state["availability"]["tokens"])
+
+    def test_claude_summary_keeps_other_angle_bracket_models(self):
+        other = self.synthetic_record()
+        other["message"]["model"] = "<local-model>"
+
+        row = meter.claude_summary(
+            self.source("claude"), [self.claude_usage_row(), other],
+        )
+
+        self.assertEqual(row["turns"], 2)
+        self.assertEqual(row["primary_model"], "<local-model>")
+        self.assertIn("<local-model>", row["models"])
+
+    def test_claude_only_synthetic_marker_keeps_usage_unavailable(self):
+        objs = [self.synthetic_record()]
+
+        summary = meter.claude_summary(self.source("claude"), objs)
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_text(json.dumps(objs[0]) + "\n")
+            state = meter.recompute_claude({
+                **self.source("claude"), "path": str(path),
+                "session": path.name,
+            })
+
+        self.assertEqual(summary["turns"], 0)
+        self.assertFalse(summary["availability"]["tokens"])
+        self.assertFalse(summary["availability"]["cost"])
+        self.assertEqual(state["executions"], [])
+        self.assertFalse(state["availability"]["tokens"])
+        self.assertFalse(state["availability"]["cost"])
+
+    def test_claude_summary_prices_pseudo_model_records_that_report_tokens(self):
+        objs = [
+            self.claude_usage_row(),
+            self.synthetic_record({"input_tokens": 40, "output_tokens": 5}),
+        ]
+
+        row = meter.claude_summary(self.source("claude"), objs)
+
+        self.assertFalse(row["availability"]["cost"])
+        self.assertEqual(row["primary_model"], "<synthetic>")
+
+    def test_claude_recompute_keeps_cost_available_with_synthetic_records(self):
+        records = [{
+            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {
+                "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
+                "usage": {"input_tokens": 10, "cache_creation_input_tokens": 5_000,
+                          "cache_read_input_tokens": 5_000, "output_tokens": 10,
+                          "cache_creation": {
+                              "ephemeral_5m_input_tokens": 5_000,
+                              "ephemeral_1h_input_tokens": 0,
+                          }},
+                "stop_reason": "end_turn",
+            },
+        }, self.synthetic_record()]
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_text("".join(json.dumps(row) + "\n" for row in records))
+            source = {
+                **self.source("claude"), "path": str(path),
+                "session": path.name,
+            }
+            state = meter.recompute_claude(source)
+
+        self.assertTrue(state["availability"]["cost"])
+        self.assertFalse(state["cost_approx"])
+        self.assertGreater(state["total_cost"], 0)
+        self.assertEqual(len(state["executions"]), 1)
+
+    def test_unknown_model_keeps_cache_money_unavailable(self):
+        record = {
+            "type": "assistant", "timestamp": "2026-07-02T00:00:00.000Z",
+            "message": {
+                "id": "msg-1", "content": [],
+                "usage": {
+                    "input_tokens": 10, "cache_creation_input_tokens": 5_000,
+                    "cache_read_input_tokens": 5_000, "output_tokens": 10,
+                },
+                "stop_reason": "end_turn",
+            },
+        }
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_text(json.dumps(record) + "\n")
+            source = {
+                **self.source("claude"), "path": str(path),
+                "session": path.name,
+            }
+            state = meter.recompute_claude(source)
+
+        self.assertFalse(state["availability"]["cost"])
+        self.assertTrue(state["availability"]["cache"])
+        self.assertEqual(state["cache"]["total"], 10_000)
+        self.assertIsNone(state["cache"]["saved"])
+        self.assertIsNone(state["cache"]["cost"])
+        self.assertIsNone(state["cache_saved"])
+
+    def claude_source_without_title(self):
+        return {
+            "id": "session", "path": "/tmp/session.jsonl", "provider": "claude",
+            "client": "claude", "label": "Claude", "project": "/repo",
+            "mtime": 1, "title": None, "model": None,
+        }
+
+    def claude_usage_row(self, ts="2026-07-02T00:00:00.000Z"):
+        return {
+            "type": "assistant", "timestamp": ts,
+            "message": {
+                "id": "msg-1", "model": "claude-sonnet-4-6", "content": [],
+                "usage": {"input_tokens": 10, "output_tokens": 5},
+                "stop_reason": "end_turn",
+            },
+        }
+
+    def test_claude_summary_prefers_custom_title_record_over_prompt_heuristic(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
+             "message": {"content": "What does this function do?"}},
+            self.claude_usage_row(),
+            {"type": "custom-title", "customTitle": "release-triage",
+             "sessionId": "session"},
+        ]
+        row = meter.claude_summary(self.claude_source_without_title(), objs)
+        self.assertEqual(row["title"], "release-triage")
+        self.assertEqual(row["session_name"], "release-triage")
+
+    def test_claude_summary_counts_loaded_and_used_skills_and_mcp_servers(self):
+        usage = self.claude_usage_row()
+        usage["message"]["content"] = [
+            {"type": "tool_use", "id": "t1", "name": "Skill", "input": {"skill": "brainstorming"}},
+            {"type": "tool_use", "id": "t2", "name": "mcp__context7__query-docs", "input": {}},
+            {"type": "tool_use", "id": "t3", "name": "mcp__webex__webex_rooms", "input": {}},
+        ]
+        objs = [
+            {"type": "attachment", "attachment": {
+                "type": "skill_listing", "isInitial": True, "skillCount": 3,
+                "names": ["brainstorming", "pdf", "docx"],
+                "content": "PRIVATE SKILL LISTING TEXT"}},
+            {"type": "attachment", "attachment": {
+                "type": "deferred_tools_delta", "addedLines": ["PRIVATE LINE"],
+                "addedNames": ["CronCreate", "mcp__context7__query-docs",
+                               "mcp__context7__resolve-library-id", "mcp__outlook__outlook_send"],
+                "removedNames": []}},
+            {"type": "attachment", "attachment": {
+                "type": "mcp_instructions_delta", "addedNames": ["context7"],
+                "addedBlocks": ["PRIVATE INSTRUCTIONS"], "removedNames": []}},
+            usage,
+        ]
+        row = meter.claude_summary(self.claude_source_without_title(), objs)
+        self.assertEqual(row["capabilities"], {
+            "skills": {"loaded": 3, "used": 1},
+            "mcp_servers": {"loaded": 3, "used": 2},
+        })
+        self.assertNotIn("PRIVATE", json.dumps(row["capabilities"]))
+        self.assertNotIn("PRIVATE", json.dumps(
+            {k: v for k, v in row.items() if not k.startswith("_")}, default=str,
+        ))
+
+    def test_claude_session_state_counts_capabilities_from_main_trace(self):
+        usage = self.claude_usage_row()
+        usage["message"]["content"] = [
+            {"type": "tool_use", "id": "t1", "name": "mcp__docs__search", "input": {}},
+        ]
+        records = [
+            {"type": "attachment", "attachment": {
+                "type": "skill_listing", "names": ["pdf", "docx"], "content": "PRIVATE"}},
+            {"type": "attachment", "attachment": {
+                "type": "deferred_tools_delta", "addedNames": ["mcp__jira__get"]}},
+            usage,
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "claude-capabilities.jsonl"
+            path.write_text("".join(json.dumps(record) + "\n" for record in records))
+            state = meter.recompute_claude({
+                **self.source("claude"), "path": str(path), "session": path.name,
+            })
+        self.assertEqual(state["capabilities"], {
+            "skills": {"loaded": 2, "used": 0, "basis": "session"},
+            "mcp_servers": {"loaded": 2, "used": 1, "basis": "session"},
+        })
+        self.assertNotIn("PRIVATE", json.dumps(meter.dashboard_state_payload(state), default=str))
+
+    def test_codex_skill_listing_and_namespaced_mcp_calls_are_counted(self):
+        from token_meter.runtimes.codex import codex_mcp_tool_name, _loaded_skill_names
+        objs = [
+            {"type": "world_state", "payload": {"state": {"host_skills": {
+                "body": "- pdf: PRIVATE (file: /h/.codex/skills/pdf/SKILL.md)\n"
+                        "- docx: PRIVATE (file: /h/.codex/skills/docx/SKILL.md)"}}}},
+            {"type": "response_item", "payload": {"type": "message", "role": "developer", "content": [
+                {"type": "input_text", "text": "<skills_instructions>- xlsx (file: /p/skills/xlsx/SKILL.md)</skills_instructions>"},
+            ]}},
+        ]
+        self.assertEqual(_loaded_skill_names(objs, meter.skill_names_from_value), {"pdf", "docx", "xlsx"})
+        self.assertIsNone(_loaded_skill_names([], meter.skill_names_from_value))
+        self.assertEqual(codex_mcp_tool_name("js", "mcp__cua_repl"), "mcp__cua_repl__js")
+        self.assertEqual(codex_mcp_tool_name("exec", None), "exec")
+        calls = meter.codex_tool_call_evidence([{"timestamp": "2026-07-02T00:00:00Z", "payload": {
+            "type": "function_call", "name": "js", "namespace": "mcp__cua_repl", "call_id": "c1", "arguments": "{}",
+        }}])
+        self.assertEqual((calls[0]["kind"], calls[0]["namespace"]), ("mcp", "cua_repl"))
+
+    def test_configured_capabilities_fill_unrecorded_loads_with_label(self):
+        with mock.patch.object(meter, "configured_capabilities", return_value=({"a", "b", "c"}, set())):
+            result = meter.with_configured_capabilities({
+                "skills": {"loaded": None, "used": 1},
+                "mcp_servers": {"loaded": None, "used": 2},
+            }, "cursor", "/repo")
+        self.assertEqual(result, {
+            "skills": {"loaded": 3, "used": 1, "basis": "configured"},
+            "mcp_servers": {"loaded": 2, "used": 2, "basis": "configured"},
+        })
+        with mock.patch.object(meter, "configured_capabilities", return_value=(None, None)):
+            result = meter.with_configured_capabilities({
+                "skills": {"loaded": 9, "used": 1}, "mcp_servers": {"loaded": None, "used": 0},
+            }, "kiro", "")
+        self.assertEqual(result["skills"], {"loaded": 9, "used": 1, "basis": "session"})
+        self.assertEqual(result["mcp_servers"], {"loaded": None, "used": 0, "basis": "unavailable"})
+
+    def test_cursor_configured_capabilities_read_skill_dirs_and_mcp_json(self):
+        with tempfile.TemporaryDirectory() as home, tempfile.TemporaryDirectory() as project:
+            for root, name in (("skills", "pdf"), ("skills-cursor", "canvas")):
+                path = Path(home) / ".cursor" / root / name
+                path.mkdir(parents=True)
+                (path / "SKILL.md").write_text("x")
+            (Path(home) / ".cursor" / "mcp.json").write_text(json.dumps({"mcpServers": {"docs": {}, "jira": {}}}))
+            (Path(project) / ".cursor").mkdir()
+            (Path(project) / ".cursor" / "mcp.json").write_text(json.dumps({"mcpServers": {"local": {}}}))
+            with mock.patch.dict(os.environ, {"HOME": home}):
+                skills, servers = meter._scan_configured_capabilities("cursor", project)
+        self.assertEqual(skills, {"pdf", "canvas"})
+        self.assertEqual(servers, {"docs", "jira", "local"})
+
+    def test_claude_summary_without_load_records_keeps_loaded_unknown(self):
+        row = meter.claude_summary(self.claude_source_without_title(), [self.claude_usage_row()])
+        self.assertEqual(row["capabilities"], {
+            "skills": {"loaded": None, "used": 0},
+            "mcp_servers": {"loaded": None, "used": 0},
+        })
+
+    def test_session_capabilities_uses_codex_catalog_mcp_namespaces(self):
+        from token_meter.domain.tools import session_capabilities
+        evidence = {
+            "skills": [],
+            "tools": [{"name": "mcp__docs__search", "namespace": "docs", "kind": "mcp"}],
+            "catalog": [
+                {"name": "mcp__docs__search", "namespace": "docs", "kind": "mcp"},
+                {"name": "mcp__jira__get", "namespace": "jira", "kind": "mcp"},
+                {"name": "exec_command", "namespace": "shell", "kind": "tool"},
+            ],
+        }
+        self.assertEqual(session_capabilities(evidence), {
+            "skills": {"loaded": None, "used": 0},
+            "mcp_servers": {"loaded": 2, "used": 1},
+        })
+        self.assertEqual(session_capabilities({"catalog": [
+            {"name": "exec_command", "namespace": "shell", "kind": "tool"},
+        ]})["mcp_servers"], {"loaded": None, "used": 0})
+
+    def test_claude_summary_uses_ai_title_when_no_custom_title(self):
+        objs = [
+            self.claude_usage_row(),
+            {"type": "ai-title", "aiTitle": "Process codex reviews for issue #40",
+             "sessionId": "session"},
+        ]
+        row = meter.claude_summary(self.claude_source_without_title(), objs)
+        self.assertEqual(row["title"], "Process codex reviews for issue #40")
+        self.assertEqual(row["session_name"], "Process codex reviews for issue #40")
+
+    def test_claude_summary_desktop_title_outranks_custom_and_ai_title(self):
+        source = self.claude_source_without_title()
+        source["title"] = "Desktop sidecar title"
+        objs = [
+            self.claude_usage_row(),
+            {"type": "custom-title", "customTitle": "release-triage",
+             "sessionId": "session"},
+            {"type": "ai-title", "aiTitle": "Process codex reviews",
+             "sessionId": "session"},
+        ]
+        row = meter.claude_summary(source, objs)
+        self.assertEqual(row["title"], "Desktop sidecar title")
+        self.assertEqual(row["session_name"], "Desktop sidecar title")
+
+    def test_claude_summary_keeps_last_custom_title_when_multiple_records(self):
+        objs = [
+            self.claude_usage_row(),
+            {"type": "custom-title", "customTitle": "first-name",
+             "sessionId": "session"},
+            {"type": "custom-title", "customTitle": "second-name",
+             "sessionId": "session"},
+        ]
+        row = meter.claude_summary(self.claude_source_without_title(), objs)
+        self.assertEqual(row["title"], "second-name")
+        self.assertEqual(row["session_name"], "second-name")
+
+    def test_claude_summary_falls_back_to_untitled_when_no_declared_title_and_no_human_prompt(self):
+        objs = [
+            self.claude_usage_row(),
+            {"type": "user", "isMeta": True,
+             "timestamp": "2026-07-02T00:00:00.000Z",
+             "message": {"content": "Base directory for this skill: /Users/pat"}},
+        ]
+        row = meter.claude_summary(self.claude_source_without_title(), objs)
+        self.assertEqual(row["title"], "(untitled log)")
+        self.assertEqual(row["session_name"], "")
+
+    def test_claude_summary_prompt_fallback_title_does_not_populate_session_name(self):
+        objs = [
+            self.claude_usage_row(),
+            {"type": "user", "timestamp": "2026-07-02T00:00:00.000Z",
+             "message": {"content": "What does this function do?"}},
+        ]
+        row = meter.claude_summary(self.claude_source_without_title(), objs)
+        self.assertEqual(row["title"], "What does this function do?")
+        self.assertEqual(row["session_name"], "")
+
+    def test_codex_summary_carries_live_throughput_into_current_sessions(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-01T00:00:00.000Z",
+             "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 200, "output_tokens": 40, "total_tokens": 240,
+                }},
+            }},
+        ]
+
+        row = meter.codex_summary(self.source("codex", "gpt-5.6"), objs)
+
+        self.assertFalse(row["throughput"]["available"])
+        self.assertIn("live_throughput", row)
+        self.assertEqual(row["live_throughput"]["output_tps"], 10)
+        self.assertEqual(row["live_throughput"]["completed_steps"], 1)
+
+    def test_codex_summary_records_the_last_reply_not_later_bookkeeping(self):
+        import calendar
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-01T00:00:00.000Z", "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-01T00:00:04.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 200, "output_tokens": 40, "total_tokens": 240}}}},
+            # Resuming the session later writes context lines but no reply.
+            {"type": "turn_context", "timestamp": "2026-07-01T05:00:00.000Z", "payload": {"model": "gpt-5.6"}},
+        ]
+        row = meter.codex_summary(self.source("codex", "gpt-5.6"), objs)
+        self.assertEqual(row["last_activity_ts"], calendar.timegm((2026, 7, 1, 0, 0, 4)))
+        self.assertIsNone(meter.codex_summary(self.source("codex", "gpt-5.6"), objs[:1])["last_activity_ts"])
+
+    def test_codex_summary_keeps_missing_model_pricing_unavailable(self):
+        row = meter.codex_summary(self.source("codex"), [{
+            "timestamp": "2026-07-02T00:00:01.000Z",
+            "payload": {"type": "token_count", "info": {"last_token_usage": {
+                "input_tokens": 100_000, "output_tokens": 1_000,
+                "total_tokens": 101_000,
+            }}},
+        }])
+
+        self.assertEqual(row["primary_model"], "unknown-model")
+        self.assertFalse(row["availability"]["cost"])
+        self.assertEqual(row["cost"], 0.0)
+
+    def test_codex_summary_keeps_priced_model_coverage_in_mixed_session(self):
+        row = meter.codex_summary(self.source("codex", "gpt-5.6"), [
+            {"type": "turn_context", "timestamp": "2026-07-02T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-02T00:00:01.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100, "output_tokens": 20, "total_tokens": 120,
+                }},
+            }},
+            {"type": "turn_context", "timestamp": "2026-07-02T00:00:02.000Z",
+             "payload": {"model": "unknown-model"}},
+            {"timestamp": "2026-07-02T00:00:03.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100, "output_tokens": 30, "total_tokens": 130,
+                }},
+            }},
+        ])
+
+        self.assertFalse(row["availability"]["cost"])
+        stats = {item["model"]: item for item in row["model_stats"]}
+        self.assertTrue(stats["gpt-5.6"]["availability"]["cost"])
+        self.assertEqual(stats["gpt-5.6"]["cost_covered_executions"], 1)
+        self.assertEqual(stats["gpt-5.6"]["cost_covered_output_tokens"], 20)
+        self.assertFalse(stats["unknown-model"]["availability"]["cost"])
+        self.assertEqual(stats["unknown-model"]["cost_covered_executions"], 0)
+        daily = {item["model"]: item for item in row["_model_daily"]}
+        self.assertTrue(daily["gpt-5.6"]["availability"]["cost"])
+        self.assertFalse(daily["unknown-model"]["availability"]["cost"])
+
+        aggregate = {
+            item["model"]: item for item in meter.aggregate_model_stats([row])["models"]
+        }
+        self.assertTrue(aggregate["gpt-5.6"]["availability"]["cost"])
+        self.assertEqual(aggregate["gpt-5.6"]["cost_covered_executions"], 1)
+        self.assertEqual(aggregate["gpt-5.6"]["cost_covered_output_tokens"], 20)
+        self.assertTrue(aggregate["gpt-5.6"]["daily"][0]["availability"]["cost"])
+        self.assertEqual(
+            aggregate["gpt-5.6"]["daily"][0]["cost_covered_output_tokens"], 20,
+        )
+        self.assertFalse(aggregate["unknown-model"]["availability"]["cost"])
+
+    def test_codex_summary_exposes_input_output_and_model_stats(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-02T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6", "effort": "xhigh"}},
+            {"timestamp": "2026-07-02T00:00:00.500Z", "payload": {
+                "type": "task_started", "model_context_window": 200000,
+            }},
+            {"timestamp": "2026-07-02T00:00:01.000Z", "payload": {
+                "type": "token_count", "info": {"model_context_window": 200000,
+                                                "last_token_usage": {
+                    "input_tokens": 100, "cached_input_tokens": 40,
+                    "output_tokens": 20, "reasoning_output_tokens": 8,
+                    "total_tokens": 120,
+                }},
+            }},
+            {"timestamp": "2026-07-02T00:00:02.000Z", "payload": {
+                "type": "task_complete",
+            }},
+        ]
+        row = meter.codex_summary(self.source("codex", "gpt-5.6"), objs)
+        self.assertEqual(row["input_tokens"], 100)
+        self.assertEqual(row["output_tokens"], 20)
+        self.assertEqual(row["model_stats"][0]["model"], "gpt-5.6")
+        self.assertEqual(row["model_stats"][0]["tokens"], 120)
+        self.assertEqual(row["model_stats"][0]["reasoning_tokens"], 8)
+        self.assertEqual(row["model_stats"][0]["reasoning_output_tokens"], 20)
+        self.assertEqual(row["model_stats"][0]["reasoning_executions"], 1)
+        self.assertEqual(row["model_stats"][0]["reasoning_unavailable_executions"], 0)
+        self.assertEqual(row["primary_model"], "gpt-5.6")
+        self.assertEqual(row["reasoning_effort"], "xhigh")
+        self.assertEqual(row["session_name"], "Summary stats")
+        self.assertEqual(row["context"]["latest"], 100)
+        self.assertEqual(row["context"]["window"], 200000)
+        self.assertEqual(row["context"]["latest_pct"], 0.0005)
+        self.assertEqual(row["_context_samples"], [100])
+        self.assertTrue(row["terminal"])
+        self.assertEqual(row["usage_basis"], "reported")
+
+    def test_codex_summary_prices_each_usage_event_across_a_cutover(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-30T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6-terra"}},
+            {"timestamp": "2026-07-30T00:00:01.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100_000, "output_tokens": 100_000,
+                    "total_tokens": 200_000,
+                }},
+            }},
+            {"timestamp": "2026-07-31T00:00:00.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100_000, "output_tokens": 100_000,
+                    "total_tokens": 200_000,
+                }},
+            }},
+        ]
+        row = meter.codex_summary(self.source("codex", "gpt-5.6-terra"), objs)
+        self.assertAlmostEqual(row["cost"], 4.9)
+        self.assertEqual(len(row["_day_cost"]), 2)
+        for actual, expected in zip(sorted(row["_day_cost"].values()), (1.4, 3.5)):
+            self.assertAlmostEqual(actual, expected)
+        self.assertAlmostEqual(row["_model_cost"]["gpt-5.6-terra"], 4.9)
+
+
+class CurrentSessionSummaryTests(unittest.TestCase):
+    def row(self, session_id, mtime, **overrides):
+        row = {
+            "id": session_id,
+            "path": f"/private/traces/{session_id}.jsonl",
+            "title": f"private prompt for {session_id}",
+            "provider": "codex",
+            "client": "codex",
+            "runtime": "Codex",
+            "label": "Codex",
+            "project": "/Users/person/secret/repository",
+            "session_name": f"Session {session_id}",
+            "primary_model": "gpt-5.6",
+            "reasoning_effort": "xhigh",
+            "models": ["gpt-5.6"],
+            "cost": 1.25,
+            "cost_approx": True,
+            "availability": {"cost": True, "context": True},
+            "usage_basis": "reported",
+            "context": {
+                "latest": 50000, "window": 200000,
+                "latest_pct": 0.25, "estimated": False,
+            },
+            "_context_samples": [20000, 35000, 50000],
+            "turns": 3,
+            "mtime": mtime,
+            "terminal": False,
+            "throughput": {
+                "available": True, "output_tps": 24.5, "basis": "tool_free",
+            },
+        }
+        row.update(overrides)
+        return row
+
+    def test_opening_a_session_without_a_new_reply_does_not_make_it_live(self):
+        now = 50_000
+        opened = self.row("opened", now - 5, last_activity_ts=now - 3 * 3600)  # file touched, last reply hours ago
+        replying = self.row("replying", now - 5, last_activity_ts=now - 20)
+        quiet = self.row("quiet", now - 5, last_activity_ts=now - 600)
+        no_replies_yet = self.row("brand-new", now - 5)  # no reply recorded: the trace time still counts
+        result = {row["id"]: row for row in meter.current_session_summaries(
+            [opened, replying, quiet, no_replies_yet], now=now)}
+        self.assertNotIn("opened", result)
+        self.assertEqual(result["replying"]["activity_state"], "working")
+        self.assertEqual((result["quiet"]["activity_state"], result["quiet"]["idle_s"]), ("recent", 600))
+        self.assertIn("brand-new", result)
+
+    def test_filters_orders_limits_and_sanitizes_card_rows(self):
+        now = 10_000
+        rows = [
+            self.row(f"session-{index}", now - index * 10)
+            for index in range(10)
+        ]
+        rows.append(self.row("too-old", now - meter.CURRENT_SESSION_MAX_AGE_S - 1))
+        result = meter.current_session_summaries(rows, now=now)
+
+        self.assertEqual([row["id"] for row in result], [f"session-{index}" for index in range(10)])
+        self.assertEqual(result[0]["project"], "repository")
+        self.assertEqual(result[0]["session_name"], "Session session-0")
+        self.assertEqual(result[0]["reasoning_effort"], "xhigh")
+        self.assertEqual(result[0]["throughput"]["output_tps"], 24.5)
+        self.assertIsNone(result[0]["output_per_dollar"])
+        self.assertEqual(result[0]["context"]["samples"], [20000, 35000, 50000])
+        self.assertNotIn("_context_samples", result[0])
+        self.assertNotIn("path", result[0])
+        self.assertNotIn("title", result[0])
+        self.assertNotIn("private prompt", json.dumps(result))
+        self.assertNotIn("/Users/person", json.dumps(result))
+
+    def test_returns_every_live_session_up_to_the_payload_ceiling(self):
+        now = 10_000
+        rows = [
+            self.row(f"session-{index}", now - index)
+            for index in range(meter.CURRENT_SESSION_LIMIT + 5)
+        ]
+        result = meter.current_session_summaries(rows, now=now)
+
+        self.assertGreater(meter.CURRENT_SESSION_LIMIT, 8)
+        self.assertEqual(len(result), meter.CURRENT_SESSION_LIMIT)
+        self.assertEqual(result[0]["id"], "session-0")
+
+    def test_projects_output_per_covered_dollar_without_model_details(self):
+        row = self.row(
+            "mixed-coverage", 49_990,
+            availability={
+                "cost": False, "tokens": True, "output_tokens": True,
+                "context": True,
+            },
+            model_stats=[
+                {
+                    "model": "priced-model", "cost_covered_executions": 2,
+                    "cost_covered_output_tokens": 600,
+                    "cost_covered_cost": 2.0,
+                },
+                {
+                    "model": "unpriced-model", "cost_covered_executions": 0,
+                    "cost_covered_output_tokens": 0,
+                    "cost_covered_cost": 0.0,
+                },
+            ],
+        )
+
+        result = meter.current_session_summaries([row], now=50_000)[0]
+
+        self.assertEqual(result["output_per_dollar"], 300.0)
+        self.assertTrue(result["availability"]["output_per_dollar"])
+        self.assertNotIn("model_stats", result)
+        self.assertNotIn("priced-model", json.dumps(result))
+
+    def test_projects_only_valid_claude_desktop_resume_ids(self):
+        resumable = self.row("resumable", 49_990)
+        resumable["desktop_resume_id"] = "0f9f0062-51be-4131-acfa-51034ef23f99"
+        forged = self.row("forged", 49_980)
+        forged["desktop_resume_id"] = "0f9f0062-51be-4131-acfa-51034ef23f99&q=x"
+        plain = self.row("plain", 49_970)
+        results = {
+            row["id"]: row
+            for row in meter.current_session_summaries([resumable, forged, plain], now=50_000)
+        }
+        self.assertEqual(results["resumable"]["desktop_resume_id"], "0f9f0062-51be-4131-acfa-51034ef23f99")
+        self.assertIsNone(results["forged"]["desktop_resume_id"])
+        self.assertIsNone(results["plain"]["desktop_resume_id"])
+
+    def test_projects_bounded_capability_counts_with_unknown_loads(self):
+        known = self.row("known", 49_990)
+        known["capabilities"] = {
+            "skills": {"loaded": 75, "used": 2, "names": ["private"]},
+            "mcp_servers": {"loaded": 20, "used": 1},
+        }
+        unknown = self.row("unknown", 49_980)
+        results = {row["id"]: row for row in meter.current_session_summaries([known, unknown], now=50_000)}
+        self.assertEqual(results["known"]["capabilities"], {
+            "skills": {"loaded": 75, "used": 2, "basis": "unavailable"},
+            "mcp_servers": {"loaded": 20, "used": 1, "basis": "unavailable"},
+        })
+        self.assertEqual(results["unknown"]["capabilities"], {
+            "skills": {"loaded": None, "used": 0, "basis": "unavailable"},
+            "mcp_servers": {"loaded": None, "used": 0, "basis": "unavailable"},
+        })
+
+    def test_output_per_dollar_requires_output_and_nonzero_cost_evidence(self):
+        rows = [
+            self.row(
+                "missing-output", 59_990, output_tokens=250,
+                availability={"cost": True, "output_tokens": False, "context": True},
+            ),
+            self.row(
+                "zero-cost", 59_980, cost=0.0, output_tokens=250,
+                availability={"cost": True, "output_tokens": True, "context": True},
+            ),
+            self.row(
+                "covered", 59_970, cost=2.0, output_tokens=250,
+                availability={"cost": True, "output_tokens": True, "context": True},
+            ),
+        ]
+
+        result = {
+            row["id"]: row
+            for row in meter.current_session_summaries(rows, now=60_000)
+        }
+
+        self.assertIsNone(result["missing-output"]["output_per_dollar"])
+        self.assertFalse(result["missing-output"]["availability"]["output_per_dollar"])
+        self.assertIsNone(result["zero-cost"]["output_per_dollar"])
+        self.assertFalse(result["zero-cost"]["availability"]["output_per_dollar"])
+        self.assertEqual(result["covered"]["output_per_dollar"], 125.0)
+        self.assertTrue(result["covered"]["availability"]["output_per_dollar"])
+
+    def test_uses_working_waiting_and_recent_activity_states(self):
+        now = 20_000
+        rows = [
+            self.row("working", now - 10, terminal=False),
+            self.row("waiting", now - 20, terminal=True),
+            self.row("recent", now - meter.CURRENT_SESSION_WORKING_S - 1, terminal=False),
+        ]
+        result = {
+            row["id"]: row
+            for row in meter.current_session_summaries(rows, now=now)
+        }
+        self.assertEqual(result["working"]["activity_state"], "working")
+        self.assertEqual(result["waiting"]["activity_state"], "waiting")
+        self.assertEqual(result["recent"]["activity_state"], "recent")
+        self.assertEqual(result["working"]["context"]["latest_pct"], 0.25)
+
+    def test_duplicate_session_segments_prefer_active_work(self):
+        now = 25_000
+        rows = [
+            self.row("resumed", now - 15, terminal=False, turns=8),
+            self.row("resumed", now - 5, terminal=True, turns=120),
+        ]
+        result = meter.current_session_summaries(rows, now=now)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["id"], "resumed")
+        self.assertEqual(result[0]["activity_state"], "working")
+        self.assertEqual(result[0]["turns"], 8)
+
+    def test_keeps_context_tokens_without_inventing_a_window(self):
+        row = self.row(
+            "claude-session", 29_990, provider="claude", client="claude_code",
+            runtime="Claude Code", context={
+                "latest": 118000, "window": None,
+                "latest_pct": None, "estimated": False,
+            },
+        )
+        result = meter.current_session_summaries([row], now=30_000)[0]
+        self.assertEqual(result["context"]["latest"], 118000)
+        self.assertIsNone(result["context"]["window"])
+        self.assertIsNone(result["context"]["latest_pct"])
+
+    def test_context_samples_are_numeric_recent_and_bounded(self):
+        row = self.row(
+            "long-session", 39_990,
+            _context_samples=[*range(40), "invalid", -1, None],
+        )
+        result = meter.current_session_summaries([row], now=40_000)[0]
+        self.assertEqual(len(result["context"]["samples"]),
+                         meter.CURRENT_SESSION_CONTEXT_SAMPLES)
+        self.assertEqual(result["context"]["samples"], list(range(8, 40)))
+        self.assertTrue(all(isinstance(value, int)
+                            for value in result["context"]["samples"]))
+
+
+class SelectedSessionStateCacheTests(unittest.TestCase):
+    def test_reuses_unchanged_state_and_recomputes_after_trace_append(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_text('{"type":"session_meta"}\n')
+            source = {
+                "provider": "codex", "id": "session", "path": str(path),
+                "mtime": path.stat().st_mtime,
+            }
+            meter._session_state_cache.clear()
+            calls = []
+
+            def build(_source):
+                calls.append(len(calls) + 1)
+                return {"source": {"id": "session"}, "version": calls[-1]}
+
+            try:
+                with mock.patch.object(meter, "recompute", side_effect=build):
+                    first = meter.cached_session_state(source)
+                    first["version"] = 99
+                    second = meter.cached_session_state(source)
+                    path.write_text(path.read_text() + '{"type":"event"}\n')
+                    third = meter.cached_session_state(source)
+            finally:
+                meter._session_state_cache.clear()
+
+        self.assertEqual(calls, [1, 2])
+        self.assertEqual(second["version"], 1)
+        self.assertEqual(third["version"], 2)
+
+    def test_concurrent_misses_share_one_recompute(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_text('{"type":"session_meta"}\n')
+            source = {
+                "provider": "codex", "id": "session", "path": str(path),
+                "mtime": path.stat().st_mtime,
+            }
+            meter._session_state_cache.clear()
+            calls = []
+            started = threading.Event()
+            release = threading.Event()
+
+            def build(_source):
+                calls.append(1)
+                started.set()
+                release.wait(5)
+                return {"source": {"id": "session"}}
+
+            results = []
+            try:
+                with mock.patch.object(meter, "recompute", side_effect=build):
+                    threads = [
+                        threading.Thread(
+                            target=lambda: results.append(meter.cached_session_state(source))
+                        )
+                        for _ in range(8)
+                    ]
+                    threads[0].start()
+                    started.wait(5)
+                    # A live transcript grows while later pollers queue.
+                    with path.open("a") as handle:
+                        handle.write('{"type":"event"}\n')
+                    for thread in threads[1:]:
+                        thread.start()
+                    time.sleep(0.2)
+                    release.set()
+                    for thread in threads:
+                        thread.join(5)
+            finally:
+                meter._session_state_cache.clear()
+                meter._session_state_build_locks.clear()
+
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(results, [{"source": {"id": "session"}}] * 8)
+
+
+class SessionRouteTests(unittest.TestCase):
+    def test_dashboard_accepts_root_and_unique_session_paths(self):
+        self.assertTrue(meter.is_dashboard_page_path("/"))
+        self.assertTrue(meter.is_dashboard_page_path("/sessions/019f16fa-dc6c-7a62-839c-25c15dca4e75"))
+        self.assertTrue(meter.is_dashboard_page_path("/sessions/claude%20session/"))
+
+    def test_dashboard_rejects_api_nested_and_empty_session_paths(self):
+        self.assertFalse(meter.is_dashboard_page_path("/session"))
+        self.assertFalse(meter.is_dashboard_page_path("/sessions/"))
+        self.assertFalse(meter.is_dashboard_page_path("/sessions/one/two"))
+
+    def test_dashboard_serves_only_explicitly_bundled_assets(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            page = root / "page.html"
+            font = root / "assets" / "fonts" / "Tektur-Variable.ttf"
+            logo = root / "assets" / "brand" / "logo-splunk-by-cisco-rgb-w.png"
+            effects = root / "assets" / "session-effects.js"
+            dithering = root / "assets" / "vendor" / "paper-shaders" / "shaders" / "dithering.js"
+            pulsing_border = root / "assets" / "vendor" / "paper-shaders" / "shaders" / "pulsing-border.js"
+            font.parent.mkdir(parents=True)
+            logo.parent.mkdir(parents=True)
+            effects.parent.mkdir(parents=True, exist_ok=True)
+            dithering.parent.mkdir(parents=True)
+            page.write_text("dashboard")
+            font.write_bytes(b"font")
+            logo.write_bytes(b"logo")
+            effects.write_text("export {}")
+            dithering.write_text("export {}")
+            pulsing_border.write_text("export {}")
+            with mock.patch.object(meter, "page_path", return_value=str(page)):
+                self.assertEqual(
+                    meter.dashboard_asset_path("/assets/fonts/Tektur-Variable.ttf"),
+                    str(font),
+                )
+                self.assertEqual(
+                    meter.dashboard_asset_path("/assets/brand/logo-splunk-by-cisco-rgb-w.png"),
+                    str(logo),
+                )
+                self.assertEqual(
+                    meter.dashboard_asset_content_type("/assets/fonts/Tektur-Variable.ttf"),
+                    "font/ttf",
+                )
+                self.assertEqual(
+                    meter.dashboard_asset_content_type("/assets/brand/logo-splunk-by-cisco-rgb-w.png"),
+                    "image/png",
+                )
+                self.assertEqual(
+                    meter.dashboard_asset_path("/assets/session-effects.js"),
+                    str(effects),
+                )
+                self.assertIsNone(meter.dashboard_asset_path(
+                    "/assets/vendor/paper-shaders/shaders/dithering.js"
+                ))
+                self.assertEqual(
+                    meter.dashboard_asset_path(
+                        "/assets/vendor/paper-shaders/shaders/pulsing-border.js"
+                    ),
+                    str(pulsing_border),
+                )
+                self.assertEqual(
+                    meter.dashboard_asset_content_type("/assets/session-effects.js"),
+                    "text/javascript; charset=utf-8",
+                )
+                self.assertIsNone(meter.dashboard_asset_path("/assets/fonts/OFL-Tektur.txt"))
+                self.assertIsNone(meter.dashboard_asset_path("/assets/brand/SOURCE.md"))
+                self.assertIsNone(meter.dashboard_asset_path(
+                    "/assets/vendor/paper-shaders/shaders/neuro-noise.js"
+                ))
+                self.assertIsNone(meter.dashboard_asset_path(
+                    "/assets/vendor/paper-shaders/shaders/god-rays.js"
+                ))
+                self.assertIsNone(meter.dashboard_asset_path("/assets/../meter.py"))
+
+
+class SessionTraceKeyProjectionTests(unittest.TestCase):
+    def test_spend_logs_and_current_sessions_carry_the_trace_key(self):
+        rows = [
+            {"id": "task-1", "session": "rollout-a.jsonl", "provider": "codex",
+             "_day_cost": {"2026-08-11": 2.0}, "mtime": 990, "turns": 1},
+            {"id": "task-1", "session": "rollout-b.jsonl", "provider": "codex",
+             "_day_cost": {"2026-08-11": 3.0}, "mtime": 995, "turns": 1},
+        ]
+        spend = meter.spend_log_summaries(rows, "2026-08-01", "2026-08-31")
+        self.assertEqual(
+            sorted(row["session"] for row in spend),
+            ["rollout-a.jsonl", "rollout-b.jsonl"],
+        )
+        current = meter.current_session_summaries(rows, now=1000)
+        self.assertEqual([row["session"] for row in current], ["rollout-b.jsonl"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_trace_parsing.py b/tests/test_trace_parsing.py
new file mode 100644
index 00000000..721d6086
--- /dev/null
+++ b/tests/test_trace_parsing.py
@@ -0,0 +1,999 @@
+import unittest
+import json
+import os
+import sqlite3
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class LegacyJsonlLoadTests(unittest.TestCase):
+    def test_load_skips_corrupt_bytes_truncated_rows_and_non_objects(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            path.write_bytes(
+                b'{"type":"user","value":1}\n'
+                b'\xff\n'
+                b'[]\n'
+                b'"text"\n'
+                b'42\n'
+                b'null\n'
+                b'{"type":"assistant","value":2}\n'
+                b'{"truncated":\n'
+            )
+
+            rows = meter.load(str(path))
+
+        self.assertEqual(rows, [
+            {"type": "user", "value": 1},
+            {"type": "assistant", "value": 2},
+        ])
+
+    def test_load_returns_empty_when_the_trace_cannot_be_opened(self):
+        with mock.patch("builtins.open", side_effect=PermissionError("denied")):
+            self.assertEqual(meter.load("/unreadable/session.jsonl"), [])
+
+
+class SourceDiscoveryCacheTests(unittest.TestCase):
+    def test_codex_metadata_prefix_is_reused_after_large_trace_append(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            rows = [
+                {
+                    "type": "session_meta",
+                    "payload": {"id": "session", "cwd": "/repo"},
+                },
+                {
+                    "type": "turn_context",
+                    "payload": {"model": "gpt-stable"},
+                },
+            ]
+            rows.extend({"type": "event", "payload": {"index": idx}}
+                        for idx in range(121))
+            path.write_text("".join(json.dumps(row) + "\n" for row in rows))
+
+            with mock.patch.object(meter, "_codex_native_adapters", {}):
+                first = meter.codex_meta(str(path))
+                with path.open("a", encoding="utf-8") as handle:
+                    handle.write(json.dumps({"type": "event", "payload": {}}) + "\n")
+                with mock.patch(
+                    "builtins.open",
+                    side_effect=AssertionError(
+                        "append-only growth must reuse the completed metadata prefix"
+                    ),
+                ):
+                    second = meter.codex_meta(str(path))
+
+        self.assertEqual(first, second)
+        self.assertEqual(second["model"], "gpt-stable")
+
+    def test_codex_metadata_is_reused_until_the_trace_changes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "session.jsonl"
+            session_meta = {
+                "type": "session_meta",
+                "payload": {"id": "session", "cwd": "/repo"},
+            }
+            first_turn = {
+                "type": "turn_context",
+                "payload": {"model": "gpt-first"},
+            }
+            path.write_text(
+                json.dumps(session_meta) + "\n" + json.dumps(first_turn) + "\n"
+            )
+            with mock.patch.object(meter, "_codex_native_adapters", {}):
+                first = meter.codex_meta(str(path))
+                with mock.patch(
+                    "builtins.open",
+                    side_effect=AssertionError("unchanged metadata should come from cache"),
+                ):
+                    second = meter.codex_meta(str(path))
+
+                second_turn = {
+                    "type": "turn_context",
+                    "payload": {"model": "gpt-second"},
+                }
+                path.write_text(
+                    json.dumps(session_meta) + "\n" + json.dumps(second_turn) + "\n"
+                )
+                third = meter.codex_meta(str(path))
+
+        self.assertEqual(first["model"], "gpt-first")
+        self.assertEqual(second["model"], "gpt-first")
+        self.assertEqual(third["model"], "gpt-second")
+
+    def test_codex_index_rename_refreshes_cached_session_name_without_trace_change(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            sessions = root / "sessions"
+            trace = sessions / "2026" / "08" / "10" / "session.jsonl"
+            trace.parent.mkdir(parents=True)
+            session_id = "codex-session"
+            trace.write_text(json.dumps({
+                "type": "session_meta",
+                "timestamp": "2026-08-10T10:00:00Z",
+                "payload": {"id": session_id, "cwd": "/repo"},
+            }) + "\n")
+            os.utime(trace, (1_784_548_800, 1_784_548_800))
+            index = root / "session_index.jsonl"
+            index.write_text(json.dumps({
+                "id": session_id, "thread_name": "Review token-meter PR 14",
+            }) + "\n")
+            empty_summary_cache = {}
+            with mock.patch.object(meter, "CODEX_SESSIONS", str(sessions)), \
+                    mock.patch.object(meter, "CODEX_INDEX", str(index)), \
+                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
+                    mock.patch.object(meter, "CURSOR_PROJECTS", str(root / "no-cursor")), \
+                    mock.patch.object(meter, "OPENCODE_DB", str(root / "no-opencode.db")), \
+                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
+                    mock.patch.object(meter, "claude_desktop_index", return_value={}), \
+                    mock.patch.object(meter, "_summary_cache", empty_summary_cache):
+                first_source = meter.all_session_sources()[0]
+                first_signature = meter.source_mtime_signature([first_source])
+                first_state_signature = meter.session_state_signature(first_source)
+                first_summary = meter.session_summary(first_source)
+                with index.open("a", encoding="utf-8") as fh:
+                    fh.write(json.dumps({
+                        "id": session_id, "thread_name": "Review token-meter PR 14 (2)",
+                    }) + "\n")
+                second_source = meter.all_session_sources()[0]
+                second_signature = meter.source_mtime_signature([second_source])
+                second_state_signature = meter.session_state_signature(second_source)
+                second_summary = meter.session_summary(second_source)
+
+        self.assertEqual(first_source["mtime"], second_source["mtime"])
+        self.assertEqual(first_summary["session_name"], "Review token-meter PR 14")
+        self.assertEqual(second_source["title"], "Review token-meter PR 14 (2)")
+        self.assertNotEqual(first_signature, second_signature)
+        self.assertNotEqual(first_state_signature, second_state_signature)
+        self.assertEqual(second_summary["session_name"], "Review token-meter PR 14 (2)")
+
+    def test_shared_path_cache_retains_one_complete_adapter_pattern_set(self):
+        cache = meter._recursive_path_cache
+        cache.clear()
+        try:
+            with mock.patch("glob.glob", return_value=[]):
+                for index in range(37):
+                    cache.paths(f"/nonexistent/runtime-pattern-{index}/*", now=1.0)
+            self.assertEqual(cache.entry_count, 37)
+        finally:
+            cache.clear()
+
+
+class CursorTraceTests(unittest.TestCase):
+    def source(self, path="/tmp/cursor-session.jsonl", session_id="cursor-session"):
+        return {
+            "provider": "cursor", "client": "cursor", "label": "Cursor",
+            "runtime": "Cursor", "id": session_id,
+            "session": Path(path).name, "path": path, "project": "/repo",
+            "mtime": 1, "title": "Cursor run", "model": "composer-2.5",
+        }
+
+    def snapshot(self):
+        base_ms = 1_784_548_800_000
+        return {
+            "available": True,
+            "header": {"name": "Cursor run"},
+            "composer": {
+                "modelConfig": {
+                    "modelName": "composer-2.5",
+                    "selectedModels": [{"modelId": "composer-2.5", "parameters": [
+                        {"id": "fast", "value": "true"},
+                    ]}],
+                },
+                "contextTokensUsed": 80448,
+                "contextTokenLimit": 200000,
+                "promptTokenBreakdown": {"categories": [
+                    {"id": "rules", "label": "Rules", "estimatedTokens": 1234},
+                ]},
+            },
+            "bubbles": [
+                {"type": 1, "bubbleId": "user-1", "createdAt": base_ms,
+                 "text": "inspect the repository", "requestId": "request-1",
+                 "modelInfo": {"modelName": "composer-2.5"},
+                 "contextWindowStatusAtCreation": {"tokensUsed": 78000, "tokenLimit": 200000}},
+                {"type": 2, "bubbleId": "assistant-1", "createdAt": base_ms + 46000,
+                 "thinking": "trace-visible", "thinkingDurationMs": 3200,
+                 "toolFormerData": {
+                     "name": "ripgrep_raw_search", "toolCallId": "tool-1",
+                     "params": {"query": "needle"}, "additionalData": {"lines": "x" * 80},
+                     "status": "error",
+                 },
+                 "text": "finished", "turnDurationMs": 46624},
+            ],
+        }
+
+    def spans(self):
+        base = 1_784_548_800.0
+        return [
+            {"name": "client.ttft", "start_ts": base, "end_ts": base + 4.118,
+             "duration_s": 4.118, "request_id": "request-1", "error": False},
+            {"name": "agent.request.attempt", "start_ts": base, "end_ts": base + 20,
+             "duration_s": 20, "request_id": "attempt-1", "error": True},
+            {"name": "agent.request.attempt", "start_ts": base + 21, "end_ts": base + 46,
+             "duration_s": 25, "request_id": "attempt-2", "error": False},
+            {"name": "ComposerChatService.submitChatMaybeAbortCurrent", "start_ts": base,
+             "end_ts": base + 46.624, "duration_s": 46.624,
+             "request_id": "request-1", "error": False},
+        ]
+
+    def test_cursor_discovery_uses_sqlite_metadata_and_keeps_activity_order_session_specific(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            projects = root / "projects"
+            db_path = root / "state.vscdb"
+            logs = root / "logs"
+            logs.mkdir()
+            conn = sqlite3.connect(db_path)
+            conn.execute("CREATE TABLE composerHeaders (composerId TEXT, workspaceId TEXT, createdAt INTEGER, lastUpdatedAt INTEGER, isArchived INTEGER, isSubagent INTEGER, checkpointAt INTEGER, value TEXT)")
+            conn.execute("CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value TEXT)")
+            rows = [
+                ("older", 1_784_548_800_000, 0, "gpt-5.6-sol"),
+                ("newer", 1_784_548_900_000, 0, "composer-2.5"),
+                ("child", 1_784_549_000_000, 1, "composer-2.5"),
+            ]
+            for sid, updated, subagent, model in rows:
+                header = {"name": sid.title(), "workspaceIdentifier": {"uri": {"fsPath": "/repo"}}}
+                if subagent:
+                    header["subagentInfo"] = {
+                        "parentComposerId": "newer", "subagentTypeName": "explore",
+                    }
+                composer = {"modelConfig": {"modelName": model}}
+                conn.execute("INSERT INTO composerHeaders VALUES (?, ?, ?, ?, 0, ?, 0, ?)",
+                             (sid, "workspace", updated - 1000, updated, subagent, json.dumps(header)))
+                conn.execute("INSERT INTO cursorDiskKV VALUES (?, ?)",
+                             (f"composerData:{sid}", json.dumps(composer)))
+                trace_dir = projects / "Users-test-repo" / "agent-transcripts" / sid
+                trace_dir.mkdir(parents=True)
+                transcript = trace_dir / f"{sid}.jsonl"
+                transcript.write_text(json.dumps({"role": "user"}) + "\n")
+                os.utime(transcript, (updated / 1000, updated / 1000))
+            nested = (projects / "Users-test-repo" / "agent-transcripts" / "newer" /
+                      "subagents" / "nested.jsonl")
+            nested.parent.mkdir(parents=True)
+            nested.write_text(json.dumps({"role": "user"}) + "\n")
+            os.utime(nested, (1_784_548_000, 1_784_548_000))
+            duplicate = projects / "empty-window" / "agent-transcripts" / "newer" / "newer.jsonl"
+            duplicate.parent.mkdir(parents=True)
+            duplicate.write_text(json.dumps({"role": "user", "replica": "newest"}) + "\n")
+            os.utime(duplicate, (1_784_551_000, 1_784_551_000))
+            conn.commit()
+            conn.close()
+            request_log = logs / "cursor.requestTraces.log"
+            request_log.write_text(
+                "2026-07-20T10:00:01Z span_completed name=client.ttft "
+                "composerId=newer durationMs=100 requestId=r1 traceId=t1 error=false\n"
+            )
+            os.utime(request_log, (1_784_550_000, 1_784_550_000))
+            with mock.patch.object(meter, "CURSOR_PROJECTS", str(projects)), \
+                    mock.patch.object(meter, "CURSOR_STATE_DB", str(db_path)), \
+                    mock.patch.object(meter, "CURSOR_REQUEST_LOGS", str(logs)), \
+                    mock.patch.object(meter, "OPENCODE_DB", str(root / "no-opencode.db")), \
+                    mock.patch.object(meter, "CLAUDE_PROJECTS", str(root / "no-claude")), \
+                    mock.patch.object(meter, "CODEX_SESSIONS", str(root / "no-codex")), \
+                    mock.patch.object(meter, "CODEX_INDEX", str(root / "no-index")), \
+                    mock.patch.object(meter, "KIRO_SESSIONS", str(root / "no-kiro")), \
+                    mock.patch.object(meter, "KIRO_AGENT_STORAGE", str(root / "no-kiro-agent")), \
+                    mock.patch.object(meter, "PI_AGENT_DIR", str(root / "no-pi-agent")), \
+                    mock.patch.object(meter, "HERMES_STATE_DB", str(root / "no-hermes.db")), \
+                    mock.patch.object(meter, "AGY_BRAIN_DIR", str(root / "no-agy-brain")), \
+                    mock.patch.object(meter, "CLAUDE_DESKTOP_DATA_ROOTS", []), \
+                    mock.patch.object(meter, "claude_desktop_index", return_value={}):
+                sources = meter.all_session_sources()
+            self.assertEqual({row["id"] for row in sources}, {"older", "newer", "child", "nested"})
+            self.assertEqual(len(sources), 4)
+            by_id = {row["id"]: row for row in sources}
+            parent_agent = meter.cursor_agent_id("newer")
+            self.assertEqual(by_id["newer"]["agent_kind"], "root")
+            self.assertEqual(by_id["newer"]["agent_id"], parent_agent)
+            self.assertIsNone(by_id["newer"]["agent_parent_id"])
+            self.assertEqual(by_id["child"]["agent_kind"], "spawned")
+            self.assertEqual(by_id["child"]["agent_parent_id"], parent_agent)
+            self.assertEqual(by_id["child"]["agent_role"], "explore")
+            self.assertEqual(by_id["nested"]["agent_kind"], "spawned")
+            self.assertEqual(by_id["nested"]["agent_parent_id"], parent_agent)
+            self.assertTrue(by_id["nested"]["project"].endswith("test/repo"))
+            self.assertNotIn("newer", by_id["newer"]["agent_id"])
+            self.assertEqual(max(sources, key=lambda row: row["mtime"])["id"], "newer")
+            newer = next(row for row in sources if row["id"] == "newer")
+            self.assertEqual(newer["path"], str(duplicate))
+            self.assertEqual(newer["model"], "composer-2.5")
+            self.assertEqual(newer["project"], "/repo")
+            self.assertEqual(newer["signature_mtime"], newer["mtime"])
+            self.assertTrue(newer["request_revision"])
+
+    def test_cursor_forked_subagent_skips_inherited_bubbles_and_joins_parent_group(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            db_path = Path(tmp) / "state.vscdb"
+            conn = sqlite3.connect(db_path)
+            conn.execute("CREATE TABLE composerHeaders (composerId TEXT, workspaceId TEXT, createdAt INTEGER, lastUpdatedAt INTEGER, isArchived INTEGER, isSubagent INTEGER, checkpointAt INTEGER, value TEXT)")
+            conn.execute("CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value TEXT)")
+            base_ms = 1_784_548_800_000
+
+            def bubble(sid, bid, kind, offset, text):
+                conn.execute("INSERT INTO cursorDiskKV VALUES (?, ?)", (
+                    f"bubbleId:{sid}:{bid}", json.dumps({
+                        "type": kind, "bubbleId": bid, "createdAt": base_ms + offset,
+                        "text": text, "modelInfo": {"modelName": "gpt-5.6-sol"},
+                        **({"turnDurationMs": 1000} if kind == 2 else {}),
+                    })))
+
+            shared = [("u1", 1, 0, "parent ask"), ("a1", 2, 1000, "p" * 400)]
+            for sid, header, own in (
+                ("parent", {}, []),
+                ("fork", {"subagentInfo": {
+                    "parentComposerId": "parent", "forkedFromComposerId": "parent",
+                    "conversationLengthAtSpawn": 2, "subagentTypeName": "generalPurpose",
+                }}, [("u2", 1, 5000, "child ask"), ("a2", 2, 6000, "c" * 40)]),
+            ):
+                rows = shared + own
+                for bid, kind, offset, text in rows:
+                    bubble(sid, bid, kind, offset, text)
+                conn.execute("INSERT INTO composerHeaders VALUES (?, 'w', ?, ?, 0, ?, 0, ?)", (
+                    sid, base_ms, base_ms + 7000, 1 if own else 0, json.dumps(header)))
+                conn.execute("INSERT INTO cursorDiskKV VALUES (?, ?)", (
+                    f"composerData:{sid}", json.dumps({
+                        "modelConfig": {"modelName": "gpt-5.6-sol"},
+                        "contextTokensUsed": 1000,
+                        "fullConversationHeadersOnly": [{"bubbleId": row[0]} for row in rows],
+                    })))
+            conn.commit()
+            conn.close()
+            adapter = meter._cursor_adapter_for(
+                projects_root=str(Path(tmp) / "projects"), database_path=str(db_path),
+                request_logs=str(Path(tmp) / "logs"),
+            )
+            fork = adapter.snapshot("fork")
+            self.assertEqual([item["bubbleId"] for item in fork["bubbles"]], ["u2", "a2"])
+            conn = sqlite3.connect(db_path)
+            conn.execute("UPDATE cursorDiskKV SET value=? WHERE key='composerData:parent'", (
+                json.dumps({"fullConversationHeadersOnly": [{"bubbleId": "u1"}, {"bubbleId": "other"}]}),))
+            conn.commit()
+            conn.close()
+            adapter.reset_metadata_cache()
+            partial = adapter.snapshot("fork")
+            self.assertEqual([item["bubbleId"] for item in partial["bubbles"]], ["a1", "u2", "a2"])
+            conn = sqlite3.connect(db_path)
+            conn.execute("UPDATE cursorDiskKV SET value=? WHERE key='composerData:parent'", (
+                json.dumps({"fullConversationHeadersOnly": [{"bubbleId": "u1"}, {"bubbleId": "a1"}]}),))
+            conn.commit()
+            conn.close()
+
+            parent_source = {**self.source("/tmp/parent.jsonl", "parent"),
+                             "agent_id": meter.cursor_agent_id("parent"),
+                             "agent_kind": "root", "agent_parent_id": None, "agent_role": ""}
+            fork_source = {**self.source("/tmp/fork.jsonl", "fork"),
+                           "agent_id": meter.cursor_agent_id("fork"), "agent_kind": "spawned",
+                           "agent_parent_id": meter.cursor_agent_id("parent"),
+                           "agent_role": "generalPurpose"}
+            with mock.patch.object(meter, "cursor_snapshot", side_effect=adapter.snapshot_legacy), \
+                    mock.patch.object(meter, "cursor_request_spans", return_value=[]), \
+                    mock.patch.object(meter, "load", return_value=[]):
+                rows = [adapter.summarize_legacy(parent_source),
+                        adapter.summarize_legacy(fork_source)]
+        fork_record = rows[1]["_agent_records"][0]
+        self.assertEqual(fork_record["output_tokens"], 10)
+        self.assertEqual(fork_record["role"], "generalPurpose")
+        self.assertEqual(fork_record["session_id"], "fork")
+        self.assertEqual(fork_record["activity_state"], "complete")
+        groups = meter._domain_build_agent_groups(rows)
+        self.assertEqual(len(groups), 1)
+        self.assertEqual(groups[0]["root_session_id"], "parent")
+        self.assertEqual(groups[0]["coverage"]["relationships"], "complete")
+        self.assertEqual([agent["kind"] for agent in groups[0]["agents"]], ["root", "spawned"])
+        self.assertEqual(groups[0]["child_totals"]["tokens"], 1010)
+
+    def test_cursor_recompute_exposes_context_tools_reasoning_wait_ttft_and_retries(self):
+        with mock.patch.object(meter, "cursor_snapshot", return_value=self.snapshot()), \
+                mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
+            state = meter.recompute_cursor(self.source())
+        self.assertEqual(state["provider"], "cursor")
+        self.assertEqual(state["primary_model"], "composer-2.5")
+        self.assertEqual(state["context"]["latest"], 80448)
+        self.assertEqual(state["context"]["window"], 200000)
+        self.assertTrue(state["context"]["estimated"])
+        self.assertEqual(state["context"]["breakdown"][0]["estimated_tokens"], 1234)
+        self.assertTrue(state["availability"]["cost"])
+        self.assertTrue(state["availability"]["tokens"])
+        self.assertFalse(state["availability"]["cache"])
+        self.assertTrue(state["availability"]["throughput"])
+        self.assertTrue(state["availability"]["context"])
+        self.assertTrue(state["availability"]["timing"])
+        self.assertTrue(state["availability"]["tool_results"])
+        execution = state["executions"][0]
+        self.assertEqual(execution["tools"][0]["name"], "ripgrep_raw_search")
+        self.assertTrue(execution["tools"][0]["error"])
+        self.assertGreater(execution["tokens"]["retrieval"], 0)
+        self.assertAlmostEqual(execution["wait_duration_ms"], 46624, places=3)
+        self.assertAlmostEqual(execution["ttft_ms"], 4118, places=3)
+        self.assertEqual((execution["attempts"], execution["failed_attempts"], execution["retries"]),
+                         (2, 1, 1))
+        self.assertEqual(execution["reasoning_duration_ms"], 3200)
+        self.assertEqual(execution["reasoning_tokens"], 4)
+        self.assertEqual(execution["tokens"]["input"], 80448)
+        self.assertEqual(execution["tokens"]["output"], 6)
+        self.assertEqual(execution["pricing_variant"], "fast")
+        self.assertAlmostEqual(execution["cost"], 0.241434, places=6)
+        self.assertTrue(state["cost_approx"])
+        self.assertTrue(state["token_estimate"])
+
+    def test_cursor_turn_timing_attributes_each_span_to_the_turn_it_started_in(self):
+        base = 1_784_548_800.0
+        starts = [base, base + 76.5, base + 86.6]
+        spans = [
+            {"name": "agent.request.attempt", "start_ts": base + 0.2,
+             "end_ts": base + 76.6, "duration_s": 76.4, "request_id": "a", "error": False},
+            {"name": "agent.request.attempt", "start_ts": base + 76.7,
+             "end_ts": base + 101.6, "duration_s": 24.9, "request_id": "b", "error": False},
+            {"name": "agent.request.attempt", "start_ts": base + 84.1,
+             "end_ts": base + 90.0, "duration_s": 5.9, "request_id": "c", "error": False},
+        ]
+        timings = [
+            meter.cursor_turn_timing(
+                spans, start, starts[index + 1] if index + 1 < len(starts) else 0,
+                start + 1,
+            )
+            for index, start in enumerate(starts)
+        ]
+        self.assertEqual([round(item["active_s"], 1) for item in timings], [76.4, 24.9, 5.9])
+        self.assertEqual([item["attempts"] for item in timings], [1, 1, 1])
+        self.assertAlmostEqual(timings[1]["wait_s"], 25.1, places=3)
+        self.assertAlmostEqual(timings[2]["end_ts"], base + 90.0, places=3)
+
+        retry = {"name": "agent.request.attempt", "start_ts": base + 80.0,
+                 "end_ts": base + 82.0, "duration_s": 2.0, "request_id": "turn-a",
+                 "error": False}
+        claimed = frozenset(("turn-a", "turn-b"))
+        turn_a = meter.cursor_turn_timing(
+            [spans[0], retry], base, base + 10, base + 1,
+            request_id="turn-a", claimed_request_ids=claimed,
+        )
+        turn_b = meter.cursor_turn_timing(
+            [spans[0], retry], base + 10, 0, base + 11,
+            request_id="turn-b", claimed_request_ids=claimed,
+        )
+        self.assertEqual((turn_a["attempts"], turn_b["attempts"]), (2, 0))
+        self.assertAlmostEqual(turn_a["end_ts"], base + 82.0, places=3)
+
+    def test_cursor_tool_identity_classifies_orchestration_interaction_and_mcp_tools(self):
+        expected = {
+            "task_v2": ("Subagent", "orchestration", "tool"),
+            "update_current_step": ("Update step", "planning", "tool"),
+            "ask_question": ("Ask question", "interaction", "tool"),
+            "switch_mode": ("Switch mode", "interaction", "tool"),
+            "set_active_branch": ("Set branch", "workspace", "tool"),
+            "search_conversations": ("Search chats", "search", "tool"),
+            "get_mcp_tools": ("MCP tool lookup", "tool_search", "tool"),
+            "mcp-cursor-app-control-open_resource": (
+                "open_resource", "cursor-app-control", "mcp",
+            ),
+        }
+        for name, (display, namespace, kind) in expected.items():
+            with self.subTest(name=name):
+                ident = meter.cursor_tool_identity(name)
+                self.assertEqual(ident["name"], name)
+                self.assertEqual(
+                    (ident["display"], ident["namespace"], ident["kind"]),
+                    (display, namespace, kind),
+                )
+        self.assertEqual(meter.cursor_tool_identity("Read")["name"], "read_file_v2")
+        self.assertEqual(meter.cursor_tool_identity("mcp-")["kind"], "tool")
+
+    def test_cursor_transcript_fallback_survives_missing_database(self):
+        transcript = [
+            {"role": "user", "message": {"content": [{"type": "text", "text": "<user_query>hello</user_query>"}]}},
+            {"role": "assistant", "message": {"content": [
+                {"type": "tool_use", "id": "one", "name": "Read", "input": {"path": "README.md"}},
+                {"type": "text", "text": "done"},
+            ]}},
+            {"type": "turn_ended", "status": "success"},
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "fallback.jsonl"
+            path.write_text("".join(json.dumps(row) + "\n" for row in transcript))
+            with mock.patch.object(meter, "cursor_snapshot", return_value={"available": False}), \
+                    mock.patch.object(meter, "cursor_request_spans") as spans:
+                state = meter.recompute_cursor(self.source(str(path), "fallback"))
+        spans.assert_not_called()
+        self.assertEqual(state["turns"], 1)
+        self.assertTrue(state["cursor_enrichment"]["transcript_fallback"])
+        self.assertEqual(state["executions"][0]["tools"][0]["name"], "read_file_v2")
+        self.assertFalse(state["availability"]["tool_results"])
+
+    def test_cursor_pricing_uses_persisted_composer_variant_and_fails_closed_without_it(self):
+        price, approximate = meter.price_for("composer-2.5", "cursor")
+        self.assertEqual(price, meter.ZERO_PRICE)
+        self.assertTrue(approximate)
+        fast, approximate = meter.price_for("composer-2.5", "cursor", "fast")
+        standard, _ = meter.price_for("composer-2.5", "cursor", "standard")
+        self.assertEqual((fast["input"], fast["output"]), (3.0, 15.0))
+        self.assertEqual((standard["input"], standard["output"]), (0.5, 2.5))
+        self.assertTrue(approximate)
+        self.assertEqual(meter.cursor_price_variant(self.snapshot()["composer"], "composer-2.5"),
+                         "fast")
+
+    def test_cursor_subagent_prices_the_speed_its_parent_spawn_call_recorded(self):
+        def child():
+            data = self.snapshot()
+            data["header"]["subagentInfo"] = {"parentComposerId": "parent", "toolCallId": "spawn-1"}
+            data["composer"]["modelConfig"]["selectedModels"] = [{"modelId": "composer-2.5"}]
+            for bubble in data["bubbles"]:
+                bubble.pop("modelInfo", None)
+            return data
+
+        def parent(spawn_model, tool_call_id="spawn-1"):
+            return {"available": True, "header": {}, "composer": {}, "bubbles": [
+                {"type": 2, "bubbleId": "spawn", "toolFormerData": {
+                    "name": "task_v2", "toolCallId": tool_call_id,
+                    "params": json.dumps({"model": spawn_model, "prompt": "delegate"}),
+                }},
+            ]}
+
+        cases = (
+            ("composer-2.5-fast", "spawn-1", 3.0),
+            ("composer-2.5-standard", "spawn-1", 0.5),
+            ("composer-2.5", "spawn-1", None),
+            ("grok-4.6-fast", "spawn-1", None),
+            ("composer-2.5-fast", "other-call", None),
+        )
+        for spawn_model, tool_call_id, input_rate in cases:
+            with self.subTest(spawn_model=spawn_model, tool_call_id=tool_call_id):
+                snapshots = {"cursor-session": child(), "parent": parent(spawn_model, tool_call_id)}
+                with mock.patch.object(meter, "cursor_snapshot", side_effect=snapshots.__getitem__), \
+                        mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
+                    state = meter.recompute_cursor(self.source())
+                execution = state["executions"][0]
+                if input_rate is None:
+                    self.assertFalse(state["availability"]["cost"])
+                    self.assertEqual(execution["cost"], 0)
+                    continue
+                self.assertTrue(state["availability"]["cost"])
+                self.assertAlmostEqual(execution["cost_breakdown"]["input"], 80448 * input_rate / 1e6)
+
+    def test_cursor_pricing_uses_published_third_party_and_grok_rates(self):
+        after_sol_update = 1_788_000_000
+        cases = {
+            ("claude-opus-5-5", ""): (4.0, 5.0, 0.2, 20.0),
+            ("claude-opus-5-5-medium", ""): (4.0, 5.0, 0.2, 20.0),
+            ("gpt-5.6-sol", ""): (4.0, 5.0, 0.4, 20.0),
+            ("gpt-5.6-sol-xhigh", ""): (4.0, 5.0, 0.4, 20.0),
+            ("grok-4.7", "standard"): (2.0, 0.0, 0.5, 6.0),
+            ("grok-4.7", "fast"): (4.0, 0.0, 1.0, 12.0),
+            ("grok-4.7", "500k-standard"): (4.0, 0.0, 1.0, 12.0),
+            ("grok-4.7", "500k-fast"): (6.0, 0.0, 1.5, 18.0),
+        }
+        for (model, variant), rates in cases.items():
+            with self.subTest(model=model, variant=variant):
+                price, _ = meter.price_for(model, "cursor", variant, at=after_sol_update)
+                self.assertEqual(
+                    (price["input"], price["cache_write"], price["cache_read"], price["output"]),
+                    rates,
+                )
+        before, _ = meter.price_for("gpt-5.6-sol", "cursor", "", at=1_786_000_000)
+        self.assertEqual((before["input"], before["output"]), (5.0, 30.0))
+        for model, variant in (("claude-opus-5-5", "fast"), ("gpt-5.6-sol", "max"),
+                               ("gpt-5.6-sol", "max-fast"), ("composer-2.5", "max"),
+                               ("composer-2.5", "max-fast"), ("claude-opus-5-5-turbo", ""),
+                               ("claude-opus-5-5-turbo", "max")):
+            with self.subTest(unpriced=model, variant=variant):
+                price, _ = meter.price_for(model, "cursor", variant)
+                self.assertEqual(price, meter.ZERO_PRICE)
+
+    def test_cursor_max_mode_bills_the_api_rate_plus_twenty_percent(self):
+        cases = {
+            ("claude-opus-5-5", "max"): (4.8, 6.0, 0.24, 24.0),
+            ("claude-opus-5-5-medium", "max"): (4.8, 6.0, 0.24, 24.0),
+            ("claude-opus-5-5", "max-fast"): (9.6, 12.0, 0.48, 48.0),
+        }
+        for (model, variant), rates in cases.items():
+            with self.subTest(model=model, variant=variant):
+                price, _ = meter.price_for(model, "cursor", variant)
+                self.assertEqual(
+                    tuple(round(price[key], 6) for key in ("input", "cache_write", "cache_read", "output")),
+                    rates,
+                )
+        cost = meter.cost_of({"input_tokens": 1_000_000, "output_tokens": 100_000},
+                             "claude-opus-5-5", "cursor", "max")
+        self.assertAlmostEqual(sum(cost.values()), 4.8 + 2.4)
+
+    def test_cursor_model_name_drops_effort_suffix_only_for_selected_model(self):
+        def composer(name, model_id):
+            return {"modelConfig": {"modelName": name, "selectedModels": [{"modelId": model_id}]}}
+        self.assertEqual(meter.cursor_model(composer("gpt-5.6-sol-xhigh", "gpt-5.6-sol")),
+                         "gpt-5.6-sol")
+        self.assertEqual(meter.cursor_model(composer("claude-opus-5-5-medium", "claude-opus-5-5")),
+                         "claude-opus-5-5")
+        self.assertEqual(meter.cursor_model(composer("gpt-5.6-sol-turbo", "gpt-5.6-sol")),
+                         "gpt-5.6-sol-turbo")
+        self.assertEqual(meter.cursor_model(composer("grok-4.6-high", "composer-2.5")),
+                         "grok-4.6-high")
+
+    def test_cursor_price_variant_reads_fast_max_and_context_parameters(self):
+        def composer(model, params, max_mode=False):
+            return {"modelConfig": {"modelName": model, "maxMode": max_mode, "selectedModels": [{
+                "modelId": model,
+                "parameters": [{"id": key, "value": value} for key, value in params.items()],
+            }]}}
+        self.assertEqual(meter.cursor_price_variant(
+            composer("claude-opus-5-5", {"fast": "false", "effort": "medium"}), "claude-opus-5-5"), "")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("claude-opus-5-5", {"fast": "true"}), "claude-opus-5-5"), "fast")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("gpt-5.6-sol", {}, max_mode=True), "gpt-5.6-sol"), "max")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("composer-2.5", {"fast": "true"}, max_mode=True), "composer-2.5"), "max-fast")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("claude-opus-5-5", {"fast": "false", "context": "300k"}, max_mode=True),
+            "claude-opus-5-5"), "max")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("claude-opus-5-5", {"fast": "true", "context": "1m"}, max_mode=True),
+            "claude-opus-5-5-high"), "max-fast")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("grok-4.7", {"fast": "true", "context": "500k"}), "grok-4.7"), "500k-fast")
+        self.assertEqual(meter.cursor_price_variant(
+            composer("grok-4.7", {"fast": "false"}), "grok-4.7"), "standard")
+
+    def test_cursor_pricing_rejects_composer_lookalikes_and_accepts_qualified_alias(self):
+        composer = self.snapshot()["composer"]
+        composer["modelConfig"]["selectedModels"].insert(0, {
+            "modelId": "some-other-model",
+            "parameters": [{"id": "fast", "value": "false"}],
+        })
+        qualified, approximate = meter.price_for(
+            "cursor.composer-2.5", "cursor", "fast"
+        )
+        self.assertTrue(approximate)
+        self.assertEqual((qualified["input"], qualified["output"]), (3.0, 15.0))
+        self.assertEqual(
+            meter.cursor_price_variant(composer, "cursor.composer-2.5"), "fast"
+        )
+
+        for model in ("composer-2.5ish", "composer-2.5-future"):
+            with self.subTest(model=model):
+                price, unavailable = meter.price_for(model, "cursor", "fast")
+                self.assertTrue(unavailable)
+                self.assertEqual(price, meter.ZERO_PRICE)
+                self.assertEqual(meter.cursor_price_variant(self.snapshot()["composer"], model), "")
+
+    def test_cursor_agent_check_reports_local_estimate_and_caveat(self):
+        with mock.patch.object(meter, "cursor_snapshot", return_value=self.snapshot()), \
+                mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
+            state = meter.recompute_cursor(self.source())
+        with mock.patch.object(meter, "resolve_agent_source", return_value=(self.source(), "matched")), \
+                mock.patch.object(meter, "recompute", return_value=state):
+            result = meter.agent_check(focus="cost", caller={"runtime": "cursor", "project": "/repo"})
+        self.assertTrue(result["ok"])
+        self.assertAlmostEqual(result["evidence"][0]["value"], 0.2414, places=4)
+        self.assertTrue(result["availability"]["cost"])
+        self.assertIn("local", result["caveat"].lower())
+        self.assertIn("cost", result["approximate_fields"])
+
+    def test_cursor_summary_and_model_rollup_include_local_estimates(self):
+        with mock.patch.object(meter, "cursor_snapshot", return_value=self.snapshot()), \
+                mock.patch.object(meter, "cursor_request_spans", return_value=self.spans()):
+            state = meter.recompute_cursor(self.source())
+        with mock.patch.object(meter, "recompute_cursor", return_value=state):
+            row = meter.cursor_summary(self.source())
+        aggregate = meter.aggregate_model_stats([row])
+        model = aggregate["models"][0]
+        self.assertEqual(row["turns"], 1)
+        self.assertEqual(row["models"], ["composer-2.5"])
+        # Live-session selection uses the end of the last execution, not the database file time.
+        self.assertEqual(row["last_activity_ts"], float(state["timing"]["end_ts"]))
+        self.assertTrue(row["availability"]["cost"])
+        self.assertTrue(row["cost_approx"])
+        self.assertEqual(row["input_tokens"], 80448)
+        self.assertEqual(row["output_tokens"], 6)
+        self.assertEqual(row["usage_basis"], "local_estimate")
+        self.assertEqual(row["provenance"]["estimated_sessions"], 1)
+        self.assertEqual(model["model"], "composer-2.5")
+        self.assertEqual(model["runtime"], "Cursor")
+        self.assertEqual(model["usage_basis"], "local_estimate")
+        self.assertFalse(model["availability"]["cache"])
+        self.assertEqual(model["coverage"]["cache"]["covered_sessions"], 0)
+        self.assertEqual(model["executions"], 1)
+        self.assertEqual(model["median_peak_input_tokens"], 80448)
+        self.assertEqual(model["median_tool_calls"], 1)
+        self.assertAlmostEqual(model["median_wait_s"], 46.624, places=3)
+        self.assertAlmostEqual(model["avg_ttft_ms"], 4118, places=3)
+        self.assertTrue(model["availability"]["tokens"])
+        self.assertEqual(model["input_tokens"], 80448)
+        self.assertEqual(model["output_tokens"], 6)
+        self.assertEqual(model["reasoning_tokens"], 4)
+        self.assertEqual(model["reasoning_output_tokens"], 6)
+        self.assertEqual(model["reasoning_executions"], 1)
+        self.assertTrue(model["availability"]["reasoning_tokens"])
+        self.assertEqual((model["attempts"], model["retries"], model["failed_attempts"]),
+                         (2, 1, 1))
+        self.assertTrue(model["availability"]["attempts"])
+
+    def test_cursor_summary_keeps_priced_model_coverage_in_mixed_session(self):
+        session_availability = meter.metric_availability(
+            "cursor", cost=False, tokens=True, input_tokens=True,
+            output_tokens=True,
+        )
+
+        def execution(model, output_tokens, cost, cost_available, ts):
+            return {
+                "model": model, "ts": ts, "cost": cost,
+                "tokens": {"input": 100, "output": output_tokens},
+                "context_tokens": 100, "reasoning_tokens": 0,
+                "availability": meter.metric_availability(
+                    "cursor", cost=cost_available, tokens=True,
+                    input_tokens=True, output_tokens=True,
+                ),
+                "tools": [], "tool_count": 0, "model_calls": 1,
+            }
+
+        state = {
+            "availability": session_availability,
+            "executions": [
+                execution("composer-2.5", 20, 0.1, True, 1_784_548_801),
+                execution("unknown-model", 30, 0.0, False, 1_784_548_802),
+            ],
+            "total_cost": 0.1, "total_tokens": 250,
+            "tokens": {"input": 200, "output": 50},
+            "cost_approx": True, "token_estimate": True,
+            "timing": {}, "wait_time": {}, "context": {},
+        }
+        with mock.patch.object(meter, "recompute_cursor", return_value=state):
+            row = meter.cursor_summary(self.source())
+
+        self.assertFalse(row["availability"]["cost"])
+        stats = {item["model"]: item for item in row["model_stats"]}
+        self.assertTrue(stats["composer-2.5"]["availability"]["cost"])
+        self.assertEqual(stats["composer-2.5"]["cost_covered_executions"], 1)
+        self.assertEqual(stats["composer-2.5"]["cost_covered_output_tokens"], 20)
+        self.assertFalse(stats["unknown-model"]["availability"]["cost"])
+        daily = {item["model"]: item for item in row["_model_daily"]}
+        self.assertTrue(daily["composer-2.5"]["availability"]["cost"])
+        self.assertFalse(daily["unknown-model"]["availability"]["cost"])
+
+        aggregate = {
+            item["model"]: item for item in meter.aggregate_model_stats([row])["models"]
+        }
+        self.assertTrue(aggregate["composer-2.5"]["availability"]["cost"])
+        self.assertEqual(
+            aggregate["composer-2.5"]["cost_covered_output_tokens"], 20,
+        )
+        self.assertFalse(aggregate["unknown-model"]["availability"]["cost"])
+
+    def test_cursor_efficiency_coverage_requires_output_evidence(self):
+        session_availability = meter.metric_availability(
+            "cursor", cost=True, tokens=True, input_tokens=True,
+            output_tokens=False,
+        )
+
+        def execution(output_tokens, output_available, cost, ts):
+            return {
+                "model": "composer-2.5", "ts": ts, "cost": cost,
+                "tokens": {"input": 100, "output": output_tokens},
+                "context_tokens": 100, "reasoning_tokens": output_tokens // 2,
+                "availability": meter.metric_availability(
+                    "cursor", cost=True, tokens=True, input_tokens=True,
+                    output_tokens=output_available,
+                ),
+                "tools": [], "tool_count": 0, "model_calls": 1,
+            }
+
+        state = {
+            "availability": session_availability,
+            "executions": [
+                execution(20, True, 0.1, 1_784_548_801),
+                execution(0, False, 0.05, 1_784_548_802),
+            ],
+            "total_cost": 0.15, "total_tokens": 220,
+            "tokens": {"input": 200, "output": 20},
+            "cost_approx": True, "token_estimate": True,
+            "timing": {}, "wait_time": {}, "context": {},
+        }
+        with mock.patch.object(meter, "recompute_cursor", return_value=state):
+            row = meter.cursor_summary(self.source())
+
+        stats = row["model_stats"][0]
+        self.assertEqual(stats["executions"], 2)
+        self.assertEqual(stats["token_covered_executions"], 1)
+        self.assertEqual(stats["io_covered_executions"], 1)
+        self.assertEqual(stats["io_covered_input_tokens"], 100)
+        self.assertEqual(stats["io_covered_output_tokens"], 20)
+        self.assertEqual(stats["cost_covered_executions"], 1)
+        self.assertEqual(stats["cost_covered_output_tokens"], 20)
+        self.assertAlmostEqual(stats["cost_covered_cost"], 0.1)
+        self.assertEqual(stats["reasoning_executions"], 1)
+        self.assertEqual(stats["reasoning_unavailable_executions"], 1)
+
+        aggregate = meter.aggregate_model_stats([row])["models"][0]
+        self.assertFalse(aggregate["coverage"]["cost"]["complete"])
+        self.assertFalse(aggregate["coverage"]["reasoning_tokens"]["complete"])
+        self.assertEqual(aggregate["io_covered_executions"], 1)
+        self.assertEqual(aggregate["io_covered_input_tokens"], 100)
+        self.assertEqual(aggregate["io_covered_output_tokens"], 20)
+        self.assertEqual(aggregate["daily"][0]["io_covered_input_tokens"], 100)
+        self.assertAlmostEqual(aggregate["cost_covered_cost"], 0.1)
+
+    def test_usage_provenance_distinguishes_reported_estimated_and_mixed(self):
+        reported = {"id": "reported", "provider": "codex", "cost": 1, "tokens": 10}
+        estimated = {
+            "id": "estimated", "provider": "cursor", "cost": 2, "tokens": 20,
+            "token_estimate": True,
+            "availability": meter.metric_availability("cursor", cost=True, tokens=True),
+        }
+        self.assertEqual(meter.usage_provenance([reported])["usage_basis"], "reported")
+        local = meter.usage_provenance([estimated])
+        self.assertEqual(local["usage_basis"], "local_estimate")
+        self.assertEqual(local["estimated_cost"], 2)
+        mixed = meter.usage_provenance([reported, estimated])
+        self.assertEqual(mixed["usage_basis"], "mixed")
+        self.assertEqual((mixed["reported_sessions"], mixed["estimated_sessions"]), (1, 1))
+
+    def test_cursor_sparse_context_is_interpolated_between_persisted_checkpoints(self):
+        groups = [
+            {"context": {}},
+            {"context": {"tokensUsed": 60000, "tokenLimit": 200000}},
+            {"context": {}},
+        ]
+        rows = meter.cursor_context_estimates(groups, 90000, 200000)
+        self.assertEqual([row["tokens"] for row in rows], [30000, 60000, 90000])
+        self.assertTrue(rows[0]["interpolated"])
+        self.assertFalse(rows[1]["interpolated"])
+
+    def test_mixed_runtime_coverage_is_explicitly_partial(self):
+        covered = {"availability": meter.metric_availability("codex")}
+        cursor = {"availability": meter.metric_availability("cursor")}
+        self.assertEqual(meter.metric_coverage([covered, cursor], "cost"), {
+            "covered_sessions": 1, "total_sessions": 2, "complete": False,
+        })
+
+
+class ExecutionTimingTests(unittest.TestCase):
+    def test_merges_overlapping_execution_windows(self):
+        seconds = meter._merge_execution_intervals([(0, 10), (5, 15), (20, 25)])
+        self.assertEqual(seconds, 20)
+
+    def test_uses_claude_reported_turn_durations(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-06-30T00:00:00.000Z", "message": {"content": "first"}},
+            {"type": "system", "subtype": "turn_duration", "timestamp": "2026-06-30T00:00:10.000Z", "durationMs": 10000},
+            {"type": "user", "timestamp": "2026-06-30T00:01:00.000Z", "message": {"content": "second"}},
+            {"type": "system", "subtype": "turn_duration", "timestamp": "2026-06-30T00:01:20.000Z", "durationMs": 20000},
+        ]
+        timing = meter.execution_timing("claude", objs)
+        self.assertEqual(timing["duration_s"], 30)
+        self.assertEqual(timing["reported_executions"], 2)
+        self.assertEqual(timing["basis"], "reported")
+
+    def test_claude_observed_fallback_excludes_between_prompt_idle_gap(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-06-30T00:00:00.000Z", "message": {"content": "first"}},
+            {"type": "assistant", "timestamp": "2026-06-30T00:00:10.000Z", "message": {"content": "done"}},
+            {"type": "user", "timestamp": "2026-06-30T01:00:00.000Z", "message": {"content": "second"}},
+            {"type": "assistant", "timestamp": "2026-06-30T01:00:20.000Z", "message": {"content": "done"}},
+        ]
+        timing = meter.execution_timing("claude", objs)
+        self.assertEqual(timing["duration_s"], 30)
+        self.assertEqual(timing["observed_executions"], 2)
+        self.assertEqual(timing["basis"], "observed")
+
+    def test_combines_codex_reported_and_open_execution_time(self):
+        objs = [
+            {"timestamp": "2026-06-30T00:00:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-06-30T00:00:30.000Z", "payload": {"type": "task_complete", "duration_ms": 20000}},
+            {"timestamp": "2026-06-30T00:01:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-06-30T00:01:15.000Z", "payload": {"type": "agent_message"}},
+        ]
+        timing = meter.execution_timing("codex", objs)
+        self.assertEqual(timing["duration_s"], 35)
+        self.assertEqual(timing["reported_executions"], 1)
+        self.assertEqual(timing["observed_executions"], 1)
+        self.assertEqual(timing["basis"], "reported + observed")
+
+    def test_codex_context_accepts_structured_approval_policy(self):
+        self.assertEqual(meter.codex_approval_policy_label("on_request"), "on request")
+        self.assertEqual(
+            meter.codex_approval_policy_label({
+                "granular": {
+                    "sandbox_approval": False,
+                    "request_permissions": True,
+                },
+            }),
+            "granular",
+        )
+
+
+class WaitTimeTests(unittest.TestCase):
+    def test_claude_wait_is_prompt_to_completion_and_dedupes_split_messages(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
+             "message": {"content": "do the work"}},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:02.000Z", "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "text", "text": "working"}],
+                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
+            }},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:03.000Z", "message": {
+                "id": "msg-1", "model": "claude-opus-4-8",
+                "content": [{"type": "tool_use", "id": "tool-1", "name": "Read"}],
+                "usage": {"input_tokens": 20, "output_tokens": 30}, "stop_reason": "tool_use",
+            }},
+            {"type": "user", "timestamp": "2026-07-13T00:00:04.000Z", "message": {
+                "content": [{"type": "tool_result", "tool_use_id": "tool-1", "content": "done"}],
+            }},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:09.000Z", "message": {
+                "id": "msg-2", "model": "claude-opus-4-8",
+                "content": [{"type": "text", "text": "finished"}],
+                "usage": {"input_tokens": 25, "output_tokens": 20}, "stop_reason": "end_turn",
+            }},
+            {"type": "system", "subtype": "turn_duration",
+             "timestamp": "2026-07-13T00:00:10.000Z", "durationMs": 10000},
+        ]
+        samples = meter.claude_wait_samples(objs)
+        self.assertEqual(len(samples), 1)
+        self.assertEqual(samples[0]["duration_s"], 10)
+        self.assertEqual(samples[0]["tool_calls"], 1)
+        self.assertEqual(samples[0]["output_tokens"], 50)
+        self.assertEqual(samples[0]["timing_basis"], "reported")
+
+    def test_codex_wait_uses_reported_duration_and_includes_tool_time(self):
+        objs = [
+            {"type": "turn_context", "timestamp": "2026-07-13T00:00:00.000Z",
+             "payload": {"model": "gpt-5.6"}},
+            {"timestamp": "2026-07-13T00:00:00.000Z", "payload": {"type": "task_started"}},
+            {"timestamp": "2026-07-13T00:00:02.000Z", "payload": {
+                "type": "function_call", "name": "exec_command", "call_id": "call-1",
+            }},
+            {"timestamp": "2026-07-13T00:00:08.000Z", "payload": {
+                "type": "token_count", "info": {"last_token_usage": {
+                    "input_tokens": 100, "output_tokens": 40, "total_tokens": 140,
+                }},
+            }},
+            {"timestamp": "2026-07-13T00:00:10.000Z", "payload": {
+                "type": "task_complete", "duration_ms": 10000,
+            }},
+        ]
+        sample = meter.codex_wait_samples(objs)[0]
+        self.assertEqual(sample["duration_s"], 10)
+        self.assertEqual(sample["tool_calls"], 1)
+        self.assertEqual(sample["output_tokens"], 40)
+        self.assertEqual(sample["model"], "gpt-5.6")
+
+    def test_claude_observed_wait_excludes_time_waiting_for_user_input(self):
+        objs = [
+            {"type": "user", "timestamp": "2026-07-13T00:00:00.000Z",
+             "message": {"content": "start"}},
+            {"type": "assistant", "timestamp": "2026-07-13T00:00:10.000Z", "message": {
+                "id": "msg-1", "model": "claude-opus-4-8", "stop_reason": "tool_use",
+                "usage": {"input_tokens": 20, "output_tokens": 10},
+                "content": [{"type": "tool_use", "id": "question-1", "name": "AskUserQuestion"}],
+            }},
+            {"type": "user", "timestamp": "2026-07-13T00:01:40.000Z", "message": {
+                "content": [{"type": "tool_result", "tool_use_id": "question-1", "content": "answer"}],
+            }},
+            {"type": "assistant", "timestamp": "2026-07-13T00:01:50.000Z", "message": {
+                "id": "msg-2", "model": "claude-opus-4-8", "stop_reason": "end_turn",
+                "usage": {"input_tokens": 25, "output_tokens": 20},
+                "content": [{"type": "text", "text": "finished"}],
+            }},
+        ]
+        sample = meter.claude_wait_samples(objs)[0]
+        self.assertEqual(sample["wall_duration_s"], 110)
+        self.assertEqual(sample["user_pause_s"], 90)
+        self.assertEqual(sample["duration_s"], 20)
+        self.assertEqual(meter.wait_time_summary([sample])["user_pause_s"], 90)
+
+    def test_wait_summary_reports_average_p95_and_longest(self):
+        summary = meter.wait_time_summary([
+            {"duration_s": 2, "timing_basis": "reported"},
+            {"duration_s": 6, "timing_basis": "observed"},
+            {"duration_s": 10, "timing_basis": "reported"},
+        ])
+        self.assertEqual(summary["total_s"], 18)
+        self.assertEqual(summary["avg_s"], 6)
+        self.assertEqual(summary["median_s"], 6)
+        self.assertEqual(summary["p95_s"], 10)
+        self.assertEqual(summary["max_s"], 10)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_updates_install.py b/tests/test_updates_install.py
new file mode 100644
index 00000000..cdba577e
--- /dev/null
+++ b/tests/test_updates_install.py
@@ -0,0 +1,1230 @@
+import unittest
+import json
+import os
+import plistlib
+import tempfile
+import time
+from pathlib import Path
+from unittest import mock
+import meter
+
+
+class SoftwareUpdateTests(unittest.TestCase):
+    def enabled_settings(self, root):
+        path = Path(root) / "settings.json"
+        path.write_text(json.dumps({"updates": {"enabled": True}, "keep": "value"}))
+        return path
+
+    def runner(self, outputs, calls):
+        def run(command, **kwargs):
+            args = tuple(command[3:])
+            calls.append(args)
+            value = outputs.get(args)
+            if isinstance(value, int):
+                return meter.subprocess.CompletedProcess(command, value, "", "failed")
+            if value is None:
+                raise AssertionError(f"Unexpected git command: {args}")
+            return meter.subprocess.CompletedProcess(command, 0, value, "")
+        return run
+
+    def test_windows_background_git_checks_do_not_create_a_console_window(self):
+        observed = {}
+
+        def runner(command, **kwargs):
+            observed.update(kwargs)
+            return meter.subprocess.CompletedProcess(command, 0, "main\n", "")
+
+        windows = meter.platform_services(
+            "windows", environment={"USERPROFILE": r"C:\Users\example"},
+            home=r"C:\Users\example",
+        )
+        with mock.patch.object(meter, "_PLATFORM_SERVICES", windows):
+            self.assertEqual(
+                meter._run_update_git(r"C:\Token Meter", ["rev-parse", "HEAD"],
+                                      runner=runner),
+                "main",
+            )
+
+        self.assertEqual(observed["creationflags"], 0x08000000)
+        self.assertTrue(observed["close_fds"])
+
+    def test_update_setting_defaults_on_and_preserves_an_explicit_off_choice(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"model_pricing": {"claude": {}}}))
+            initial = meter.update_settings(str(path))
+            invalid = meter.set_update_settings({"enabled": "yes"}, str(path))
+            result = meter.set_update_settings(
+                {"enabled": False, "auto_install": True}, str(path)
+            )
+            stored = json.loads(path.read_text())
+            explicit = meter.update_settings(str(path))
+        self.assertTrue(initial["enabled"])
+        self.assertTrue(initial["auto_install"])
+        self.assertEqual(initial["interval_seconds"], 600)
+        self.assertFalse(invalid["ok"])
+        self.assertTrue(result["ok"])
+        self.assertFalse(explicit["enabled"])
+        self.assertFalse(explicit["auto_install"])
+        self.assertEqual(
+            stored["updates"], {"enabled": False, "auto_install": False}
+        )
+        self.assertIn("model_pricing", stored)
+
+    def test_auto_install_can_be_disabled_without_disabling_update_checks(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "settings.json"
+            path.write_text(json.dumps({"keep": "value"}))
+            result = meter.set_update_settings(
+                {"enabled": True, "auto_install": False}, str(path)
+            )
+            stored = json.loads(path.read_text())
+            explicit = meter.update_settings(str(path))
+        self.assertTrue(result["ok"])
+        self.assertEqual(
+            explicit,
+            {"enabled": True, "auto_install": False, "interval_seconds": 600},
+        )
+        self.assertEqual(
+            stored,
+            {"keep": "value", "updates": {"enabled": True, "auto_install": False}},
+        )
+
+    def test_menubar_update_projection_is_bounded_and_actionable(self):
+        status = {
+            "enabled": True,
+            "auto_install": False,
+            "state": "available",
+            "available": True,
+            "can_update": True,
+            "current_revision": "a" * 40,
+            "latest_revision": "b" * 40,
+            "message": "/private/source checkout has an update",
+            "path": "/private/source",
+            "actions": {
+                "token": "local_action_token-123",
+                "check": True,
+                "install": True,
+            },
+        }
+        projected = meter.menubar_software_update(status)
+        self.assertEqual(projected, {
+            "enabled": True,
+            "auto_install": False,
+            "state": "available",
+            "available": True,
+            "can_update": True,
+            "current_revision": "a" * 40,
+            "latest_revision": "b" * 40,
+            "actions": {
+                "token": "local_action_token-123",
+                "install": True,
+            },
+        })
+        self.assertNotIn("message", projected)
+        self.assertNotIn("path", projected)
+
+    def test_update_watcher_preserves_terminal_result_for_one_interval_then_checks(self):
+        wake = mock.Mock()
+        wake.wait.side_effect = [False, RuntimeError("stop watcher")]
+        with (mock.patch.object(meter, "_update_wake", wake),
+              mock.patch.object(
+                  meter, "update_settings",
+                  return_value={"enabled": True, "auto_install": False},
+              ),
+              mock.patch.object(meter, "_update_status_record", return_value={"phase": "complete"}),
+              mock.patch.object(meter, "check_for_software_update") as check):
+            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
+                meter.software_update_watcher()
+        self.assertEqual(
+            wake.wait.call_args_list,
+            [mock.call(meter.UPDATE_CHECK_INTERVAL_S), mock.call(meter.UPDATE_CHECK_INTERVAL_S)],
+        )
+        check.assert_called_once_with()
+
+    def test_update_watcher_starts_a_safe_available_update_when_enabled(self):
+        wake = mock.Mock()
+        wake.wait.side_effect = [RuntimeError("stop watcher")]
+        available = {
+            "available": True,
+            "can_update": True,
+            "latest_revision": "b" * 40,
+        }
+        with (mock.patch.object(meter, "_update_wake", wake),
+              mock.patch.object(
+                  meter, "update_settings",
+                  return_value={"enabled": True, "auto_install": True},
+              ),
+              mock.patch.object(meter, "_update_status_record", return_value={"phase": "current"}),
+              mock.patch.object(
+                  meter, "check_for_software_update", return_value=available,
+              ) as check,
+              mock.patch.object(meter, "start_software_update") as start):
+            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
+                meter.software_update_watcher()
+        check.assert_called_once_with()
+        start.assert_called_once_with()
+
+    def test_update_watcher_keeps_checking_when_auto_install_is_disabled(self):
+        wake = mock.Mock()
+        wake.wait.side_effect = [RuntimeError("stop watcher")]
+        available = {
+            "available": True,
+            "can_update": True,
+            "latest_revision": "b" * 40,
+        }
+        with (mock.patch.object(meter, "_update_wake", wake),
+              mock.patch.object(
+                  meter, "update_settings",
+                  return_value={"enabled": True, "auto_install": False},
+              ),
+              mock.patch.object(meter, "_update_status_record", return_value={"phase": "current"}),
+              mock.patch.object(
+                  meter, "check_for_software_update", return_value=available,
+              ) as check,
+              mock.patch.object(meter, "start_software_update") as start):
+            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
+                meter.software_update_watcher()
+        check.assert_called_once_with()
+        start.assert_not_called()
+
+    def test_update_watcher_does_not_repeat_the_same_failed_revision(self):
+        wake = mock.Mock()
+        wake.wait.side_effect = [RuntimeError("stop watcher")]
+        target = "b" * 40
+        available = {
+            "available": True,
+            "can_update": True,
+            "latest_revision": target,
+        }
+        record = {"phase": "available", "failed_revision": target}
+        with (mock.patch.object(meter, "_update_wake", wake),
+              mock.patch.object(
+                  meter, "update_settings",
+                  return_value={"enabled": True, "auto_install": True},
+              ),
+              mock.patch.object(meter, "_update_status_record", return_value=record),
+              mock.patch.object(
+                  meter, "check_for_software_update", return_value=available,
+              ),
+              mock.patch.object(meter, "start_software_update") as start):
+            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
+                meter.software_update_watcher()
+        start.assert_not_called()
+
+    def test_automatic_check_fetches_and_reports_a_clean_fast_forward_update(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            calls = []
+            outputs = {
+                ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"):
+                    "origin/main\n",
+                ("rev-parse", "--abbrev-ref", "HEAD"): "main\n",
+                ("fetch", "--quiet", "--prune", "--no-tags", "origin"): "",
+                ("rev-parse", "HEAD"): "a" * 40,
+                ("rev-parse", "@{upstream}"): "b" * 40,
+                ("rev-list", "--left-right", "--count", "HEAD...@{upstream}"): "0\t2\n",
+                ("status", "--porcelain"): "",
+            }
+            with mock.patch.object(meter.shutil, "which", return_value="/usr/bin/git"):
+                status = meter.check_for_software_update(
+                    checkout=tmp,
+                    runner=self.runner(outputs, calls),
+                    now=1234,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+        self.assertEqual(status["state"], "available")
+        self.assertTrue(status["available"])
+        self.assertTrue(status["can_update"])
+        self.assertEqual(status["current_revision"], "a" * 40)
+        self.assertEqual(status["latest_revision"], "b" * 40)
+        self.assertEqual(status["behind"], 2)
+        self.assertEqual(status["next_check_at"], 1834)
+        self.assertIn(("fetch", "--quiet", "--prune", "--no-tags", "origin"), calls)
+        self.assertNotIn(tmp, json.dumps(status))
+
+    def test_available_update_fails_closed_when_checkout_is_dirty(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            outputs = {
+                ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"):
+                    "origin/main\n",
+                ("rev-parse", "--abbrev-ref", "HEAD"): "main\n",
+                ("fetch", "--quiet", "--prune", "--no-tags", "origin"): "",
+                ("rev-parse", "HEAD"): "a" * 40,
+                ("rev-parse", "@{upstream}"): "b" * 40,
+                ("rev-list", "--left-right", "--count", "HEAD...@{upstream}"): "0 1",
+                ("status", "--porcelain"): " M page.html\n",
+            }
+            with mock.patch.object(meter.shutil, "which", return_value="/usr/bin/git"):
+                status = meter.check_for_software_update(
+                    checkout=tmp,
+                    runner=self.runner(outputs, []),
+                    now=1234,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+        self.assertEqual(status["state"], "attention")
+        self.assertTrue(status["available"])
+        self.assertFalse(status["can_update"])
+        self.assertTrue(status["dirty"])
+        self.assertIn("local changes", status["message"])
+
+    def test_automatic_update_rejects_a_checkout_not_on_main(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            outputs = {
+                ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"):
+                    "origin/feature\n",
+                ("rev-parse", "--abbrev-ref", "HEAD"): "feature\n",
+            }
+            with mock.patch.object(meter.shutil, "which", return_value="/usr/bin/git"):
+                status = meter.check_for_software_update(
+                    checkout=tmp,
+                    runner=self.runner(outputs, []),
+                    now=1234,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+        self.assertEqual(status["state"], "attention")
+        self.assertFalse(status["can_update"])
+        self.assertIn("main", status["message"])
+
+    def test_linux_helper_failure_has_an_actionable_bounded_status(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            meter._persist_update_status({
+                "phase": "failed",
+                "error_code": "linux_helper_unavailable",
+                "checked_at": 1234,
+                "available": False,
+                "can_update": False,
+            }, str(status_path))
+            status = meter.software_update_status(
+                settings_path=str(settings_path), status_path=str(status_path),
+            )
+
+        self.assertEqual(status["state"], "attention")
+        self.assertEqual(
+            status["message"],
+            "The installed Linux update helper is unavailable. Reinstall Token Meter to repair automatic updates.",
+        )
+        self.assertNotIn(tmp, json.dumps(status))
+
+    def test_explicit_install_starts_only_the_bounded_detached_helper(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            meter._persist_update_status({
+                "phase": "available",
+                "current_revision": "a" * 40,
+                "latest_revision": "b" * 40,
+                "checked_at": 1234,
+                "available": True,
+                "can_update": True,
+                "ahead": 0,
+                "behind": 1,
+                "dirty": False,
+            }, str(status_path))
+            popen = mock.Mock()
+            macos = meter.platform_services("darwin", environment={}, home=tmp)
+            with (mock.patch.object(meter, "source_checkout_path", return_value=tmp),
+                  mock.patch.object(meter, "_PLATFORM_SERVICES", macos),
+                  mock.patch.object(meter.os.path, "isfile", return_value=True),
+                  mock.patch.object(meter.os, "access", return_value=True)):
+                result = meter.start_software_update(
+                    popen=popen,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+            command = popen.call_args.args[0]
+            kwargs = popen.call_args.kwargs
+        self.assertTrue(result["ok"])
+        self.assertTrue(command[0].endswith("/scripts/update"))
+        self.assertEqual(command[1:], [tmp, str(status_path)])
+        self.assertTrue(kwargs["start_new_session"])
+        self.assertTrue(kwargs["close_fds"])
+        self.assertNotIn("cwd", kwargs)
+        self.assertNotIn(tmp, json.dumps(result))
+
+    def test_windows_install_starts_the_helper_outside_the_runtime_it_replaces(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            checkout = os.path.join(tmp, "source")
+            os.mkdir(checkout)
+            meter._persist_update_status({
+                "phase": "available",
+                "current_revision": "a" * 40,
+                "latest_revision": "b" * 40,
+                "checked_at": 1234,
+                "available": True,
+                "can_update": True,
+                "ahead": 0,
+                "behind": 1,
+                "dirty": False,
+            }, str(status_path))
+            popen = mock.Mock()
+            windows = meter.platform_services("windows", environment={}, home=tmp)
+            with (mock.patch.object(meter, "source_checkout_path", return_value=checkout),
+                  mock.patch.object(meter, "_PLATFORM_SERVICES", windows),
+                  mock.patch.object(meter.os.path, "isfile", return_value=True)):
+                result = meter.start_software_update(
+                    popen=popen,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+            command = popen.call_args.args[0]
+            kwargs = popen.call_args.kwargs
+        self.assertTrue(result["ok"])
+        self.assertEqual(command[0], "powershell.exe")
+        self.assertEqual(command[-2:], [checkout, str(status_path)])
+        self.assertEqual(kwargs["cwd"], checkout)
+        # CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP; DETACHED_PROCESS stops
+        # Windows PowerShell before the helper runs.
+        self.assertEqual(kwargs["creationflags"], 0x08000200)
+
+    def test_windows_install_refuses_a_checkout_that_disappeared(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            meter._persist_update_status({
+                "phase": "available",
+                "current_revision": "a" * 40,
+                "latest_revision": "b" * 40,
+                "checked_at": 1234,
+                "available": True,
+                "can_update": True,
+                "ahead": 0,
+                "behind": 1,
+                "dirty": False,
+            }, str(status_path))
+            popen = mock.Mock()
+            windows = meter.platform_services("windows", environment={}, home=tmp)
+            with (mock.patch.object(meter, "source_checkout_path",
+                                    return_value=os.path.join(tmp, "missing")),
+                  mock.patch.object(meter, "_PLATFORM_SERVICES", windows),
+                  mock.patch.object(meter.os.path, "isfile", return_value=True)):
+                result = meter.start_software_update(
+                    popen=popen,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+            phase = meter._update_status_record(str(status_path)).get("phase")
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["error"], "The installed updater is unavailable.")
+        popen.assert_not_called()
+        self.assertEqual(phase, "available")
+
+    def test_linux_install_launches_the_helper_as_a_transient_user_unit(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            target = "b" * 40
+            meter._persist_update_status({
+                "phase": "failed",
+                "error_code": "update_interrupted",
+                "current_revision": "a" * 40,
+                "latest_revision": target,
+                "failed_revision": target,
+                "checked_at": 1234,
+                "available": True,
+                "can_update": False,
+            }, str(status_path))
+            popen = mock.Mock()
+            linux = meter.platform_services(
+                "linux", environment={"INVOCATION_ID": "a" * 32}, home=tmp,
+            )
+            with (mock.patch.object(meter, "source_checkout_path", return_value=tmp),
+                  mock.patch.object(meter, "_PLATFORM_SERVICES", linux),
+                  mock.patch("token_meter.platforms.linux.shutil.which",
+                             return_value="/usr/bin/systemd-run"),
+                  mock.patch.object(meter.os.path, "isfile", return_value=True),
+                  mock.patch.object(meter.os, "access", return_value=True)):
+                result = meter.start_software_update(
+                    popen=popen,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+            command = popen.call_args.args[0]
+        self.assertTrue(result["ok"])
+        self.assertEqual(command[:2], ["/usr/bin/systemd-run", "--user"])
+        self.assertIn("--setenv=TOKEN_METER_UPDATE_RETRY_REVISION=" + target, command)
+        separator = command.index("--")
+        self.assertTrue(command[separator + 1].endswith("/scripts/update"))
+        self.assertEqual(command[separator + 2:], [tmp, str(status_path)])
+
+    def test_stale_in_progress_update_becomes_a_retryable_interruption(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            target = "b" * 40
+            record = {
+                "phase": "installing",
+                "current_revision": target,
+                "latest_revision": target,
+                "previous_revision": "a" * 40,
+                "checked_at": 1000,
+                "started_at": 1001,
+                "available": True,
+                "can_update": False,
+            }
+            meter._persist_update_status(record, str(status_path))
+            fresh = meter._recover_stale_update(
+                record, now=1001 + meter.UPDATE_STALE_AFTER_S - 1,
+                status_path=str(status_path),
+            )
+            still_installing = json.loads(status_path.read_text())["phase"]
+            recovered = meter._recover_stale_update(
+                record, now=1001 + meter.UPDATE_STALE_AFTER_S,
+                status_path=str(status_path),
+            )
+            stored = json.loads(status_path.read_text())
+            status = meter.software_update_status(
+                settings_path=str(settings_path), status_path=str(status_path),
+            )
+        self.assertFalse(fresh)
+        self.assertEqual(still_installing, "installing")
+        self.assertTrue(recovered)
+        self.assertEqual(stored["phase"], "failed")
+        self.assertEqual(stored["error_code"], "update_interrupted")
+        self.assertEqual(stored["failed_revision"], target)
+        self.assertEqual(stored["previous_revision"], "a" * 40)
+        self.assertEqual(status["state"], "attention")
+        self.assertIn("stopped before it finished", status["message"])
+
+    def test_stale_check_falls_back_to_checked_at_and_needs_a_timestamp(self):
+        """The Windows helper writes in-progress records without started_at."""
+        with tempfile.TemporaryDirectory() as tmp:
+            status_path = str(Path(tmp) / "update-status.json")
+            windows_record = {
+                "phase": "installing", "checked_at": 1000, "latest_revision": "b" * 40,
+            }
+            meter._persist_update_status(windows_record, status_path)
+            fresh = meter._recover_stale_update(
+                windows_record, now=1005, status_path=status_path,
+            )
+            undated = meter._recover_stale_update(
+                {"phase": "fetching"}, now=10 ** 9, status_path=status_path,
+            )
+            still_installing = json.loads(Path(status_path).read_text())["phase"]
+            stale = meter._recover_stale_update(
+                windows_record, now=1000 + meter.UPDATE_STALE_AFTER_S,
+                status_path=status_path,
+            )
+            stored = json.loads(Path(status_path).read_text())
+        self.assertFalse(fresh)
+        self.assertFalse(undated)
+        self.assertEqual(still_installing, "installing")
+        self.assertTrue(stale)
+        self.assertEqual(stored["error_code"], "update_interrupted")
+
+    def test_update_watcher_waits_on_a_fresh_in_progress_update(self):
+        wake = mock.Mock()
+        wake.wait.side_effect = [None, RuntimeError("stop watcher")]
+        fresh = {"phase": "installing", "started_at": int(time.time())}
+        with (mock.patch.object(meter, "_update_wake", wake),
+              mock.patch.object(
+                  meter, "update_settings",
+                  return_value={"enabled": True, "auto_install": False},
+              ),
+              mock.patch.object(meter, "_update_status_record", return_value=fresh),
+              mock.patch.object(meter, "_persist_update_status") as persist,
+              mock.patch.object(meter, "check_for_software_update") as check):
+            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
+                meter.software_update_watcher()
+        persist.assert_not_called()
+        self.assertEqual(wake.wait.call_args_list, [mock.call(5), mock.call(5)])
+        check.assert_not_called()
+
+    def test_update_watcher_recovers_a_stale_in_progress_update(self):
+        wake = mock.Mock()
+        wake.wait.side_effect = [RuntimeError("stop watcher")]
+        stale = {"phase": "installing", "started_at": 1}
+        with (mock.patch.object(meter, "_update_wake", wake),
+              mock.patch.object(
+                  meter, "update_settings",
+                  return_value={"enabled": True, "auto_install": False},
+              ),
+              mock.patch.object(
+                  meter, "_update_status_record",
+                  side_effect=[stale, {"phase": "failed"}],
+              ),
+              mock.patch.object(meter, "_persist_update_status", return_value=True) as persist,
+              mock.patch.object(meter, "check_for_software_update") as check):
+            with self.assertRaisesRegex(RuntimeError, "stop watcher"):
+                meter.software_update_watcher()
+        self.assertEqual(persist.call_args.args[0]["error_code"], "update_interrupted")
+        self.assertEqual(wake.wait.call_args_list, [mock.call(meter.UPDATE_CHECK_INTERVAL_S)])
+        check.assert_not_called()
+
+    def test_explicit_install_retries_a_failed_current_revision(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            target = "b" * 40
+            meter._persist_update_status({
+                "phase": "failed",
+                "error_code": "install_failed",
+                "current_revision": target,
+                "latest_revision": target,
+                "previous_revision": "a" * 40,
+                "failed_revision": target,
+                "checked_at": 1234,
+                "available": False,
+                "can_update": False,
+            }, str(status_path))
+            popen = mock.Mock()
+            with (mock.patch.object(meter, "source_checkout_path", return_value=tmp),
+                  mock.patch.object(meter.os.path, "isfile", return_value=True),
+                  mock.patch.object(meter.os, "access", return_value=True)):
+                result = meter.start_software_update(
+                    popen=popen,
+                    settings_path=str(settings_path),
+                    status_path=str(status_path),
+                )
+            retry_environment = popen.call_args.kwargs["env"]
+        self.assertTrue(result["ok"])
+        self.assertEqual(
+            retry_environment["TOKEN_METER_UPDATE_RETRY_REVISION"], target
+        )
+
+    def test_manual_check_cannot_overwrite_an_install_in_progress(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = self.enabled_settings(tmp)
+            status_path = Path(tmp) / "update-status.json"
+            meter._persist_update_status({
+                "phase": "installing",
+                "current_revision": "b" * 40,
+                "latest_revision": "b" * 40,
+                "available": True,
+                "can_update": False,
+            }, str(status_path))
+            result = meter.trigger_software_update_check(
+                settings_path=str(settings_path),
+                status_path=str(status_path),
+            )
+            stored = json.loads(status_path.read_text())
+        self.assertFalse(result["ok"])
+        self.assertIn("already in progress", result["error"])
+        self.assertEqual(stored["phase"], "installing")
+
+
+class InstallationTests(unittest.TestCase):
+    def test_menu_bar_launcher_builds_a_stable_background_app_bundle(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "run-menubar").read_text()
+        info = plistlib.loads((root / "menubar" / "Info.plist").read_bytes())
+        self.assertIn('APP="$ROOT/.build/Token Meter Menu Bar.app"', script)
+        self.assertIn('ditto "$ROOT/menubar/Info.plist" "$INFO"', script)
+        self.assertIn('exec "$BIN"', script)
+        self.assertEqual(info["CFBundleIdentifier"], "com.token-meter.menubar")
+        self.assertEqual(info["CFBundleExecutable"], "token-meter-menubar")
+        self.assertTrue(info["LSUIElement"])
+
+    def test_user_installer_waits_for_both_supervised_runtime_jobs_and_returns_control(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "install").read_text()
+        manifest = (root / "runtime-manifest.txt").read_text()
+        server_start = script.index(
+            '"$INSTALL_ROOT/scripts/install-launch-agent" server-only'
+        )
+        readiness_check = script.index('"state_ready": true')
+        menubar_start = script.index(
+            '"$INSTALL_ROOT/scripts/install-launch-agent" menubar-only'
+        )
+        self.assertLess(server_start, readiness_check)
+        self.assertLess(readiness_check, menubar_start)
+        self.assertIn('$HOME/Library/Application Support/Token Meter/runtime', script)
+        self.assertIn('TOKEN_METER_READINESS_TIMEOUT_SECONDS:-600', script)
+        self.assertIn('curl -fsS --max-time 5 "$HEALTH_URL"', script)
+        self.assertNotIn('curl -fsS --max-time 1 "$HEALTH_URL"', script)
+        self.assertIn('launchctl print "gui/$UID/$SERVER_LABEL"', script)
+        self.assertIn('launchctl print "gui/$UID/$MENUBAR_LABEL"', script)
+        self.assertIn('"$INSTALL_ROOT/meter.py"', script)
+        self.assertIn('"$INSTALL_ROOT/scripts/run-menubar"', script)
+        self.assertIn('ditto "$source_path" "$install_path"', script)
+        self.assertIn('python3 -m token_meter.packaging parity', script)
+        self.assertIn('assets/brand/logo-splunk-by-cisco-rgb-w.png', manifest)
+        self.assertIn('menubar/Info.plist', manifest)
+        self.assertIn(
+            'printf \'%s\\n\' "$UPDATE_SOURCE_ROOT" > "$INSTALL_ROOT/SOURCE_CHECKOUT"',
+            script,
+        )
+        self.assertIn('git clone --quiet --no-local "$SOURCE_ROOT"', script)
+        self.assertIn(
+            'git -C "$MANAGED_SOURCE_ROOT" fetch --quiet --no-tags',
+            script,
+        )
+        self.assertIn(
+            'git -C "$MANAGED_SOURCE_ROOT" merge --quiet --ff-only FETCH_HEAD',
+            script,
+        )
+        self.assertIn('remote set-url origin "$source_remote_url"', script)
+        self.assertIn('"branch.$managed_branch.merge" "refs/heads/$source_branch"', script)
+        self.assertIn('source_slug=', script)
+        self.assertIn('source_slug="${source_slug%.git}"', script)
+        self.assertIn('MANAGED_SOURCE_ROOT="$INSTALL_PARENT/source-$source_slug"', script)
+        self.assertIn('Preserving the existing managed checkout at:', script)
+        self.assertIn("Token Meter installation complete.", script)
+        self.assertNotIn('exec "$INSTALL_ROOT/scripts/install-launch-agent"', script)
+
+    def test_installers_show_progress_during_long_waits_and_always_clean_up(self):
+        root = Path(__file__).resolve().parents[1]
+        for name in ("install", "install-linux"):
+            with self.subTest(installer=name):
+                script = (root / "scripts" / name).read_text()
+                intro = script.index(
+                    'echo "Indexing local agent history (first run can take a few minutes)\u2026"'
+                )
+                start = script.index('progress_start "Indexing local agent history" "Still indexing\u2026"')
+                readiness = script.index('readiness_deadline=$((SECONDS + READINESS_TIMEOUT_SECONDS))')
+                done = script.index('progress_done "Server ready"')
+                self.assertLess(intro, start)
+                self.assertLess(start, readiness)
+                self.assertLess(readiness, done)
+                self.assertIn("if [ -t 1 ]; then", script)
+                self.assertIn("frames=(\u280b \u2819 \u2839 \u2838 \u283c \u2834 \u2826 \u2827 \u2807 \u280f)", script)
+                self.assertIn('while kill -0 "$parent" 2>/dev/null; do', script)
+                # The macOS installer also stops its background menu bar build.
+                cleanup = "install_cleanup" if name == "install" else "progress_stop"
+                self.assertIn(f"trap {cleanup} EXIT", script)
+                self.assertIn(f"trap '{cleanup}; trap - INT; kill -INT $$' INT", script)
+                self.assertIn(f"trap '{cleanup}; trap - TERM; kill -TERM $$' TERM", script)
+                self.assertIn('fail() {\n  progress_stop\n  echo "Token Meter installation failed: $*" >&2', script)
+                self.assertNotIn("\\033", script)
+                self.assertIn("the local server did not finish indexing within ${READINESS_TIMEOUT_SECONDS}s at $HEALTH_URL.", script)
+        mac = (root / "scripts" / "install").read_text()
+        self.assertIn('install_cleanup() {\n  progress_stop\n  stop_menubar_build\n}', mac)
+        # The companion compiles in the background while the server indexes,
+        # but only when a toolchain is already installed: probing goes through
+        # `xcode-select -p`, which never opens Apple's install dialog.
+        self.assertIn('developer_dir="$(xcode-select -p 2>/dev/null)" || return 1', mac)
+        readiness = mac.index("readiness_deadline=$((SECONDS + READINESS_TIMEOUT_SECONDS))")
+        early_start = mac.index("  if swift_toolchain_installed; then\n    start_menubar_build\n  fi")
+        self.assertLess(early_start, readiness)
+        self.assertNotIn("swiftc", mac[mac.index("install_cleanup() {"):readiness])
+        build_check = mac.index('"$INSTALL_ROOT/scripts/run-menubar" --check')
+        self.assertIn('MENUBAR_BUILD_PID=$!', mac[build_check:build_check + 200])
+        build_intro = mac.index(
+            'echo "Building the menu bar companion (first build compiles Swift, ~1 min)\u2026"'
+        )
+        build_start = mac.index('progress_start "Building the menu bar companion" "Still building\u2026"')
+        build_wait = mac.index('wait "$MENUBAR_BUILD_PID" || menubar_check_status=$?')
+        build_stop = mac.index("progress_stop", build_wait)
+        self.assertLess(build_start, build_wait)
+        build_fail = mac.index(
+            'fail "the native companion cannot build with the installed Swift toolchain and macOS SDKs."'
+        )
+        build_done = mac.index('progress_done "Menu bar companion ready"')
+        self.assertLess(build_intro, build_start)
+        self.assertLess(build_wait, build_stop)
+        self.assertLess(build_stop, build_fail)
+        self.assertLess(build_fail, build_done)
+
+    def test_update_helper_requires_clean_fast_forward_then_reuses_installer(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "update").read_text()
+        self.assertIn("git -C \"$SOURCE_ROOT\" fetch --quiet --prune --no-tags", script)
+        self.assertIn("git -C \"$SOURCE_ROOT\" status --porcelain", script)
+        self.assertIn("git -C \"$SOURCE_ROOT\" merge --ff-only '@{upstream}'", script)
+        self.assertIn('branch="$(git -C "$SOURCE_ROOT" rev-parse --abbrev-ref HEAD', script)
+        self.assertIn('[[ "$branch" != "main" || "${upstream##*/}" != "main" ]]', script)
+        self.assertIn('TOKEN_METER_UPDATE_RETRY_REVISION', script)
+        self.assertIn('record["failed_revision"]', script)
+        self.assertIn('INSTALL_SCRIPT="$SOURCE_ROOT/scripts/install"', script)
+        self.assertIn('INSTALL_SCRIPT="$SOURCE_ROOT/scripts/install-linux"', script)
+        self.assertIn('TOKEN_METER_INSTALL_ROOT="$RUNTIME_ROOT" "$INSTALL_SCRIPT"', script)
+        self.assertNotIn("reset --hard", script)
+        self.assertNotIn("sudo ", script)
+
+    def test_update_entrypoint_dispatches_linux_to_linux_helper(self):
+        root = Path(__file__).resolve().parents[1]
+        entrypoint = (root / "scripts" / "update").read_text()
+        linux_helper = (root / "scripts" / "update-linux").read_text()
+        manifest = (root / "runtime-manifest.txt").read_text()
+
+        self.assertIn('case "$(uname -s)" in', entrypoint)
+        self.assertIn('LINUX_HELPER="$ENTRYPOINT_ROOT/scripts/update-linux"', entrypoint)
+        self.assertIn('[[ ! -x "$LINUX_HELPER" ]]', entrypoint)
+        self.assertIn('"error_code": "linux_helper_unavailable"', entrypoint)
+        self.assertIn('exec env TOKEN_METER_UPDATE_LINUX_HELPER=1 "$LINUX_HELPER" "$@"', entrypoint)
+        self.assertIn('Darwin)', entrypoint)
+        self.assertIn('supported platforms are macOS and Linux.', entrypoint)
+        self.assertIn('[[ "$(uname -s)" == "Linux" ]]', linux_helper)
+        self.assertIn(
+            'exec env TOKEN_METER_UPDATE_LINUX_HELPER=1 "$ENTRYPOINT_ROOT/scripts/update" "$@"',
+            linux_helper,
+        )
+        self.assertNotIn('git -C "$SOURCE_ROOT"', linux_helper)
+        self.assertIn('required scripts/update-linux', manifest)
+
+    def test_windows_update_helper_requires_main_and_supports_failed_retry(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "update-windows.ps1").read_text()
+        self.assertIn('$Branch = (Get-GitText @("-C", $SourceRoot, "rev-parse", "--abbrev-ref", "HEAD"))', script)
+        self.assertIn('$Branch -ne "main"', script)
+        self.assertIn('$env:TOKEN_METER_UPDATE_RETRY_REVISION', script)
+        self.assertIn('failed_revision =', script)
+
+    def test_launch_agents_supervise_server_and_menu_bar_independently(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "install-launch-agent").read_text()
+        self.assertIn('SERVER_LABEL="com.token-meter.server"', script)
+        self.assertIn('MENUBAR_LABEL="com.token-meter.menubar"', script)
+        self.assertIn("<string>$SERVER_PROGRAM</string>", script)
+        self.assertIn("<string>$MENUBAR_PROGRAM</string>", script)
+        self.assertIn("Verify the replacement survives that", script)
+        self.assertGreaterEqual(
+            script.count('launchctl print "gui/$UID/$label"'), 3,
+        )
+        self.assertEqual(script.count("<key>KeepAlive</key>"), 2)
+        self.assertEqual(script.count("<key>SuccessfulExit</key>"), 1)
+        self.assertEqual(script.count("<key>SuccessfulExit</key>\n    <false/>"), 1)
+        self.assertNotIn("start-token-meter", script)
+        self.assertIn("all|server-only|menubar-only", script)
+        self.assertIn("server-only)", script)
+        self.assertIn("menubar-only)", script)
+        self.assertNotIn("kickstart -k", script)
+        self.assertIn("attempt <= 10", script)
+        self.assertIn('launchctl print "gui/$UID/$label"', script)
+        self.assertIn("sleep 0.2", script)
+        for label in ("SERVER_LABEL", "MENUBAR_LABEL"):
+            self.assertIn(f'launchctl bootout "gui/$UID/${label}"', script)
+
+    def test_foreground_launcher_waits_for_indexing_before_starting_menubar(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "start-token-meter").read_text()
+        readiness_check = script.index('"state_ready": true')
+        menubar_start = script.index('exec "$ROOT/scripts/run-menubar"')
+        self.assertLess(readiness_check, menubar_start)
+        self.assertIn('TOKEN_METER_READINESS_TIMEOUT_SECONDS:-600', script)
+        self.assertIn('curl -fsS --max-time 5 "$HEALTH_URL"', script)
+        self.assertNotIn('curl -fsS --max-time 1 "$HEALTH_URL"', script)
+
+    def test_uninstaller_removes_both_supervised_jobs(self):
+        root = Path(__file__).resolve().parents[1]
+        script = (root / "scripts" / "uninstall-launch-agent").read_text()
+        self.assertIn('launchctl bootout "gui/$UID/$SERVER_LABEL"', script)
+        self.assertIn('launchctl bootout "gui/$UID/$MENUBAR_LABEL"', script)
+        self.assertIn('rm -f "$MENUBAR_PLIST" "$SERVER_PLIST"', script)
+
+    def test_linux_installer_uses_xdg_runtime_systemd_and_appindicator_tray(self):
+        root = Path(__file__).resolve().parents[1]
+        entrypoint = (root / "scripts" / "install").read_text()
+        installer = (root / "scripts" / "install-linux").read_text()
+        systemd = (root / "scripts" / "install-systemd-user").read_text()
+        runner = (root / "scripts" / "run-menubar").read_text()
+        tray = (root / "menubar" / "token_meter_tray.py").read_text()
+        self.assertIn('exec "$SOURCE_ROOT/scripts/install-linux" "$@"', entrypoint)
+        self.assertNotIn("install-systemd-user", entrypoint)
+        self.assertNotIn("launchctl", installer)
+        self.assertNotIn("install-launch-agent", installer)
+        self.assertIn("XDG_DATA_HOME", installer)
+        self.assertIn("install-systemd-user", installer)
+        self.assertIn('"$INSTALL_ROOT/scripts/install-systemd-user" server-only', installer)
+        self.assertIn('"$INSTALL_ROOT/scripts/install-systemd-user" menubar-only', installer)
+        self.assertIn("systemctl --user is-active", installer)
+        self.assertIn("token-meter-server.service", systemd)
+        self.assertIn("token-meter-tray.service", systemd)
+        self.assertIn("all|server-only|menubar-only", systemd)
+        self.assertEqual(systemd.count("Restart=on-failure"), 2)
+        self.assertIn("Linux)", runner)
+        self.assertIn("AyatanaAppIndicator3", tray)
+        self.assertIn("AppIndicator3", tray)
+        self.assertIn("XDG_CONFIG_HOME", tray)
+        self.assertIn("refresh_menu_content", tray)
+        self.assertIn("self.indicator.set_menu(self.menu)", tray)
+        self.assertNotIn("self.indicator.set_menu(menu)", tray)
+        self.assertIn("Recent sessions", tray)
+        self.assertIn("Provider limits", tray)
+        self.assertIn("Open Budget Settings", tray)
+        self.assertIn("Menu bar title", tray)
+        self.assertIn("def open_dashboard(self):", tray)
+
+    def test_linux_runtime_uses_xdg_desktop_and_trash_paths(self):
+        if not meter.IS_LINUX:
+            self.skipTest("Linux-specific default paths")
+        self.assertTrue(meter.CURSOR_STATE_DB.startswith(meter.XDG_CONFIG_HOME))
+        self.assertTrue(all(path.startswith(meter.XDG_CONFIG_HOME)
+                            for path in meter.CLAUDE_DESKTOP_DATA_ROOTS))
+        self.assertEqual(meter.session_action_capability()["destination"], "Trash")
+
+
+class RemovedAgentDefaultsEndpointTests(unittest.TestCase):
+    def test_removed_agent_defaults_endpoint_returns_not_found(self):
+        for method in ("do_GET", "do_POST"):
+            with self.subTest(method=method):
+                handler = object.__new__(meter.H)
+                handler.path = "/settings/agent-defaults"
+                errors, responses = [], []
+                handler.send_error = lambda status: errors.append(status)
+                handler._send = lambda *args, **kwargs: responses.append((args, kwargs))
+                handler.headers = {"Host": "127.0.0.1:8722"}
+                getattr(handler, method)()
+                self.assertEqual(errors, [404])
+                self.assertEqual(responses, [])
+
+
+@unittest.skip("Agent defaults feature removed")
+class AgentDefaultSettingsTests(unittest.TestCase):
+    def test_agent_default_status_does_not_project_model_configuration(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text(
+                'model = "existing-codex-model"\nmodel_reasoning_effort = "high"\n'
+            )
+            claude_path.write_text(json.dumps({
+                "model": "existing-claude-model",
+                "modelOverrides": {"alias": "existing-provider-model"},
+                "effortLevel": "high",
+            }))
+
+            status = meter.agent_default_settings(
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+
+        serialized = json.dumps(status)
+        for client in status["clients"]:
+            self.assertNotIn("model", client["defaults"])
+            self.assertNotIn("hidden_model", client)
+        for configured_model in (
+            "existing-codex-model", "existing-claude-model", "existing-provider-model",
+        ):
+            self.assertNotIn(configured_model, serialized)
+
+    def test_saving_agent_behavior_defaults_preserves_existing_model_configuration(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text(
+                'model = "existing-codex-model"\nmodel_reasoning_effort = "low"\n'
+            )
+            claude_path.write_text(json.dumps({
+                "model": "existing-claude-model",
+                "modelOverrides": {"alias": "existing-provider-model"},
+                "effortLevel": "low",
+            }))
+
+            codex = meter.set_agent_default_settings(
+                "codex", {
+                    "model": "legacy-request-model", "preserve_model": False,
+                    "reasoning_effort": "high", "context_limit": 128000,
+                },
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            claude = meter.set_agent_default_settings(
+                "claude", {
+                    "model": "legacy-request-model", "preserve_model": False,
+                    "reasoning_effort": "xhigh", "context_limit": 500000,
+                },
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            codex_text = codex_path.read_text()
+            claude_json = json.loads(claude_path.read_text())
+
+        self.assertIn('model = "existing-codex-model"', codex_text)
+        self.assertEqual(claude_json["model"], "existing-claude-model")
+        self.assertEqual(
+            claude_json["modelOverrides"], {"alias": "existing-provider-model"},
+        )
+        self.assertNotIn("model", codex["defaults"])
+        self.assertNotIn("model", claude["defaults"])
+
+    def test_agent_default_save_rejects_concurrent_model_changes_without_overwriting(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text(
+                'model = "initial-codex-model"\nmodel_reasoning_effort = "low"\n'
+            )
+            claude_path.write_text(json.dumps({
+                "model": "initial-claude-model",
+                "modelOverrides": {"alias": "initial-provider-model"},
+                "effortLevel": "low",
+            }))
+            original_write = meter.atomic_write_text
+
+            def concurrent_codex_write(path, text, *args, **kwargs):
+                codex_path.write_text(
+                    codex_path.read_text().replace(
+                        "initial-codex-model", "concurrent-codex-model",
+                    )
+                )
+                return original_write(path, text, *args, **kwargs)
+
+            with mock.patch.object(
+                    meter, "atomic_write_text", side_effect=concurrent_codex_write):
+                codex = meter.set_agent_default_settings(
+                    "codex", {"reasoning_effort": "high", "context_limit": 128000},
+                    codex_config=str(codex_path), claude_settings=str(claude_path),
+                )
+
+            def concurrent_claude_write(path, text, *args, **kwargs):
+                concurrent = json.loads(claude_path.read_text())
+                concurrent["model"] = "concurrent-claude-model"
+                concurrent["modelOverrides"] = {"alias": "concurrent-provider-model"}
+                claude_path.write_text(json.dumps(concurrent))
+                return original_write(path, text, *args, **kwargs)
+
+            with mock.patch.object(
+                    meter, "atomic_write_text", side_effect=concurrent_claude_write):
+                claude = meter.set_agent_default_settings(
+                    "claude", {"reasoning_effort": "xhigh", "context_limit": 500000},
+                    codex_config=str(codex_path), claude_settings=str(claude_path),
+                )
+
+            codex_text = codex_path.read_text()
+            claude_json = json.loads(claude_path.read_text())
+
+        self.assertFalse(codex["ok"])
+        self.assertFalse(claude["ok"])
+        self.assertIn('model = "concurrent-codex-model"', codex_text)
+        self.assertEqual(claude_json["model"], "concurrent-claude-model")
+        self.assertEqual(
+            claude_json["modelOverrides"], {"alias": "concurrent-provider-model"},
+        )
+        for secret in (
+            "concurrent-codex-model", "concurrent-claude-model",
+            "concurrent-provider-model",
+        ):
+            self.assertNotIn(secret, json.dumps({"codex": codex, "claude": claude}))
+
+    def test_codex_defaults_report_cli_scope(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text('model = "gpt-5.6-terra"\n')
+            claude_path.write_text("{}\n")
+
+            status = meter.agent_default_settings(
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            saved = meter.set_agent_default_settings(
+                "codex", {"reasoning_effort": "high", "context_limit": 128000},
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+
+        codex = status["clients"][0]
+        self.assertEqual(codex["scope"], "cli")
+        self.assertEqual(codex["label"], "Codex CLI")
+        self.assertEqual(saved["scope"], "cli")
+        self.assertIn("Codex CLI defaults saved", saved["message"])
+        self.assertNotIn("Desktop", saved["message"])
+
+    def test_agent_default_settings_update_only_the_supported_client_fields(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text(
+                '# Keep this comment.\nmodel = "old-model"\n'
+                'model_reasoning_effort = "low"\n\n'
+                '[mcp_servers.local]\ncommand = "keep-me"\n'
+            )
+            claude_path.write_text(json.dumps({
+                "model": "old-model",
+                "effortLevel": "low",
+                "env": {"KEEP": "value"},
+                "enabledPlugins": {"keep@personal": True},
+            }))
+
+            codex = meter.set_agent_default_settings(
+                "codex", {"reasoning_effort": "high", "context_limit": 128000},
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            claude = meter.set_agent_default_settings(
+                "claude", {"reasoning_effort": "xhigh", "context_limit": 500000},
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            codex_text = codex_path.read_text()
+            claude_json = json.loads(claude_path.read_text())
+
+        self.assertTrue(codex["ok"])
+        self.assertTrue(codex["verified"])
+        self.assertTrue(claude["ok"])
+        self.assertTrue(claude["verified"])
+        self.assertIn('model = "old-model"', codex_text)
+        self.assertIn('model_reasoning_effort = "high"', codex_text)
+        self.assertIn("model_context_window = 128000", codex_text)
+        self.assertIn('[mcp_servers.local]\ncommand = "keep-me"', codex_text)
+        self.assertEqual(claude_json["model"], "old-model")
+        self.assertEqual(claude_json["effortLevel"], "xhigh")
+        self.assertEqual(claude_json["env"], {
+            "KEEP": "value", "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "500000",
+        })
+        self.assertEqual(claude_json["enabledPlugins"], {"keep@personal": True})
+
+    def test_clearing_agent_default_settings_removes_only_the_saved_overrides(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text(
+                'model = "gpt-5.6-terra"\nmodel_reasoning_effort = "high"\n'
+                'model_context_window = 256000\n[features]\nskills = true\n'
+            )
+            claude_path.write_text(json.dumps({
+                "model": "claude-sonnet-4-6", "effortLevel": "high",
+                "env": {"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "256000", "KEEP": "value"},
+            }))
+
+            codex = meter.set_agent_default_settings(
+                "codex", {"reasoning_effort": "", "context_limit": None},
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            claude = meter.set_agent_default_settings(
+                "claude", {"reasoning_effort": "", "context_limit": None},
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+            codex_text = codex_path.read_text()
+            claude_json = json.loads(claude_path.read_text())
+
+        self.assertTrue(codex["ok"])
+        self.assertTrue(claude["ok"])
+        self.assertIn('model = "gpt-5.6-terra"', codex_text)
+        self.assertNotIn("model_reasoning_effort", codex_text)
+        self.assertNotIn("model_context_window", codex_text)
+        self.assertIn("[features]\nskills = true", codex_text)
+        self.assertEqual(claude_json["model"], "claude-sonnet-4-6")
+        self.assertNotIn("effortLevel", claude_json)
+        self.assertEqual(claude_json["env"], {"KEEP": "value"})
+
+    def test_agent_default_settings_reject_an_invalid_context_limit_without_writing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text('model = "keep"\n')
+            claude_path.write_text(json.dumps({"model": "keep"}))
+
+            result = meter.set_agent_default_settings(
+                "claude", {"reasoning_effort": "high", "context_limit": 99999},
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+
+            codex_text = codex_path.read_text()
+            claude_json = json.loads(claude_path.read_text())
+
+        self.assertFalse(result["ok"])
+        self.assertIn("Context limit", result["error"])
+        self.assertEqual(codex_text, 'model = "keep"\n')
+        self.assertEqual(claude_json, {"model": "keep"})
+
+    def test_agent_default_settings_reject_a_fractional_context_limit_without_writing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            claude_path = Path(tmp) / "settings.json"
+            claude_path.write_text(json.dumps({"model": "keep"}))
+
+            result = meter.set_agent_default_settings(
+                "claude", {"reasoning_effort": "high", "context_limit": 128000.5},
+                claude_settings=str(claude_path),
+            )
+
+            claude_json = json.loads(claude_path.read_text())
+
+        self.assertFalse(result["ok"])
+        self.assertIn("whole number", result["error"])
+        self.assertEqual(claude_json, {"model": "keep"})
+
+    def test_agent_defaults_accept_only_documented_persistent_reasoning_efforts(self):
+        for effort in ("minimal", "low", "medium", "high", "xhigh"):
+            with self.subTest(effort=effort):
+                defaults = meter.normalize_agent_default_settings(
+                    "codex", {"reasoning_effort": effort, "context_limit": 128000},
+                )
+                self.assertEqual(defaults["reasoning_effort"], effort)
+        for client, efforts in (("codex", ("none", "max", "ultra")),
+                                ("claude", ("minimal", "none", "max", "ultra"))):
+            for effort in efforts:
+                with self.subTest(client=client, effort=effort):
+                    with self.assertRaisesRegex(ValueError, "not supported"):
+                        meter.normalize_agent_default_settings(
+                            client, {"reasoning_effort": effort, "context_limit": 128000},
+                        )
+
+    def test_codex_agent_defaults_preserve_triple_quoted_root_content_and_hashes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            codex_path.write_text(
+                'developer_instructions = """\n[keep this literal instruction]\n"""\n'
+                'model = "gpt#old"\n[features]\nskills = true\n'
+            )
+
+            result = meter.set_agent_default_settings(
+                "codex", {"reasoning_effort": "minimal", "context_limit": 128000},
+                codex_config=str(codex_path),
+            )
+            text = codex_path.read_text()
+
+        self.assertTrue(result["ok"])
+        self.assertIn('developer_instructions = """\n[keep this literal instruction]\n"""', text)
+        self.assertIn('model = "gpt#old"', text)
+        self.assertLess(text.index("model_context_window = 128000"), text.index("[features]"))
+        self.assertIn("[features]\nskills = true", text)
+
+    def test_codex_agent_defaults_preserve_multiline_arrays_before_tables(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            codex_path.write_text('matrix = [\n  [1, 2]\n]\n[features]\nskills = true\n')
+
+            result = meter.set_agent_default_settings(
+                "codex", {"reasoning_effort": "minimal", "context_limit": 128000},
+                codex_config=str(codex_path),
+            )
+            text = codex_path.read_text()
+
+        self.assertTrue(result["ok"])
+        self.assertIn("matrix = [\n  [1, 2]\n]\n", text)
+        self.assertLess(text.index("model_context_window = 128000"), text.index("[features]"))
+        self.assertIn("[features]\nskills = true", text)
+
+    def test_agent_default_status_redacts_unvalidated_or_sensitive_config_values(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            codex_path = Path(tmp) / "config.toml"
+            claude_path = Path(tmp) / "settings.json"
+            codex_path.write_text('model = "/very/secret/path"\nmodel_reasoning_effort = "secret"\n')
+            claude_path.write_text(json.dumps({
+                "model": "arn:aws:bedrock:private-account:application/profile",
+                "effortLevel": "super-secret-token",
+                "env": {"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "999999999999999999999"},
+            }))
+
+            status = meter.agent_default_settings(
+                codex_config=str(codex_path), claude_settings=str(claude_path),
+            )
+
+        serialized = json.dumps(status)
+        self.assertEqual(status["clients"][0]["defaults"], {
+            "reasoning_effort": None, "context_limit": None,
+        })
+        self.assertEqual(status["clients"][1]["defaults"], {
+            "reasoning_effort": None, "context_limit": None,
+        })
+        for secret in ("/very/secret/path", "private-account", "super-secret-token", "999999999999999999999"):
+            self.assertNotIn(secret, serialized)
+
+    def test_legacy_model_fields_are_ignored_when_saving_other_defaults(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            claude_path = Path(tmp) / "settings.json"
+            hidden_model = "arn:aws:bedrock:private-account:application/profile"
+            claude_path.write_text(json.dumps({"model": hidden_model, "effortLevel": "high"}))
+
+            result = meter.set_agent_default_settings(
+                "claude", {"model": "", "preserve_model": True, "reasoning_effort": "xhigh",
+                           "context_limit": 500000},
+                claude_settings=str(claude_path),
+            )
+            saved = json.loads(claude_path.read_text())
+
+        self.assertTrue(result["ok"])
+        self.assertEqual(saved["model"], hidden_model)
+        self.assertEqual(saved["effortLevel"], "xhigh")
+        self.assertNotIn("private-account", json.dumps(result))
+
+
+if __name__ == "__main__":
+    unittest.main()

From 1638eb342186f6d146099c86c9a6ff801e8176a6 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 08:58:57 +0530
Subject: [PATCH 5/9] refactor(app): move leaf helpers out of app.py into
 app_helpers/

app.py was 631 KB. Move 421 top-level functions and constants (about
150 KB) into 12 modules under token_meter/app_helpers/ (trace parsing for
Claude, Codex, and Cursor, normalization, the menu-bar payload, config-file
parsing, and shared leaf helpers). app.py re-exports every moved name, so
meter.NAME and token_meter.app.NAME are unchanged.

Only code that is safe to move moved. A dependency analysis kept in app.py
anything that tests patch through meter (including patched imported modules
such as meter.threading), anything declared global or rebound, anything that
reads __file__ or sys.modules, and anything that depends on those. Helper
modules may import only app_helpers.common, never app.py; a guard test
enforces this. The composition guards now cover the helpers too, and the
app.py size ceiling drops to 510 KB.

Function bodies are moved verbatim; the full suite passes unchanged.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 AGENTS.md                                     |    1 +
 specs/AGENTS.md                               |    1 +
 specs/ARCHITECTURE.md                         |    8 +
 tests/contracts/test_architecture_guards.py   |   14 +-
 tests/contracts/test_kiro_extension_budget.py |    3 +-
 tests/contracts/test_source_size_budget.py    |    2 +-
 token_meter/app.py                            | 4776 ++---------------
 token_meter/app_helpers/__init__.py           |    7 +
 token_meter/app_helpers/agents.py             |  113 +
 token_meter/app_helpers/capabilities.py       |  149 +
 token_meter/app_helpers/claude_traces.py      |  312 ++
 token_meter/app_helpers/codex_traces.py       |  382 ++
 token_meter/app_helpers/common.py             | 2112 ++++++++
 token_meter/app_helpers/config_files.py       |  164 +
 token_meter/app_helpers/cursor_traces.py      |  354 ++
 token_meter/app_helpers/menubar_payload.py    |  354 ++
 token_meter/app_helpers/normalize.py          |  449 ++
 token_meter/app_helpers/pacing.py             |   54 +
 token_meter/app_helpers/pricing_values.py     |  101 +
 token_meter/app_helpers/settings_values.py    |   41 +
 20 files changed, 5156 insertions(+), 4241 deletions(-)
 create mode 100644 token_meter/app_helpers/__init__.py
 create mode 100644 token_meter/app_helpers/agents.py
 create mode 100644 token_meter/app_helpers/capabilities.py
 create mode 100644 token_meter/app_helpers/claude_traces.py
 create mode 100644 token_meter/app_helpers/codex_traces.py
 create mode 100644 token_meter/app_helpers/common.py
 create mode 100644 token_meter/app_helpers/config_files.py
 create mode 100644 token_meter/app_helpers/cursor_traces.py
 create mode 100644 token_meter/app_helpers/menubar_payload.py
 create mode 100644 token_meter/app_helpers/normalize.py
 create mode 100644 token_meter/app_helpers/pacing.py
 create mode 100644 token_meter/app_helpers/pricing_values.py
 create mode 100644 token_meter/app_helpers/settings_values.py

diff --git a/AGENTS.md b/AGENTS.md
index 5a8edf9f..a31a0b60 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -19,6 +19,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 |---|---|
 | `meter.py` | Small executable/import compatibility facade for `token_meter.app` |
 | `token_meter/app.py` | Composition, compatibility exports, settings, and application lifecycle |
+| `token_meter/app_helpers/` | Leaf helpers moved out of `app.py`; `app.py` re-exports them. Find a name's home from `app.py`'s `app_helpers` imports |
 | `token_meter/runtimes/` | Registered runtime discovery, parsing, revisions, and safe projections |
 | `token_meter/platforms/` | Host paths, process/update policy, and trash behavior |
 | `token_meter/domain/` | Runtime-neutral usage, timing, tools, insights, and aggregates |
diff --git a/specs/AGENTS.md b/specs/AGENTS.md
index 63861834..107efee6 100644
--- a/specs/AGENTS.md
+++ b/specs/AGENTS.md
@@ -17,6 +17,7 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 |---|---|
 | `meter.py` | Small executable/import compatibility facade for `token_meter.app` |
 | `token_meter/app.py` | Composition, compatibility exports, settings, and application lifecycle |
+| `token_meter/app_helpers/` | Leaf helpers moved out of `app.py`; `app.py` re-exports them. Find a name's home from `app.py`'s `app_helpers` imports |
 | `token_meter/runtimes/` | Registered runtime discovery, parsing, revisions, and safe projections |
 | `token_meter/platforms/` | Host paths, process/update policy, and trash behavior |
 | `token_meter/domain/` | Runtime-neutral usage, timing, tools, insights, and aggregates |
diff --git a/specs/ARCHITECTURE.md b/specs/ARCHITECTURE.md
index 8c0e1a34..797790d0 100644
--- a/specs/ARCHITECTURE.md
+++ b/specs/ARCHITECTURE.md
@@ -36,6 +36,13 @@ The server binds to `127.0.0.1:8722`. `meter.py` is intentionally only an
 executable and import-compatibility facade; current composition lives in
 `token_meter/app.py`.
 
+Code that tests patch through `meter.NAME` (or that reads a patched name) stays
+in `app.py`: a patch replaces the name in `app.py`'s namespace only, so moving
+such code to another module would silently bypass the patch. To move more out,
+first change those tests to patch the owning module. Source files have a size
+budget (`tests/contracts/test_source_size_budget.py`): new files stay under
+80 KB, and existing larger files have a ceiling that may only drop.
+
 ## Responsibility Boundaries
 
 | Area | Owner | Responsibility |
@@ -47,6 +54,7 @@ executable and import-compatibility facade; current composition lives in
 | Provider limits | `token_meter/quotas/` | Make bounded, read-only account-usage requests and normalize available quota windows. |
 | Operating-system behavior | `token_meter/platforms/` | Own host paths, process policy, updates, service integration, and recoverable trash behavior. |
 | Application lifecycle | `token_meter/app.py`, `token_meter/services/` | Compose registries, manage caches/settings/watchers, and serve application jobs. |
+| Composition helpers | `token_meter/app_helpers/` | Leaf helpers extracted from `app.py` (trace parsing, normalization, menu-bar payload, config files). They import only the standard library, other packages, and `app_helpers.common`; `app.py` re-exports every name, so `meter.NAME` is unchanged. |
 | Goals | `token_meter/services/goals.py`, `token_meter/models/tiers.py` | Validate local metric goals and measure them deterministically from complete scoped rows and explicit Git windows; the browser and menu bar render these results and never recompute them. See [Goals](GOALS.md). |
 | Public projections | `token_meter/projections.py` | Allowlist fields for session, state, model, browser-only agent, menu-bar, and MCP consumers. |
 | MCP query layer | `token_meter/mcp/` | Validate filters, bind opaque cursors to query revisions, positively allowlist standardized and native-structure fields, aggregate metrics, and publish schema metadata. |
diff --git a/tests/contracts/test_architecture_guards.py b/tests/contracts/test_architecture_guards.py
index eebe627a..12809f93 100644
--- a/tests/contracts/test_architecture_guards.py
+++ b/tests/contracts/test_architecture_guards.py
@@ -10,14 +10,24 @@
 
 class ArchitectureGuardTests(unittest.TestCase):
     def test_composition_contains_no_superseded_legacy_function_bodies(self):
-        tree = ast.parse((ROOT / "token_meter" / "app.py").read_text(encoding="utf-8"))
+        composition = [ROOT / "token_meter" / "app.py", *(ROOT / "token_meter" / "app_helpers").glob("*.py")]
         names = [
-            node.name for node in tree.body
+            node.name
+            for path in composition
+            for node in ast.parse(path.read_text(encoding="utf-8")).body
             if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
             and node.name.startswith("_legacy_")
         ]
         self.assertEqual(names, [])
 
+    def test_app_helpers_never_import_the_composition_module(self):
+        # app.py re-exports every helper name; an import back would be circular
+        # and would let helpers depend on names tests patch on ``meter``.
+        for path in (ROOT / "token_meter" / "app_helpers").glob("*.py"):
+            source = path.read_text(encoding="utf-8")
+            self.assertNotRegex(source, r"from token_meter import app\b|import token_meter\.app\b|^import meter", path)
+            self.assertNotIn("from token_meter.app import", source, path)
+
     def test_shared_domain_services_and_web_have_no_runtime_dispatch_conditionals(self):
         paths = [
             *(ROOT / "token_meter" / "domain").glob("*.py"),
diff --git a/tests/contracts/test_kiro_extension_budget.py b/tests/contracts/test_kiro_extension_budget.py
index b9e65988..597d346e 100644
--- a/tests/contracts/test_kiro_extension_budget.py
+++ b/tests/contracts/test_kiro_extension_budget.py
@@ -24,7 +24,8 @@ def test_shared_domain_platform_http_and_generic_clients_need_no_kiro_branch(sel
             self.assertNotRegex(source, r"\b(?:if|elif|case|switch)\b[^\n]{0,120}\bkiro\b", path)
 
     def test_composition_contains_no_kiro_runtime_dispatch_condition(self):
-        source = (ROOT / "token_meter" / "app.py").read_text().lower()
+        composition = [ROOT / "token_meter" / "app.py", *(ROOT / "token_meter" / "app_helpers").glob("*.py")]
+        source = "\n".join(path.read_text().lower() for path in composition)
         self.assertIsNone(re.search(
             r"\b(?:if|elif)\b[^\n]{0,120}(?:provider|runtime|client)[^\n]{0,80}\bkiro\b",
             source,
diff --git a/tests/contracts/test_source_size_budget.py b/tests/contracts/test_source_size_budget.py
index 1f876897..17188834 100644
--- a/tests/contracts/test_source_size_budget.py
+++ b/tests/contracts/test_source_size_budget.py
@@ -20,7 +20,7 @@
 # Ceilings are about 5% above each file's size when the budget was introduced,
 # so normal maintenance still fits. This dict may only shrink.
 LEGACY_CEILINGS = {
-    "token_meter/app.py": 663_000,
+    "token_meter/app.py": 510_000,
     "tests/test_work_insights.py": 236_000,
     "menubar/TokenMeterMenuBar.swift": 148_000,
     "tests/test_git_delivery.py": 141_000,
diff --git a/token_meter/app.py b/token_meter/app.py
index af59cbf4..05853b9a 100644
--- a/token_meter/app.py
+++ b/token_meter/app.py
@@ -54,6 +54,449 @@
 _SOURCE_ROOT = os.path.dirname(os.path.dirname(IMPLEMENTATION_FILE))
 
 from token_meter import dashboard_page
+from token_meter.app_helpers.agents import (
+    AGENT_USAGE_WINDOWS,
+    CLAUDE_CODE_CLIENT,
+    _agent_access_matches,
+    _agent_skill_part,
+    agent_access_command_display,
+    agent_as_of,
+    agent_cli_error_detail,
+    agent_project_key,
+    agent_project_name,
+    agent_usage_day_keys,
+    agent_usage_tool_categories,
+)
+from token_meter.app_helpers.capabilities import (
+    SKILL_PATH_RE,
+    _ACTION_TOKEN,
+    _SKILL_EMPTY_CAPABILITY_VALUES,
+    _capability_scan_label,
+    _skill_capability_value_is_nonempty,
+    _skill_dir_names,
+    _skill_frontmatter,
+    _skill_frontmatter_key,
+    capability_action_capability,
+    capability_content_revision,
+    capability_control_groups,
+    capability_summary_payload,
+    skill_identity,
+    skill_names_from_value,
+)
+from token_meter.app_helpers.claude_traces import (
+    _CLAUDE_FAST_STANDARD_RULES,
+    _CLAUDE_INFERENCE_GEO_RULES,
+    _claude_app_stuck,
+    _claude_desktop_entry_matches,
+    _claude_effective_duration,
+    _claude_human_text,
+    _claude_part_todo,
+    _claude_quote_supports_dimensions,
+    _claude_user_prompt,
+    _claude_window,
+    claude_desktop_access_entry,
+    claude_tool_results,
+    claude_user_events,
+    claude_user_text,
+    claude_user_turns,
+    claude_wait_samples,
+)
+from token_meter.app_helpers.codex_traces import (
+    CODEX_AUTH,
+    _codex_fallback_user_text,
+    _codex_limit_label,
+    _codex_window,
+    codex_approval_policy_label,
+    codex_id_from_path,
+    codex_live_performance_summary,
+    codex_oauth_quota,
+    codex_performance_samples,
+    codex_usage,
+    codex_user_turns,
+    codex_wait_samples,
+    codex_work_actions,
+)
+from token_meter.app_helpers.common import (
+    AGENT_ACCESS_CLIENTS,
+    AGENT_ACCESS_SERVER,
+    AGENT_CHECK_FOCUS,
+    AGENT_CURRENT_MAX_AGE_S,
+    AGENT_RESULT_MAX_CHARS,
+    AGENT_SKILL_LABELS,
+    AGENT_USAGE_FOCUS,
+    BASE64_FIELD_RE,
+    BUDGET_ALERT_EXCLUDED_ESTIMATE_PROVIDERS,
+    BUDGET_API_FIELDS,
+    BUDGET_PROVIDERS,
+    BUILTIN_MODEL_PRICE_HISTORY,
+    CHARS_PER_TOKEN,
+    CLAUDE_APP_RUNNING_ERROR,
+    CLAUDE_APP_UNREADABLE_ERROR,
+    CLAUDE_CREDENTIALS,
+    CLAUDE_DESKTOP_CLIENT,
+    CLAUDE_ROOT_CONFIG,
+    COST_DISCOUNTS_SETTINGS_KEY,
+    COST_DISCOUNT_READ_ONLY_ERRORS,
+    CURRENT_SESSION_CONTEXT_SAMPLES,
+    CURRENT_SESSION_LIMIT,
+    CURRENT_SESSION_MAX_AGE_S,
+    CURRENT_SESSION_WORKING_S,
+    DATA_URL_RE,
+    DEFAULT_CLAUDE_MODEL,
+    DEFAULT_OPENAI_MODEL,
+    EXEC_LIMIT,
+    GIT_DELIVERY_INTERVAL_S,
+    GOAL_NATIVE_REFRESH_S,
+    HERMES_MODEL_IDENTITY_LABEL,
+    HISTORY_SOURCE_REUSE_S,
+    INSIGHT_CATEGORY_ORDER,
+    INSIGHT_KIND_SCORE,
+    INVALID_STORED_BUDGETS_ERROR,
+    LOW_YIELD_CONTEXT_PCT,
+    LOW_YIELD_COST,
+    LOW_YIELD_INPUT_TOKENS,
+    LOW_YIELD_RATIO,
+    MATCHED_PACE_CACHE_SCHEMA,
+    MATCHED_PACE_MIN_COVERAGE,
+    MATCHED_PACE_MIN_PAIRS,
+    MATCHED_PACE_WINDOW_KEYS,
+    MAX_COST_DISCOUNT_OPS,
+    MAX_CUSTOM_MODEL_PRICES,
+    MAX_MODEL_PRICE_CHANGES,
+    MAX_MODEL_PRICE_PERIODS,
+    MAX_PROJECT_SKILL_ROOTS,
+    MAX_SESSION_MODEL_IDENTITIES,
+    MODEL_PRICING_MTIME_TTL_S,
+    MODEL_PROJECT_OPTION_LIMIT,
+    NOTIFICATIONS_SCHEMA_VERSION,
+    NOTIFICATION_EVALUATE_INTERVAL_S,
+    OBSOLETE_SETTINGS_KEYS,
+    OPENCODE_UPSTREAM_MODEL_PROVIDERS,
+    OTHER_LOCAL_SESSIONS_PROJECT,
+    PLUGIN_ID_RE,
+    QUOTA_HTTP_TIMEOUT_S,
+    QUOTA_PROCESS_TIMEOUT_S,
+    QUOTA_REFRESH_S,
+    QUOTA_STALE_S,
+    READ_ONLY_SESSION_PROVIDERS,
+    SESSION_STATE_CACHE_LIMIT,
+    SKILL_NAME_RE,
+    TOKEN_METER_GIT_DELIVERY_DB,
+    TOKEN_METER_MCP_EVIDENCE_CACHE,
+    TOKEN_METER_SESSION_MODEL_IDENTITIES,
+    TOKEN_METER_UPDATE_STATUS,
+    TOOL_OVERSIZED_TOKENS,
+    TRACE_LIMIT,
+    TokenMeterHTTPServer,
+    UPDATE_FETCH_TIMEOUT_S,
+    UPDATE_REF_RE,
+    UPDATE_STALE_AFTER_S,
+    USER_TURN_CONTEXT_CHARS,
+    WORK_DRILL_ENUMS,
+    WORK_INSIGHTS_UNSUPPORTED_ERROR,
+    WORK_PAUSE_CHOICES,
+    _ABSENT,
+    _ACTIVITY_BOUNDED_PROVIDERS,
+    _API_TOKEN_RE,
+    _CLAUDE_FAST_PREMIUM_RULES,
+    _CONFIGURED_CAPABILITY_TTL_S,
+    _COST_DISCOUNT_OP_FIELDS,
+    _COST_DISCOUNT_RULE_FIELDS,
+    _COST_DISCOUNT_SERVER_FIELDS,
+    _CURRENT_SESSION_REBUILD_S,
+    _DASHBOARD_ASSETS,
+    _DASHBOARD_CROSS_SLOTS,
+    _ISO_UTC_SUFFIX_RE,
+    _MATCHED_PACE_COMPARISON_KEYS,
+    _MATCHED_PACE_FLOAT_FIELDS,
+    _MATCHED_PACE_INT_FIELDS,
+    _MATCHED_PACE_MAX_COUNT,
+    _MATCHED_PACE_MAX_RATIO,
+    _MATCHED_PACE_MAX_REASON,
+    _MATCHED_PACE_REASON_RE,
+    _PUBLIC_EVENT_FIELDS,
+    _SKILL_CATALOG_TTL_S,
+    _SKILL_MEASURABLE_KEYS,
+    _SOURCE_DISCOVERY_REFRESH_S,
+    _SOURCE_MEMBERSHIP_FALLBACK_S,
+    _SOURCE_MEMBERSHIP_PROBE_S,
+    _WORK_TURNS_HANDOFF_KEY,
+    _XSESS_LIVE_REFRESH_S,
+    _XSESS_TTL,
+    _agy_native_adapters,
+    _apply_cost_discount_op,
+    _apply_verified_session_identity,
+    _bootstrap_median_interval,
+    _browser_session_row,
+    _builder_recap_line_count,
+    _cache_pricing_provider,
+    _cached_price_query,
+    _claude_native_adapters,
+    _close_claude_user_pauses,
+    _compat_price_quote,
+    _config_stamp,
+    _configured_capability_cache,
+    _cost_discount_cache,
+    _cursor_native_adapters,
+    _dashboard_cross_cache,
+    _dashboard_cross_nonce,
+    _dedupe_user_turns,
+    _discount_rule_content,
+    _discount_scope,
+    _finalize_throughput_fields,
+    _goal_cache,
+    _goal_evidence_cache,
+    _has_scheduled_builtin_prices,
+    _history_scan,
+    _history_scan_failed,
+    _index_worker_pressure,
+    _is_child_agent_row,
+    _is_user_input_tool,
+    _kiro_native_adapters,
+    _last_model_price,
+    _matched_discount,
+    _matched_pace_build_state,
+    _matched_pace_cache,
+    _matched_pace_pair_cache,
+    _matching_price,
+    _merge_discount_rule,
+    _merge_execution_intervals,
+    _model_pricing_cache,
+    _new_cost_discount_id,
+    _notification_runtime,
+    _op_removes_stored_entry,
+    _opaque_session_identity_key,
+    _opencode_adapter_key,
+    _opencode_context_tokens,
+    _opencode_db_override,
+    _opencode_display_cost,
+    _opencode_distribute,
+    _opencode_int,
+    _opencode_json,
+    _opencode_reported_cost,
+    _opencode_usage,
+    _page_within_runtime,
+    _parse_iso_text,
+    _pause_until,
+    _percentile,
+    _physical_source_path,
+    _pricing_recalc,
+    _pricing_state,
+    _public_budget_settings,
+    _public_cost_discount_rule,
+    _quota_cache,
+    _quota_inflight,
+    _quota_loading_row,
+    _recursive_path_cache,
+    _reject_unknown_op_fields,
+    _reset_cost_discount_cache,
+    _safe_update_int,
+    _safe_update_revision,
+    _same_model_price_action,
+    _same_path,
+    _session_model_identity_parent_key,
+    _session_model_identity_revision,
+    _session_state_build_locks,
+    _session_state_cache,
+    _settings_file_locks,
+    _shared_index_pool,
+    _skill_catalog_cache,
+    _source_order_mtime,
+    _source_size,
+    _submitted_discount_fields,
+    _system_load_average,
+    _trace_path_key,
+    _track_claude_user_pause,
+    _valid_matched_pace_comparison,
+    _valid_matched_pace_entry,
+    _verified_agent_access_change,
+    _verified_identity_matches_source,
+    _wait_sample,
+    _window_start_ts,
+    _work_bucket_valid,
+    _work_label_since,
+    _work_source_keys,
+    _write_api_token,
+    add_model_daily,
+    add_model_summary,
+    agy_brain_dir_path,
+    analysis_block,
+    argument_fingerprint,
+    bounded_agent_result,
+    budget_settings_revision,
+    builtin_model_price_tables,
+    catalog_counts,
+    compact_agent_value,
+    compact_duration_ms,
+    compact_text,
+    cross_session_refresh_due,
+    current_session_refresh_due,
+    current_session_summaries,
+    daily_summaries,
+    dashboard_asset_content_type,
+    decode_claude_project,
+    decode_cursor_project,
+    discount_of,
+    duration_label,
+    enable_mcp_parallel_index,
+    enqueue_latest,
+    enrich_insights,
+    execution_low_yield,
+    file_signature,
+    fold_child_source,
+    folded_child_root_id,
+    git_delivery_project_roots,
+    git_delivery_source_signature,
+    hermes_state_db_path,
+    home_shorten,
+    insight,
+    insight_sort_key,
+    is_dashboard_page_path,
+    is_operational_warning,
+    local_dt,
+    local_tm,
+    low_yield_should_warn,
+    make_usage_provenance,
+    metric_availability,
+    metric_available,
+    metric_coverage,
+    missing_performance_html,
+    monthly_summaries,
+    new_codex_pending,
+    newest_current_source,
+    observable_output_chars,
+    optional_capability_summary,
+    page_bytes,
+    page_root,
+    parse_claude_quota,
+    parse_codex_quota,
+    parse_cursor_quota,
+    parse_iso,
+    performance_summary,
+    pi_work_actions,
+    project_filter_key,
+    reset_cursor_metadata_cache,
+    safe_execution_trace,
+    session_model_identity_key,
+    source_discovery_refresh_due,
+    source_identity_signature,
+    source_inventory_probe_signature,
+    source_membership_fallback_due,
+    source_membership_probe_due,
+    spend_log_summaries,
+    spend_projection,
+    summarize_tool_evidence,
+    sweep_orphaned_atomic_writes,
+    text_from_content,
+    tool_identity,
+    tool_result_is_error,
+    tool_summary,
+    trace_event,
+    trim_trace,
+    usage_io_tokens,
+    usage_provenance,
+    usage_tokens,
+    user_prompt_preview,
+    wait_time_summary,
+)
+from token_meter.app_helpers.config_files import (
+    _toml_comment_index,
+    _toml_is_table_header,
+    _toml_line_state,
+    _toml_line_structure,
+    _toml_root_assignment,
+    _toml_root_prefix,
+    _toml_root_scalar,
+    _toml_root_scalar_text,
+    toml_named_sections,
+)
+from token_meter.app_helpers.cursor_traces import (
+    CURSOR_SPAN_LEAD_S,
+    cursor_context_estimates,
+    cursor_enriched_groups,
+    cursor_message_content,
+    cursor_model,
+    cursor_model_call_count,
+    cursor_model_parameters,
+    cursor_price_variant,
+    cursor_pricing_note,
+    cursor_prompt_breakdown,
+    cursor_timestamp,
+    cursor_transcript_groups,
+    cursor_turn_timing,
+    cursor_user_turns,
+    cursor_visible_output,
+)
+from token_meter.app_helpers.menubar_payload import (
+    MENUBAR_CONTEXT_INTERVENE_PCT,
+    MENUBAR_CONTEXT_SOFT_PCT,
+    MENUBAR_CONTEXT_WATCH_PCT,
+    MENUBAR_COST_SPIKE,
+    menubar_activity,
+    menubar_cache_window,
+    menubar_context_pulse,
+    menubar_project_name,
+    menubar_recent_sessions,
+    menubar_recommendation,
+    menubar_session_name,
+    menubar_today_spend,
+    menubar_verdict,
+)
+from token_meter.app_helpers.normalize import (
+    DEFAULT_BUDGET_THRESHOLDS,
+    DEFAULT_MENUBAR_CACHE_TIMER,
+    DEFAULT_RUNTIME_BUDGET,
+    DEFAULT_SESSION_BUDGET,
+    MAX_MODEL_PRICE,
+    MAX_MONTHLY_BUDGET,
+    MAX_SESSION_BUDGETS,
+    MENUBAR_CACHE_TIMER_MODES,
+    MIN_SESSION_BUDGET,
+    MODEL_PRICE_PROVIDERS,
+    SESSION_CLAUDE_MODEL_ID_RE,
+    SESSION_MODEL_IDENTITY_KEY_RE,
+    UPDATE_CHECK_INTERVAL_S,
+    _normalize_model_price_change,
+    _normalize_model_price_history,
+    _normalize_model_price_revision,
+    _normalize_model_price_scope,
+    _normalize_session_model_identity_model,
+    _normalize_session_model_identity_revision,
+    _normalize_session_model_identity_user,
+    _normalize_session_model_identity_verified,
+    normalize_budget_settings,
+    normalize_dynamic_tools,
+    normalize_insights,
+    normalize_menubar_settings,
+    normalize_model_price,
+    normalize_model_price_id,
+    normalize_model_price_provider,
+    normalize_notification_settings,
+    normalize_session_budget_value,
+    normalize_update_settings,
+)
+from token_meter.app_helpers.pacing import (
+    _PACE_INPUT,
+    _PACE_LOG_INPUT,
+    _PACE_LOG_MODEL,
+    _PACE_LOG_PEAK,
+    _PACE_MODEL,
+    _PACE_OUTPUT,
+    _PACE_PEAK,
+    _PACE_PREFILTER_SLACK,
+    _PACE_TOOLS,
+    _pace_features,
+    _pace_samples_signature,
+)
+from token_meter.app_helpers.pricing_values import (
+    COST_DISCOUNTS_VERSION,
+    _cost_discount_state_from_raw,
+    _price_datetime,
+    _price_multipliers,
+    _price_query_from_compat,
+    _price_timestamp,
+)
+from token_meter.app_helpers.settings_values import _update_message
 from token_meter.compat import envelope_to_legacy_source, legacy_source_to_envelope
 from token_meter.contracts import (
     AdapterFailure,
@@ -318,14 +761,10 @@
 CLAUDE_DESKTOP_SESSIONS = os.path.join(CLAUDE_DESKTOP_DATA_ROOTS[0], "claude-code-sessions")
 CLAUDE_SETTINGS = os.path.expanduser("~/.claude/settings.json")
 CLAUDE_USER_SKILLS = os.path.expanduser("~/.claude/skills")
-MAX_PROJECT_SKILL_ROOTS = 64
-CLAUDE_ROOT_CONFIG = os.path.expanduser("~/.claude.json")
 CLAUDE_DESKTOP_CONFIGS = [os.path.join(root, "claude_desktop_config.json") for root in CLAUDE_DESKTOP_DATA_ROOTS]
 CODEX_SESSIONS = os.path.expanduser("~/.codex/sessions")
 CODEX_INDEX = os.path.expanduser("~/.codex/session_index.jsonl")
 CODEX_CONFIG = os.path.expanduser("~/.codex/config.toml")
-CODEX_AUTH = os.path.expanduser("~/.codex/auth.json")
-CLAUDE_CREDENTIALS = os.path.expanduser("~/.claude/.credentials.json")
 CURSOR_PROJECTS = os.path.expanduser("~/.cursor/projects")
 CURSOR_STATE_DB = _PLATFORM_PATHS.cursor_state_db
 CURSOR_REQUEST_LOGS = _PLATFORM_PATHS.cursor_request_logs
@@ -334,7 +773,6 @@
 # override is rooted below the OpenCode XDG data directory, matching OpenCode.
 OPENCODE_DATA_ROOT = _PLATFORM_PATHS.opencode_data_root
 OPENCODE_CACHE_ROOT = _PLATFORM_PATHS.opencode_cache_root
-_opencode_db_override = os.path.expanduser(os.environ.get("OPENCODE_DB", ""))
 OPENCODE_DB = (
     _opencode_db_override
     if os.path.isabs(_opencode_db_override)
@@ -352,20 +790,11 @@
 PI_AGENT_DIR = os.path.abspath(os.path.expanduser(
     os.environ.get("PI_CODING_AGENT_DIR", "~/.pi/agent")
 ))
-def hermes_state_db_path(environ=None):
-    environ = os.environ if environ is None else environ
-    state_db = str(environ.get("HERMES_STATE_DB") or "").strip()
-    home = str(environ.get("HERMES_HOME") or "").strip() or "~/.hermes"
-    return os.path.abspath(os.path.expanduser(state_db or os.path.join(home, "state.db")))
 
 
 HERMES_STATE_DB = hermes_state_db_path()
 
 
-def agy_brain_dir_path(environ=None):
-    return _default_agy_brain_dir(os.path.expanduser("~"), environ)
-
-
 AGY_BRAIN_DIR = agy_brain_dir_path()
 TOKEN_METER_SETTINGS = os.path.expanduser(
     os.environ.get("TOKEN_METER_SETTINGS", "~/.token-meter/settings.json")
@@ -374,21 +803,9 @@ def agy_brain_dir_path(environ=None):
 TOKEN_METER_API_TOKEN = os.path.expanduser(
     os.environ.get("TOKEN_METER_API_TOKEN", "~/.token-meter/api-token")
 )
-TOKEN_METER_SESSION_MODEL_IDENTITIES = os.path.expanduser(
-    os.environ.get(
-        "TOKEN_METER_SESSION_MODEL_IDENTITIES",
-        "~/.token-meter/session-model-identities.json",
-    )
-)
 TOKEN_METER_NOTIFICATIONS = os.path.expanduser(
     os.environ.get("TOKEN_METER_NOTIFICATIONS", "~/.token-meter/notifications.json")
 )
-TOKEN_METER_UPDATE_STATUS = os.path.expanduser(
-    os.environ.get("TOKEN_METER_UPDATE_STATUS", "~/.token-meter/update-status.json")
-)
-TOKEN_METER_GIT_DELIVERY_DB = os.path.expanduser(
-    os.environ.get("TOKEN_METER_GIT_DELIVERY_DB", "~/.token-meter/git-delivery.sqlite3")
-)
 TOKEN_METER_WORK_INSIGHTS_DB = os.path.expanduser(
     os.environ.get("TOKEN_METER_WORK_INSIGHTS_DB", "~/.token-meter/work-insights.sqlite3")
 )
@@ -398,75 +815,10 @@ def agy_brain_dir_path(environ=None):
         "~/.token-meter/matched-pace-cache.json",
     )
 )
-TOKEN_METER_MCP_EVIDENCE_CACHE = os.path.expanduser(
-    os.environ.get(
-        "TOKEN_METER_MCP_EVIDENCE_CACHE",
-        "~/.token-meter/mcp-evidence-cache.json",
-    )
-)
 PORT = 8722
 
-MODEL_PRICE_PROVIDERS = ("claude", "codex", "cursor", "opencode", "google")
-MAX_CUSTOM_MODEL_PRICES = 100
-MAX_MODEL_PRICE_PERIODS = 256
-MAX_MODEL_PRICE_CHANGES = 256
-MAX_MODEL_PRICE = 1_000_000.0
-MODEL_PRICING_MTIME_TTL_S = 0.25
-MAX_SESSION_MODEL_IDENTITIES = 2_048
-SESSION_MODEL_IDENTITY_KEY_RE = re.compile(r"^[a-f0-9]{64}$")
-SESSION_CLAUDE_MODEL_ID_RE = re.compile(
-    r"^claude-(?:haiku|sonnet|opus)-[a-z0-9][a-z0-9._:-]{0,139}$",
-    re.IGNORECASE,
-)
-HERMES_MODEL_IDENTITY_LABEL = "Bedrock application profile"
-BUDGET_PROVIDERS = ("claude", "codex", "cursor", "opencode", "kiro", "pi", "hermes", "agy")
-# Runtimes whose character-count cost estimates run far below real cost (#91):
-# budgets still show them, but budget notifications are measured without them.
-BUDGET_ALERT_EXCLUDED_ESTIMATE_PROVIDERS = ("agy",)
-# Runtimes whose session storage Token Meter must never move or delete.
-READ_ONLY_SESSION_PROVIDERS = ("opencode", "hermes", "agy")
-DEFAULT_RUNTIME_BUDGET = 0.0
-DEFAULT_BUDGET_THRESHOLDS = (80, 90, 100)
-DEFAULT_SESSION_BUDGET = 10.0
-MIN_SESSION_BUDGET = 0.5
-MAX_MONTHLY_BUDGET = 100_000_000.0
-MAX_SESSION_BUDGETS = 500
 OPENCODE_DETAIL_MESSAGE_LIMIT = 200
-UPDATE_CHECK_INTERVAL_S = 10 * 60
-GIT_DELIVERY_INTERVAL_S = 5 * 60
-UPDATE_FETCH_TIMEOUT_S = 45
-# Comfortably past the installer's default 600-second readiness wait.
-UPDATE_STALE_AFTER_S = 30 * 60
-UPDATE_REF_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._/-]{1,199}$")
-
-# Compatibility re-exports retain the existing runtime-oriented names while
-# their authoritative data now lives in the model-provider catalog.
-BUILTIN_MODEL_PRICE_HISTORY = {
-    "codex": _CANONICAL_BUILTIN_MODEL_PRICE_HISTORY["openai"],
-}
-DEFAULT_CLAUDE_MODEL = _DEFAULT_MODELS["anthropic"]
-DEFAULT_OPENAI_MODEL = _DEFAULT_MODELS["openai"]
-CHARS_PER_TOKEN = 4
-TRACE_LIMIT = 220
-EXEC_LIMIT = 180
-MENUBAR_CONTEXT_SOFT_PCT = 0.65
-MENUBAR_CONTEXT_WATCH_PCT = 0.70
-MENUBAR_CONTEXT_INTERVENE_PCT = 0.85
-MENUBAR_COST_SPIKE = 0.50
-QUOTA_REFRESH_S = 60.0
-QUOTA_STALE_S = 10 * 60.0
-QUOTA_HTTP_TIMEOUT_S = 8.0
-QUOTA_PROCESS_TIMEOUT_S = 8.0
-LOW_YIELD_RATIO = 0.005
-LOW_YIELD_COST = 0.05
-LOW_YIELD_CONTEXT_PCT = 0.25
-LOW_YIELD_INPUT_TOKENS = 60000
-TOOL_OVERSIZED_TOKENS = 8000
-PLUGIN_ID_RE = re.compile(r"^[A-Za-z0-9_.@:/-]{1,180}$")
-SKILL_PATH_RE = re.compile(r"(?:^|[/\\])([^/\\\s'\"]+)[/\\]SKILL\.md(?:\b|$)", re.IGNORECASE)
-SKILL_NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,179}$")
-DATA_URL_RE = re.compile(r"data:image/[^;\s]+;base64,[A-Za-z0-9+/=]+")
-BASE64_FIELD_RE = re.compile(r'("(?:data|image_url)"\s*:\s*")([A-Za-z0-9+/=]{512,})(")')
+
 
 subscribers, subscribers_lock = [], threading.Lock()
 STATE = {}
@@ -489,179 +841,31 @@ def agy_brain_dir_path(environ=None):
     "data": None, "at": 0.0, "sessions": [],
     "internal_rows": (), "agent_groups": (), "project_model_stats": {},
 }
-_XSESS_TTL = 15.0
-_XSESS_LIVE_REFRESH_S = _XSESS_TTL
-_CURRENT_SESSION_REBUILD_S = 1.5
-_SOURCE_MEMBERSHIP_PROBE_S = 2.0
-_SOURCE_MEMBERSHIP_FALLBACK_S = 4.0
-_SOURCE_DISCOVERY_REFRESH_S = 10.0
-CURRENT_SESSION_MAX_AGE_S = 30 * 60
-CURRENT_SESSION_WORKING_S = 90
-CURRENT_SESSION_LIMIT = 200
-CURRENT_SESSION_CONTEXT_SAMPLES = 32
-SESSION_STATE_CACHE_LIMIT = 32
-MODEL_PROJECT_OPTION_LIMIT = 500
-OTHER_LOCAL_SESSIONS_PROJECT = "__other_local_sessions__"
 _summary_cache = {}
 _summary_cache_lock = threading.Lock()
 # Cold-index worker processes are opt-in so importing the module (tests, MCP,
 # tools) never spawns processes. The server entrypoint turns them on.
 _parallel_index_enabled = False
 _index_prefetch_lock = threading.Lock()
-_matched_pace_cache = {"signature": None, "data": None}
 _matched_pace_cache_lock = threading.Lock()
-# One entry per model-runtime pair for the global (all-session) scope, so a
-# changed model only rebuilds the pairs it participates in. Reused across
-# restarts via TOKEN_METER_MATCHED_PACE_CACHE. Loaded, read, mutated, and saved
-# only by the thread holding the single-flight build flag below; it is never
-# touched by project-scoped builds.
-_matched_pace_pair_cache = {}
 _matched_pace_pair_cache_loaded = False
 # Single-flight guard: one rebuild at a time, so concurrent requests share one
 # computation instead of each starting its own.
 _matched_pace_build_condition = threading.Condition(threading.Lock())
-_matched_pace_build_state = {"building": False}
 # Persistence is opt-in so importing the module (tests, tools) never writes the
 # user's cache file. The server entrypoint turns it on.
 _matched_pace_persist = False
-# Bump whenever the matching algorithm, thresholds, result fields, or pair-key
-# format change, so stale persisted comparisons are discarded on load.
-MATCHED_PACE_CACHE_SCHEMA = 2
 MATCHED_PACE_CACHE_MAX_PAIRS = 4000
-_SKILL_CATALOG_TTL_S = 60.0
-_skill_catalog_cache = {"rows": None, "at": 0.0}
 _skill_catalog_cache_lock = threading.Lock()
-_session_state_cache = {}
 _session_state_cache_lock = threading.Lock()
-_session_state_build_locks = {}
-_recursive_path_cache = BoundedPathCache(ttl_seconds=4.0, max_entries=64)
 _RUNTIME_DISCOVERY_FAILURES = ()
 _RUNTIME_LOAD_FAILURE = None
-_model_pricing_cache = {
-    "path": None, "mtime_ns": None, "mtime_checked_at": 0.0,
-    "histories": {}, "effective": {}, "quotes": {},
-}
 _session_model_identity_lock = threading.RLock()
-_quota_cache = {}
-_quota_inflight = set()
 _quota_lock = threading.Lock()
 _QUOTA_REGISTRY = None
 _quota_registry_lock = threading.Lock()
 _update_operation_lock = threading.Lock()
 _update_wake = threading.Event()
-_ACTION_TOKEN = secrets.token_urlsafe(24)
-AGENT_ACCESS_SERVER = "tokenmeter"
-AGENT_CURRENT_MAX_AGE_S = 6 * 60 * 60
-
-
-_ISO_UTC_SUFFIX_RE = re.compile(r"(?:[Zz]|[+-]00:?00)$")
-
-
-def parse_iso(ts):
-    """Parse a trace timestamp; anything that is not a string is undated (None).
-
-    The guard runs before the cache, so a list or dict value (unhashable) can
-    never raise and stop a build.
-    """
-    if not isinstance(ts, str):
-        return None
-    return _parse_iso_text(ts)
-
-
-@functools.lru_cache(maxsize=65536)
-def _parse_iso_text(ts):
-    # Logs are UTC (trailing Z). calendar.timegm treats the struct as UTC, so
-    # idle/elapsed line up with time.time(). A whole-second stamp ending in Z
-    # (or +00:00) is the same instant; other forms keep their existing result.
-    text = ts.split(".")[0]
-    if len(text) > 19:
-        text = _ISO_UTC_SUFFIX_RE.sub("", text)
-    try:
-        return calendar.timegm(time.strptime(text, "%Y-%m-%dT%H:%M:%S"))
-    except Exception:
-        return None
-
-
-# The cached string parser stays observable through the public name.
-parse_iso.cache_clear = _parse_iso_text.cache_clear
-parse_iso.cache_info = _parse_iso_text.cache_info
-
-
-def local_dt(ts):
-    return time.strftime("%Y-%m-%d %I:%M:%S %p", time.localtime(ts)).lower() if ts else ""
-
-
-def local_tm(ts):
-    return time.strftime("%H:%M:%S", time.localtime(ts)) if ts else ""
-
-
-def duration_label(seconds):
-    seconds = int(seconds or 0)
-    if seconds < 60:
-        return f"{seconds}s"
-    minutes, sec = divmod(seconds, 60)
-    if minutes < 60:
-        return f"{minutes}m {sec:02d}s"
-    hours, minutes = divmod(minutes, 60)
-    return f"{hours}h {minutes:02d}m"
-
-
-def _merge_execution_intervals(intervals):
-    """Return wall-active seconds after collapsing overlapping execution windows."""
-    return _domain_merge_execution_intervals(intervals)
-
-
-def _claude_user_prompt(obj):
-    if obj.get("type") != "user":
-        return False
-    msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-    content = msg.get("content")
-    if isinstance(content, str):
-        return bool(content.strip())
-    if not isinstance(content, list):
-        return False
-    return any(
-        isinstance(block, dict)
-        and block.get("type") == "text"
-        and str(block.get("text") or "").strip()
-        for block in content
-    )
-
-
-def _is_user_input_tool(name):
-    """Return whether a tool explicitly pauses the agent for human input."""
-    normalized = re.sub(r"[^a-z0-9]", "", str(name or "").lower())
-    return normalized in ("askuserquestion", "requestuserinput")
-
-
-def _track_claude_user_pause(group, block, ts):
-    if not group or not isinstance(block, dict) or block.get("type") != "tool_use":
-        return
-    if not _is_user_input_tool(block.get("name")):
-        return
-    tool_id = block.get("id")
-    if tool_id:
-        group.setdefault("user_pause_starts", {}).setdefault(tool_id, float(ts or 0))
-
-
-def _close_claude_user_pauses(group, message, ts):
-    if not group or not isinstance(message, dict):
-        return
-    starts = group.setdefault("user_pause_starts", {})
-    for block in message.get("content") or []:
-        if not isinstance(block, dict) or block.get("type") != "tool_result":
-            continue
-        started = starts.pop(block.get("tool_use_id"), None)
-        if started is not None and float(ts or 0) >= started:
-            group["user_pause_s"] = float(group.get("user_pause_s") or 0) + float(ts or 0) - started
-
-
-def _claude_effective_duration(group, duration_s, timing_basis):
-    """Remove trace-visible human-response pauses from observed wall time."""
-    duration_s = float(duration_s or 0)
-    paused_s = float((group or {}).get("user_pause_s") or 0)
-    excluded_s = min(duration_s, paused_s) if timing_basis == "observed" else 0.0
-    return max(0.0, duration_s - excluded_s), excluded_s
 
 
 def execution_timing(provider, objs):
@@ -778,9 +982,6 @@ def load_json(path, default=None):
         return {} if default is None else default
 
 
-OBSOLETE_SETTINGS_KEYS = ("language_signal_terms", "frustration_terms")
-
-
 def write_settings_json(path, settings):
     """Atomically write machine-wide settings, dropping keys for removed features."""
     for key in OBSOLETE_SETTINGS_KEYS:
@@ -813,111 +1014,6 @@ def atomic_write_text(path, text):
             os.unlink(tmp)
 
 
-def sweep_orphaned_atomic_writes(path):
-    """Remove temp files a killed writer of ``path`` left behind (its process is gone)."""
-    # Signal 0 probes liveness only on POSIX; on Windows ``os.kill`` delivers it.
-    if os.name != "posix":
-        return 0
-    directory = os.path.dirname(path)
-    prefix = f".{os.path.basename(path)}.token-meter-"
-    try:
-        names = os.listdir(directory)
-    except OSError:
-        return 0
-    removed = 0
-    for name in names:
-        if not name.startswith(prefix):
-            continue
-        pid_text, _separator, suffix = name[len(prefix):].partition("-")
-        if not (pid_text.isascii() and pid_text.isdecimal()) or not suffix:
-            continue
-        pid = int(pid_text)
-        if pid == os.getpid():
-            continue
-        try:
-            os.kill(pid, 0)
-            continue
-        except ProcessLookupError:
-            pass
-        except (PermissionError, OSError, OverflowError):
-            continue
-        candidate = os.path.join(directory, name)
-        try:
-            if os.path.islink(candidate) or not os.path.isfile(candidate):
-                continue
-            os.unlink(candidate)
-            removed += 1
-        except OSError:
-            continue
-    return removed
-
-
-def normalize_model_price_provider(provider):
-    provider = str(provider or "").strip().lower()
-    if provider == "openai":
-        provider = "codex"
-    if provider not in MODEL_PRICE_PROVIDERS:
-        raise ValueError("Provider must be Claude, Codex / OpenAI, Cursor, OpenCode, or Google Gemini.")
-    return provider
-
-
-def normalize_model_price_id(model):
-    return normalize_model_id(model)
-
-
-def normalize_model_price(prices):
-    if not isinstance(prices, dict):
-        raise ValueError("Model prices must be an object.")
-    normalized = {}
-    for field in MODEL_PRICE_FIELDS:
-        value = prices.get(field)
-        if isinstance(value, bool) or not isinstance(value, (int, float)):
-            raise ValueError(f"{field.replace('_', ' ').title()} price must be a number.")
-        value = float(value)
-        if not math.isfinite(value) or value < 0 or value > MAX_MODEL_PRICE:
-            raise ValueError(
-                f"{field.replace('_', ' ').title()} price must be between 0 and "
-                f"{MAX_MODEL_PRICE:,.0f}."
-            )
-        normalized[field] = value
-    return normalized
-
-
-def builtin_model_price_tables():
-    return {
-        "claude": CLAUDE_PRICE,
-        "codex": OPENAI_PRICE,
-        "cursor": CURSOR_PRICE,
-        "opencode": {},
-        "google": GOOGLE_PRICE,
-    }
-
-
-def _price_timestamp(value):
-    """Normalize an event timestamp; ``None`` intentionally means current pricing."""
-    if value is None:
-        return None
-    if isinstance(value, bool):
-        return None
-    if isinstance(value, (int, float)):
-        value = float(value)
-        return value if math.isfinite(value) else None
-    if isinstance(value, datetime.datetime):
-        if value.tzinfo is None:
-            value = value.replace(tzinfo=datetime.timezone.utc)
-        return value.timestamp()
-    if isinstance(value, str):
-        return parse_iso(value.strip())
-    return None
-
-
-def _price_datetime(value):
-    timestamp = _price_timestamp(value)
-    if timestamp is None:
-        return None
-    return datetime.datetime.fromtimestamp(timestamp, datetime.timezone.utc)
-
-
 def _model_price_period_key(provider, at=None, histories=None):
     """Return the bounded cache bucket containing one event timestamp."""
     model_provider = canonical_model_provider(provider)
@@ -942,51 +1038,6 @@ def _model_pricing_mtime_ns(path):
         return None
 
 
-def _normalize_model_price_revision(raw, builtin):
-    if not isinstance(raw, dict):
-        raise ValueError("Model price period must be an object.")
-    effective_from = raw.get("effective_from")
-    if effective_from is not None:
-        if isinstance(effective_from, bool) or not isinstance(effective_from, (int, float)):
-            raise ValueError("Model price effective time must be a Unix timestamp.")
-        effective_from = float(effective_from)
-        if not math.isfinite(effective_from) or effective_from < 0:
-            raise ValueError("Model price effective time must be a Unix timestamp.")
-    actions = sum(("prices" in raw, raw.get("use_builtin") is True,
-                   raw.get("inactive") is True))
-    if actions != 1:
-        raise ValueError("Model price period must contain exactly one action.")
-    revision = {"effective_from": effective_from}
-    if "prices" in raw:
-        revision["prices"] = normalize_model_price(raw["prices"])
-    elif raw.get("use_builtin") is True:
-        if not builtin:
-            raise ValueError("Only bundled models can resume built-in pricing.")
-        revision["use_builtin"] = True
-    else:
-        if builtin:
-            raise ValueError("Bundled models cannot be retired.")
-        revision["inactive"] = True
-    return revision
-
-
-def _normalize_model_price_history(raw, builtin):
-    """Normalize a legacy timeless price or a bounded revision timeline."""
-    if isinstance(raw, dict) and all(field in raw for field in MODEL_PRICE_FIELDS):
-        return [{"effective_from": None, "prices": normalize_model_price(raw)}]
-    if not isinstance(raw, list) or len(raw) > MAX_MODEL_PRICE_PERIODS:
-        raise ValueError("Model price history is invalid or too long.")
-    by_effective = {}
-    for item in raw:
-        revision = _normalize_model_price_revision(item, builtin)
-        by_effective[revision["effective_from"]] = revision
-    return sorted(
-        by_effective.values(),
-        key=lambda revision: (-1 if revision["effective_from"] is None
-                              else revision["effective_from"]),
-    )
-
-
 def _load_model_price_histories(path=None):
     """Load validated price timelines with an mtime cache for hot cost paths."""
     path = path or TOKEN_METER_SETTINGS
@@ -1048,22 +1099,6 @@ def _model_price_revision_at(periods, at=None):
     )
 
 
-def _same_model_price_action(left, right):
-    if not left or not right:
-        return False
-    for key in ("prices", "use_builtin", "inactive"):
-        if key in left or key in right:
-            return left.get(key) == right.get(key)
-    return False
-
-
-def _last_model_price(periods):
-    for revision in reversed(periods or ()):
-        if "prices" in revision:
-            return revision["prices"]
-    return None
-
-
 def effective_model_price_table(provider, path=None, at=None):
     provider = normalize_model_price_provider(provider)
     histories = _load_model_price_histories(path)
@@ -1134,54 +1169,6 @@ def model_pricing_settings(path=None):
     }
 
 
-def _normalize_model_price_scope(apply_to_all_history, effective_from, now):
-    if not isinstance(apply_to_all_history, bool):
-        raise ValueError("Apply to all history must be true or false.")
-    if effective_from is not None:
-        if isinstance(effective_from, bool) or not isinstance(effective_from, (int, float)):
-            raise ValueError("Model price effective time must be a Unix timestamp.")
-        effective_from = float(effective_from)
-        if not math.isfinite(effective_from) or effective_from < 0:
-            raise ValueError("Model price effective time must be a Unix timestamp.")
-        if effective_from > now + 300:
-            raise ValueError("Model price effective time cannot be in the future.")
-    if apply_to_all_history and effective_from is not None:
-        raise ValueError("Choose either an effective time or all history, not both.")
-    return (
-        None if apply_to_all_history else (
-            effective_from if effective_from is not None else now
-        ),
-        "all_history" if apply_to_all_history else (
-            "selected_time" if effective_from is not None else "now"
-        ),
-    )
-
-
-def _normalize_model_price_change(change):
-    if not isinstance(change, dict):
-        raise ValueError("Each model price change must be an object.")
-    provider = normalize_model_price_provider(change.get("provider"))
-    model = normalize_model_price_id(change.get("model"))
-    remove = change.get("remove", False)
-    if not isinstance(remove, bool):
-        raise ValueError("Remove must be true or false.")
-    if remove and "prices" in change:
-        raise ValueError("A model price change cannot set and remove prices together.")
-    prices = None if remove else normalize_model_price(change.get("prices"))
-    return {
-        "provider": provider,
-        "model": model,
-        "prices": prices,
-        "remove": remove,
-    }
-
-
-def _has_scheduled_builtin_prices(provider, model):
-    """Return whether a bundled model's price changes on a scheduled date."""
-    history = _CANONICAL_BUILTIN_MODEL_PRICE_HISTORY.get(canonical_model_provider(provider), {})
-    return model in history
-
-
 def _apply_model_price_change(
         histories, change, apply_to_all_history, applied_from):
     provider = change["provider"]
@@ -1352,55 +1339,6 @@ def set_model_price(provider, model, prices=None, remove=False, path=None,
     return result
 
 
-COST_DISCOUNTS_SETTINGS_KEY = "cost_discounts"
-COST_DISCOUNT_READ_ONLY_ERRORS = {
-    "newer_version": "Discounts were saved by a newer Token Meter.",
-    "unsupported_format": "Discounts in settings.json can't be changed by this version.",
-}
-COST_DISCOUNTS_VERSION = 1
-MAX_COST_DISCOUNT_OPS = 64
-_COST_DISCOUNT_SERVER_FIELDS = frozenset((
-    "source", "set_by", "updated_at", "start_iso", "end_iso", "updated_at_iso",
-))
-_COST_DISCOUNT_RULE_FIELDS = frozenset((
-    "id", "external_id", "price_list", "channel", "percent", "start", "end", "label",
-))
-_cost_discount_cache = {"path": None, "mtime_ns": None, "checked_at": 0.0, "state": None}
-
-
-def _cost_discount_state_from_raw(raw):
-    """Validate a stored ``cost_discounts`` value, keeping every valid rule."""
-    malformed = []
-    if isinstance(raw, dict):
-        rules, invalid = _discounts.normalize_rules_lenient(raw.get("rules"), malformed)
-        channels = _discounts.normalize_runtime_channels(raw.get("runtime_channels"))
-    else:
-        rules, invalid = [], (0 if raw is None else 1)
-        channels = _discounts.normalize_runtime_channels(None)
-    # Only this build's exact format (version 1, or no version, with a list of rules)
-    # is ever rewritten; anything else is read for what this build understands.
-    shape_ok = raw is None or (
-        isinstance(raw, dict)
-        and ("version" not in raw
-             or (type(raw["version"]) is int and raw["version"] == COST_DISCOUNTS_VERSION))
-        and isinstance(raw.get("rules", []), list)
-    )
-    version = raw.get("version") if isinstance(raw, dict) else None
-    newer = (isinstance(version, (int, float)) and not isinstance(version, bool)
-             and version > COST_DISCOUNTS_VERSION)
-    return {
-        "read_only": not shape_ok,
-        "read_only_reason": None if shape_ok else ("newer_version" if newer else "unsupported_format"),
-        # Entries invalid on their own are kept verbatim on the next write, still ignored for pricing.
-        "dropped": tuple(malformed),
-        "rules": tuple(rules),
-        "runtime_channels": channels,
-        "invalid": invalid,
-        "index": _discounts.build_index(rules),
-        "revision": _discounts.revision(rules, channels),
-    }
-
-
 def _load_cost_discounts(path=None):
     """Return validated discount rules with the same mtime/TTL cache as prices.
 
@@ -1425,10 +1363,6 @@ def _load_cost_discounts(path=None):
     return state
 
 
-def _reset_cost_discount_cache():
-    _cost_discount_cache.update(path=None, mtime_ns=None, checked_at=0.0, state=None)
-
-
 def cost_discount_revision(path=None):
     """Fingerprint of the active discount rules and Claude channel choices."""
     return _load_cost_discounts(path)["revision"]
@@ -1472,11 +1406,6 @@ def discount_amount(amount_or_breakdown, price_list, channel=None, at=None, path
     return discounted, value - discounted
 
 
-def discount_of(value):
-    """Return the discount carried by a priced figure, or 0 for a plain one."""
-    return float(getattr(value, "discount_usd", 0.0) or 0.0)
-
-
 def claude_session_channel(source, rows):
     """Resolve one Claude session's billing channel without keeping request ids.
 
@@ -1497,14 +1426,6 @@ def claude_session_channel(source, rows):
     return "unknown"
 
 
-def _public_cost_discount_rule(rule):
-    public = dict(rule)
-    public["start_iso"] = _discounts.iso_timestamp(rule.get("start"))
-    public["end_iso"] = _discounts.iso_timestamp(rule.get("end"))
-    public["updated_at_iso"] = _discounts.iso_timestamp(rule.get("updated_at"))
-    return public
-
-
 def cost_discount_settings(path=None, now=None):
     """Return discounts for Settings and the local API; no trace data is read."""
     state = _load_cost_discounts(path)
@@ -1565,178 +1486,6 @@ def resolve_cost_discount(price_list, channel, at=None, path=None):
     }
 
 
-def _new_cost_discount_id(taken):
-    while True:
-        rule_id = "d_" + secrets.token_hex(6)
-        if rule_id not in taken:
-            return rule_id
-
-
-def _discount_rule_content(rule):
-    return {field: rule.get(field) for field in _discounts.CONTENT_FIELDS}
-
-
-def _submitted_discount_fields(raw):
-    if not isinstance(raw, dict):
-        raise ValueError("Each discount must be an object.")
-    unknown = sorted(set(raw) - _COST_DISCOUNT_RULE_FIELDS - _COST_DISCOUNT_SERVER_FIELDS, key=str)
-    if unknown:
-        raise ValueError("Unknown field: {}".format(str(unknown[0])[:40]))
-    return {key: value for key, value in raw.items() if key in _COST_DISCOUNT_RULE_FIELDS}
-
-
-def _merge_discount_rule(raw, existing, taken_ids, now, source, set_by, scope=None):
-    """Merge one submitted rule over the rule it matches; unchanged keeps the original."""
-    submitted = _submitted_discount_fields(raw)
-    merged = {
-        field: existing[field] for field in _discounts.CONTENT_FIELDS
-        if existing and field in existing
-    }
-    for field in _discounts.CONTENT_FIELDS:
-        if field in submitted:
-            merged[field] = submitted[field]
-    if scope is not None:
-        for field, value in zip(("price_list", "channel"), scope):
-            supplied = submitted.get(field)
-            if supplied is not None and str(supplied).strip().lower() != value:
-                raise ValueError("A replaced schedule may only contain its own discounts.")
-            merged[field] = value
-    merged["id"] = existing["id"] if existing else _new_cost_discount_id(taken_ids)
-    candidate = _discounts.normalize_rule({
-        **merged, "source": source, "set_by": set_by, "updated_at": now,
-    })
-    if existing and _discount_rule_content(candidate) == _discount_rule_content(
-            _discounts.normalize_rule(existing)):
-        return existing
-    return candidate
-
-
-def _matched_discount(rules, raw):
-    """Return the index of the rule a submission names, or ``None`` to create one."""
-    if not isinstance(raw, dict):
-        raise ValueError("Each discount must be an object.")
-    rule_id = raw.get("id")
-    if rule_id not in (None, ""):
-        for position, rule in enumerate(rules):
-            if rule["id"] == rule_id:
-                return position
-        raise ValueError("No discount has that id.")
-    external_id = raw.get("external_id")
-    if external_id not in (None, ""):
-        for position, rule in enumerate(rules):
-            if rule.get("external_id") == external_id:
-                return position
-    return None
-
-
-def _discount_scope(op):
-    price_list = str(op.get("price_list") or "").strip().lower()
-    if price_list not in _discounts.PRICE_LISTS:
-        raise ValueError("Choose Anthropic, OpenAI, Cursor, Kiro, or OpenCode.")
-    channel = op.get("channel")
-    channel = _discounts.ANY_CHANNEL if channel is None else str(channel).strip().lower()
-    if channel not in _discounts.RULE_CHANNELS:
-        raise ValueError("Choose who bills you: the provider, AWS Bedrock, Google Vertex, Microsoft Azure, or anyone.")
-    if price_list in _discounts.FIXED_CHANNEL_PRICE_LISTS and channel != _discounts.ANY_CHANNEL:
-        raise ValueError("{} discounts apply however it is billed.".format(
-            _discounts.PRICE_LIST_LABELS[price_list]))
-    return price_list, channel
-
-
-_COST_DISCOUNT_OP_FIELDS = {
-    "delete": frozenset(("op", "id", "external_id")),
-    "replace_scope": frozenset(("op", "price_list", "channel", "rules")),
-    "set_runtime_channels": frozenset(("op", "runtime_channels", *_discounts.RUNTIME_CHANNEL_KEYS)),
-}
-
-
-def _reject_unknown_op_fields(op, kind):
-    allowed = _COST_DISCOUNT_OP_FIELDS.get(kind)
-    if kind == "upsert" and "rule" in op:
-        allowed = frozenset(("op", "rule"))
-    if allowed is None:
-        return
-    unknown = sorted((key for key in op if key not in allowed), key=str)
-    if unknown:
-        raise ValueError("Unknown field: {}".format(str(unknown[0])[:40]))
-
-
-def _op_removes_stored_entry(op, raw):
-    """Whether a delete or replace_scope names a preserved invalid stored entry."""
-    if not isinstance(op, dict) or not isinstance(raw, dict):
-        return False
-    if op.get("op") == "delete":
-        return any(op.get(key) not in (None, "") and op.get(key) == raw.get(key)
-                   for key in ("id", "external_id"))
-    if op.get("op") == "replace_scope":
-        channel = raw.get("channel")
-        return (str(raw.get("price_list") or "").strip().lower() == str(op.get("price_list") or "").strip().lower()
-                and str(channel if channel is not None else "any").strip().lower()
-                == str(op.get("channel") if op.get("channel") is not None else "any").strip().lower())
-    return False
-
-
-def _apply_cost_discount_op(rules, channels, op, now, source, set_by):
-    if not isinstance(op, dict):
-        raise ValueError("Each discount change must be an object.")
-    kind = op.get("op")
-    _reject_unknown_op_fields(op, kind)
-    taken = {rule["id"] for rule in rules}
-    if kind == "upsert":
-        raw = op.get("rule") if "rule" in op else {
-            key: value for key, value in op.items() if key != "op"
-        }
-        position = _matched_discount(rules, raw)
-        existing = rules[position] if position is not None else None
-        merged = _merge_discount_rule(raw, existing, taken, now, source, set_by)
-        if position is None:
-            rules.append(merged)
-        else:
-            rules[position] = merged
-        return
-    if kind == "delete":
-        rule_id, external_id = op.get("id"), op.get("external_id")
-        if rule_id in (None, "") and external_id in (None, ""):
-            raise ValueError("Delete needs an id or external id.")
-        rules[:] = [
-            rule for rule in rules
-            if not ((rule_id not in (None, "") and rule["id"] == rule_id)
-                    or (external_id not in (None, "") and rule.get("external_id") == external_id))
-        ]
-        return
-    if kind == "replace_scope":
-        scope = _discount_scope(op)
-        submitted = op.get("rules")
-        if not isinstance(submitted, list) or len(submitted) > _discounts.MAX_RULES_PER_SCOPE:
-            raise ValueError("A schedule needs a list of at most {} discounts.".format(
-                _discounts.MAX_RULES_PER_SCOPE))
-        in_scope = [rule for rule in rules if (rule["price_list"], rule["channel"]) == scope]
-        outside = [rule for rule in rules if (rule["price_list"], rule["channel"]) != scope]
-        replacement = []
-        for raw in submitted:
-            position = _matched_discount(in_scope, raw)
-            existing = in_scope[position] if position is not None else None
-            if existing is not None and any(rule is existing for rule in replacement):
-                raise ValueError("A schedule lists the same discount twice.")
-            replacement.append(_merge_discount_rule(
-                raw, existing, taken | {rule["id"] for rule in replacement},
-                now, source, set_by, scope=scope,
-            ))
-        rules[:] = outside + replacement
-        return
-    if kind == "set_runtime_channels":
-        values = op.get("runtime_channels") if "runtime_channels" in op else {
-            key: value for key, value in op.items() if key != "op"
-        }
-        if not isinstance(values, dict) or not values:
-            raise ValueError("Choose how each Claude app is billed.")
-        updated = _discounts.normalize_runtime_channels(values, strict=True)
-        for key in values:
-            channels[key] = updated[key]
-        return
-    raise ValueError("Discount changes must be upsert, delete, replace_scope, or set_runtime_channels.")
-
-
 def apply_cost_discount_ops(ops, expected_revision=None, source="dashboard",
                             set_by="Settings", path=None, now=None):
     """Apply one atomic, all-or-nothing batch of discount changes.
@@ -1820,8 +1569,6 @@ def invalidate_cost_caches(session_states=True, cross=True):
             _session_state_build_locks.clear()
 
 
-_pricing_state = {"cache_revision": None, "fingerprint_key": None, "fingerprint": None}
-_pricing_recalc = {"running": False, "pending": False, "thread": None}
 _pricing_recalc_lock = threading.Lock()
 
 
@@ -1909,27 +1656,6 @@ def pricing_watch_tick():
     return True
 
 
-_API_TOKEN_RE = re.compile(r"^[A-Za-z0-9_-]{32,128}$")
-
-
-def _write_api_token(path, token):
-    directory = os.path.dirname(path)
-    os.makedirs(directory, exist_ok=True)
-    tmp = os.path.join(directory, ".{}.token-meter-{}".format(
-        os.path.basename(path), secrets.token_hex(8)))
-    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
-    try:
-        with os.fdopen(fd, "w", encoding="ascii") as fh:
-            fh.write(token + "\n")
-            fh.flush()
-            os.fsync(fh.fileno())
-        os.chmod(tmp, 0o600)
-        os.replace(tmp, path)
-    finally:
-        with contextlib.suppress(FileNotFoundError):
-            os.unlink(tmp)
-
-
 def _read_api_token(path=None):
     path = path or TOKEN_METER_API_TOKEN
     try:
@@ -1964,26 +1690,6 @@ def api_token_matches(candidate, path=None):
         str(candidate).encode("utf-8", "replace"), token.encode("ascii")))
 
 
-BUDGET_API_FIELDS = ("allocations", "thresholds", "native_notifications", "default_session_budget")
-
-
-def _public_budget_settings(settings):
-    """Budget settings for the local API; session ids never leave the server."""
-    return {
-        "currency": settings["currency"],
-        "allocations": {provider: settings["allocations"][provider] for provider in BUDGET_PROVIDERS},
-        "monthly_total": settings["monthly_total"],
-        "thresholds": list(settings["thresholds"]),
-        "native_notifications": settings["native_notifications"],
-        "default_session_budget": settings["default_session_budget"],
-    }
-
-
-def budget_settings_revision(settings):
-    canonical = json.dumps(_public_budget_settings(settings), sort_keys=True, separators=(",", ":"))
-    return "b_" + hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:16]
-
-
 def _budget_month_snapshot():
     """This month's spend from the served cross-session state, or None before it exists."""
     cross = (STATE or {}).get("xsession") if isinstance((STATE or {}).get("xsession"), dict) else None
@@ -2002,9 +1708,6 @@ def _budget_month_snapshot():
     }
 
 
-INVALID_STORED_BUDGETS_ERROR = "Stored budgets are invalid; fix them in Token Meter first."
-
-
 def budget_api_state(path=None):
     """Budgets for local tools: ``(body, status)``; invalid stored budgets are never shown as defaults."""
     stored = load_json(path or TOKEN_METER_SETTINGS, {})
@@ -2101,156 +1804,45 @@ def cost_discount_write(payload, source, set_by):
     return body, 200
 
 
-def _opaque_session_identity_key(value, namespace):
-    value = str(value or "").strip()
-    if not value or len(value) > 512:
-        return ""
-    return hashlib.sha256(
-        (str(namespace) + "\0" + value).encode("utf-8")
-    ).hexdigest()
-
-
-def session_model_identity_key(source):
-    """Return an opaque, physical-trace-scoped key without retaining its ID."""
-    if not isinstance(source, dict):
-        return ""
-    if source.get("provider") == "codex":
-        return _opaque_session_identity_key(
-            source.get("physical_trace_id"), "token-meter-codex-session-v1",
-        )
-    if source.get("provider") == "hermes":
-        return _opaque_session_identity_key(
-            source.get("id"), "token-meter-hermes-session-v1",
-        )
-    return ""
+def _load_session_model_identity_store(path=None):
+    path = path or TOKEN_METER_SESSION_MODEL_IDENTITIES
+    raw = load_json(path, {})
+    rows = raw.get("sessions") if isinstance(raw, dict) else {}
+    sessions = {}
+    if isinstance(rows, dict):
+        for key, value in list(rows.items())[:MAX_SESSION_MODEL_IDENTITIES]:
+            key = str(key or "")
+            if not SESSION_MODEL_IDENTITY_KEY_RE.fullmatch(key) or not isinstance(value, dict):
+                continue
+            entry = {}
+            verified = _normalize_session_model_identity_verified(value.get("verified"))
+            user = _normalize_session_model_identity_user(value.get("user"))
+            if verified:
+                entry["verified"] = verified
+            if user:
+                entry["user"] = user
+            if entry:
+                sessions[key] = entry
+    return {"version": 1, "sessions": sessions}
 
 
-def _session_model_identity_parent_key(parent_id):
-    return _opaque_session_identity_key(
-        parent_id, "token-meter-codex-parent-v1",
-    )
+def _write_session_model_identity_store(store, path=None):
+    path = path or TOKEN_METER_SESSION_MODEL_IDENTITIES
+    sessions = (store or {}).get("sessions") or {}
+    serialized = {
+        "version": 1,
+        "sessions": {key: sessions[key] for key in sorted(sessions)},
+    }
+    atomic_write_text(path, json.dumps(serialized, indent=2, ensure_ascii=False) + "\n")
 
 
-def _session_model_identity_revision(source):
-    signature = file_signature(str((source or {}).get("path") or ""))
-    if not signature:
-        return None
-    return tuple(str(value) for value in signature)
-
-
-def _normalize_session_model_identity_revision(value):
-    if not isinstance(value, (list, tuple)) or len(value) != 2:
-        return None
-    normalized = tuple(str(item) for item in value)
-    if any(not re.fullmatch(r"[0-9]{1,24}", item) for item in normalized):
-        return None
-    return normalized
-
-
-def _normalize_session_model_identity_model(provider, model):
-    raw_provider = str(provider or "").strip().lower()
-    if raw_provider in ("hermes", "anthropic", "claude"):
-        model = normalize_model_price_id(model)
-        if (
-            model == "unknown-model"
-            or not SESSION_CLAUDE_MODEL_ID_RE.fullmatch(model)
-        ):
-            raise ValueError(
-                "Choose an exact public Claude model ID, such as claude-sonnet-5."
-            )
-        return "anthropic", model
-    provider = normalize_model_price_provider(raw_provider)
-    if provider != "codex":
-        raise ValueError("Codex session assignments require Codex / OpenAI models.")
-    model = normalize_model_price_id(model)
-    if model in ("unknown-model", AUTO_REVIEW_MODEL):
-        raise ValueError("Choose an actual Codex / OpenAI model ID.")
-    return "openai", model
-
-
-def _normalize_session_model_identity_verified(value):
-    if not isinstance(value, dict):
-        return None
-    try:
-        provider, model = _normalize_session_model_identity_model(
-            value.get("model_provider"), value.get("model"),
-        )
-    except ValueError:
-        return None
-    if provider != "openai":
-        return None
-    revision = _normalize_session_model_identity_revision(value.get("revision"))
-    parent_key = str(value.get("parent_key") or "")
-    inherited_prefix = value.get("inherited_prefix")
-    if (
-        not revision
-        or not SESSION_MODEL_IDENTITY_KEY_RE.fullmatch(parent_key)
-        or isinstance(inherited_prefix, bool)
-        or not isinstance(inherited_prefix, int)
-        or inherited_prefix < 0
-        or inherited_prefix > 1_000_000
-    ):
-        return None
-    return {
-        "model_provider": provider,
-        "model": model,
-        "revision": list(revision),
-        "parent_key": parent_key,
-        "inherited_prefix": inherited_prefix,
-    }
-
-
-def _normalize_session_model_identity_user(value):
-    if not isinstance(value, dict):
-        return None
-    try:
-        provider, model = _normalize_session_model_identity_model(
-            value.get("model_provider"), value.get("model"),
-        )
-    except ValueError:
-        return None
-    return {"model_provider": provider, "model": model}
-
-
-def _load_session_model_identity_store(path=None):
-    path = path or TOKEN_METER_SESSION_MODEL_IDENTITIES
-    raw = load_json(path, {})
-    rows = raw.get("sessions") if isinstance(raw, dict) else {}
-    sessions = {}
-    if isinstance(rows, dict):
-        for key, value in list(rows.items())[:MAX_SESSION_MODEL_IDENTITIES]:
-            key = str(key or "")
-            if not SESSION_MODEL_IDENTITY_KEY_RE.fullmatch(key) or not isinstance(value, dict):
-                continue
-            entry = {}
-            verified = _normalize_session_model_identity_verified(value.get("verified"))
-            user = _normalize_session_model_identity_user(value.get("user"))
-            if verified:
-                entry["verified"] = verified
-            if user:
-                entry["user"] = user
-            if entry:
-                sessions[key] = entry
-    return {"version": 1, "sessions": sessions}
-
-
-def _write_session_model_identity_store(store, path=None):
-    path = path or TOKEN_METER_SESSION_MODEL_IDENTITIES
-    sessions = (store or {}).get("sessions") or {}
-    serialized = {
-        "version": 1,
-        "sessions": {key: sessions[key] for key in sorted(sessions)},
-    }
-    atomic_write_text(path, json.dumps(serialized, indent=2, ensure_ascii=False) + "\n")
-
-
-def codex_auto_review_evidence(source):
-    """Ask the Codex adapter for non-content evidence from a live direct parent."""
-    if (
-        not isinstance(source, dict)
-        or source.get("provider") != "codex"
-        or source.get("observed_model") != AUTO_REVIEW_MODEL
-    ):
+def codex_auto_review_evidence(source):
+    """Ask the Codex adapter for non-content evidence from a live direct parent."""
+    if (
+        not isinstance(source, dict)
+        or source.get("provider") != "codex"
+        or source.get("observed_model") != AUTO_REVIEW_MODEL
+    ):
         return None
     try:
         evidence = _codex_native_adapter().auto_review_evidence(source)
@@ -2293,15 +1885,6 @@ def _verified_session_model_identity(source, evidence):
     }
 
 
-def _verified_identity_matches_source(verified, source):
-    if not verified:
-        return False
-    return (
-        tuple(verified.get("revision") or ())
-        == _session_model_identity_revision(source)
-    )
-
-
 def _safe_hermes_model_identity_hint(value):
     if not isinstance(value, dict):
         value = {}
@@ -2394,13 +1977,6 @@ def public_session_model_identity(value):
     return result
 
 
-def _apply_verified_session_identity(source, verified):
-    source["model"] = verified["model"]
-    source["model_provider"] = verified["model_provider"]
-    source["_verified_inherited_prefix"] = verified["inherited_prefix"]
-    source["_verified_inherited_prefix_revision"] = list(verified["revision"])
-
-
 def enrich_codex_model_identities(sources, path=None):
     """Apply revision-bound Codex identity evidence without changing price settings."""
     source_rows = [dict(source) for source in (sources or ()) if isinstance(source, dict)]
@@ -2597,104 +2173,6 @@ def set_session_model_identity(session_key, model=None, provider="codex", remove
     }
 
 
-def normalize_session_budget_value(value, label="Session budget"):
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        raise ValueError(f"{label} must be a number.")
-    value = float(value)
-    if (not math.isfinite(value)
-            or value < MIN_SESSION_BUDGET
-            or value > MAX_MONTHLY_BUDGET):
-        raise ValueError(
-            f"{label} must be between "
-            f"{MIN_SESSION_BUDGET:g} and {MAX_MONTHLY_BUDGET:,.0f}."
-        )
-    return value
-
-
-def normalize_budget_settings(values):
-    """Validate one machine-wide monthly budget configuration."""
-    if values is None:
-        values = {}
-    if not isinstance(values, dict):
-        raise ValueError("Budget settings must be an object.")
-    currency = str(values.get("currency") or "USD").strip().upper()
-    if currency != "USD":
-        raise ValueError("Token Meter budgets currently support USD only.")
-
-    default_session_budget = values.get(
-        "default_session_budget", DEFAULT_SESSION_BUDGET,
-    )
-    default_session_budget = normalize_session_budget_value(
-        default_session_budget, "Default session budget",
-    )
-
-    raw_session_budgets = values.get("session_budgets") or {}
-    if not isinstance(raw_session_budgets, dict):
-        raise ValueError("Session budgets must be an object.")
-    if len(raw_session_budgets) > MAX_SESSION_BUDGETS:
-        raise ValueError(f"Token Meter supports at most {MAX_SESSION_BUDGETS} saved session budgets.")
-    session_budgets = {}
-    for raw_session_id, raw_budget in raw_session_budgets.items():
-        if not isinstance(raw_session_id, str):
-            raise ValueError("Session budget IDs must be strings.")
-        session_id = raw_session_id.strip()
-        if not session_id or len(session_id) > 240:
-            raise ValueError("Session budget IDs must be 1 to 240 characters.")
-        session_budgets[session_id] = normalize_session_budget_value(raw_budget)
-
-    raw_allocations = values.get("allocations") or {}
-    if not isinstance(raw_allocations, dict):
-        raise ValueError("Runtime allocations must be an object.")
-    unknown = sorted(set(raw_allocations) - set(BUDGET_PROVIDERS))
-    if unknown:
-        raise ValueError("Runtime allocations must use registered runtime IDs.")
-    allocations = {}
-    for provider in BUDGET_PROVIDERS:
-        value = raw_allocations.get(provider, DEFAULT_RUNTIME_BUDGET)
-        if isinstance(value, bool) or not isinstance(value, (int, float)):
-            raise ValueError(f"{provider.title()} allocation must be a number.")
-        value = float(value)
-        if not math.isfinite(value) or value < 0 or value > MAX_MONTHLY_BUDGET:
-            raise ValueError(
-                f"{provider.title()} allocation must be between 0 and "
-                f"{MAX_MONTHLY_BUDGET:,.0f}."
-            )
-        allocations[provider] = value
-    derived_total = sum(allocations.values())
-    if derived_total > MAX_MONTHLY_BUDGET:
-        raise ValueError(
-            f"Combined runtime budget must not exceed {MAX_MONTHLY_BUDGET:,.0f}."
-        )
-    total = derived_total
-
-    raw_thresholds = values.get("thresholds", DEFAULT_BUDGET_THRESHOLDS)
-    if not isinstance(raw_thresholds, list) and not isinstance(raw_thresholds, tuple):
-        raise ValueError("Budget thresholds must be a list.")
-    thresholds = []
-    for raw in raw_thresholds:
-        if isinstance(raw, bool) or not isinstance(raw, (int, float)):
-            raise ValueError("Budget thresholds must be whole percentages.")
-        value = int(raw)
-        if value != raw or value < 1 or value > 100:
-            raise ValueError("Budget thresholds must be whole percentages from 1 to 100.")
-        thresholds.append(value)
-    if not thresholds or len(thresholds) > 10 or thresholds != sorted(set(thresholds)):
-        raise ValueError("Use 1 to 10 unique budget thresholds in increasing order.")
-
-    native_notifications = values.get("native_notifications", True)
-    if not isinstance(native_notifications, bool):
-        raise ValueError("Budget notifications must be on or off.")
-    return {
-        "currency": "USD",
-        "default_session_budget": default_session_budget,
-        "session_budgets": session_budgets,
-        "monthly_total": total,
-        "allocations": allocations,
-        "thresholds": thresholds,
-        "native_notifications": native_notifications,
-    }
-
-
 def budget_settings(path=None):
     """Load the durable monthly budget with defaults for missing runtimes."""
     path = path or TOKEN_METER_SETTINGS
@@ -2706,7 +2184,6 @@ def budget_settings(path=None):
         return normalize_budget_settings({})
 
 
-_settings_file_locks = {}
 _settings_file_locks_guard = threading.Lock()
 _settings_file_lock_depth = threading.local()
 
@@ -2815,7 +2292,6 @@ def goal_settings(path=None):
     return settings.get("goals") if isinstance(settings, dict) else {}
 
 
-_goal_evidence_cache = {"key": None, "value": None}
 _goal_evidence_lock = threading.Lock()
 
 
@@ -2946,10 +2422,7 @@ def set_goals_action(action, path=None):
     return result
 
 
-_goal_cache = {"signature": None, "built_at": 0.0,
-               "native": {"ready": False, "items": [], "additional_count": 0}}
 _goal_cache_lock = threading.Lock()
-GOAL_NATIVE_REFRESH_S = 60.0
 
 
 def refresh_goal_cache():
@@ -3048,25 +2521,6 @@ def update(current):
     return _update_budget_settings(update, path or TOKEN_METER_SETTINGS)
 
 
-def normalize_update_settings(values):
-    """Validate the machine-wide software-update preferences."""
-    if values is None:
-        values = {}
-    if not isinstance(values, dict):
-        raise ValueError("Update settings must be an object.")
-    enabled = values.get("enabled", True)
-    auto_install = values.get("auto_install", True)
-    if not isinstance(enabled, bool) or not isinstance(auto_install, bool):
-        raise ValueError("Update preferences must be on or off.")
-    if not enabled:
-        auto_install = False
-    return {
-        "enabled": enabled,
-        "auto_install": auto_install,
-        "interval_seconds": UPDATE_CHECK_INTERVAL_S,
-    }
-
-
 def update_settings(path=None):
     """Load the default-on update-check and installation preferences."""
     path = path or TOKEN_METER_SETTINGS
@@ -3103,22 +2557,6 @@ def set_update_settings(values, path=None):
     return {"ok": True, "changed": changed, "updates": normalized}
 
 
-MENUBAR_CACHE_TIMER_MODES = ("always", "final2", "off")
-DEFAULT_MENUBAR_CACHE_TIMER = "always"
-
-
-def normalize_menubar_settings(values):
-    """Validate the machine-wide menu-bar preferences shared by both surfaces."""
-    if values is None:
-        values = {}
-    if not isinstance(values, dict):
-        raise ValueError("Menu bar settings must be an object.")
-    mode = values.get("cache_timer", DEFAULT_MENUBAR_CACHE_TIMER)
-    if mode not in MENUBAR_CACHE_TIMER_MODES:
-        raise ValueError("Cache timer must be Always, Last 2 min, or Off.")
-    return {"cache_timer": mode}
-
-
 def menubar_settings(path=None):
     """Load menu-bar preferences; a missing or invalid value falls back to Always."""
     settings = load_json(path or TOKEN_METER_SETTINGS, {})
@@ -3150,27 +2588,11 @@ def set_menubar_settings(values, path=None):
     return {"ok": True, "changed": changed, "menubar": normalized}
 
 
-NOTIFICATIONS_SCHEMA_VERSION = 1
-NOTIFICATION_EVALUATE_INTERVAL_S = 2.0
 _notification_lock = threading.Lock()
-_notification_runtime = {"evaluated_at": None, "quota_established": False, "hints_reseed": True}
 # Only the running server owns the durable notification state; imports and tests stay read-free.
 _notification_persist = False
 
 
-def normalize_notification_settings(values):
-    """Validate the machine-wide quota alert preferences shared by every companion."""
-    if not isinstance(values, dict):
-        raise ValueError("Notification settings must be an object.")
-    quota_alerts = values.get("quota_alerts")
-    if not isinstance(quota_alerts, bool):
-        raise ValueError("Quota notifications must be on or off.")
-    threshold = values.get("quota_threshold")
-    if isinstance(threshold, bool) or threshold not in _notifications.USER_QUOTA_THRESHOLDS:
-        raise ValueError("Quota alert threshold must be 80, 90, or 95 percent.")
-    return {"quota_alerts": quota_alerts, "quota_threshold": int(threshold)}
-
-
 def notification_settings(path=None):
     """Load quota alert preferences; ``source`` says whether a companion may still migrate its own."""
     settings = load_json(path or TOKEN_METER_SETTINGS, {})
@@ -3306,9 +2728,6 @@ def claim_notification(event_id, consumer, path=None, now=None):
     return result
 
 
-_PUBLIC_EVENT_FIELDS = ("id", "kind", "severity", "title", "body", "link", "created_at", "claimed", "claimed_by")
-
-
 def notifications_payload(state=None, path=None, settings_path=None):
     """The versioned, content-free notification contract for every local companion."""
     if state is None:
@@ -3327,14 +2746,10 @@ def notifications_payload(state=None, path=None, settings_path=None):
     }
 
 
-WORK_PAUSE_CHOICES = ("1h", "tomorrow", "indefinite", "resume")
 _work_settings_cache = {"key": None, "value": None}
 _work_settings_lock = threading.Lock()
 
 
-WORK_INSIGHTS_UNSUPPORTED_ERROR = "Work insights are available on macOS only."
-
-
 def work_insights_supported():
     """Work insights rely on a local Ollama model and are supported on macOS only for now."""
     return _PLATFORM_SERVICES.platform_id == "macos"
@@ -3361,19 +2776,6 @@ def work_insights_settings(path=None):
     return copy.deepcopy(value)
 
 
-def _pause_until(choice, now=None):
-    now = time.time() if now is None else now
-    if choice == "resume":
-        return None
-    if choice == "indefinite":
-        return "indefinite"
-    if choice == "1h":
-        return now + 3600
-    local = datetime.datetime.fromtimestamp(now)
-    tomorrow = (local + datetime.timedelta(days=1)).replace(hour=6, minute=0, second=0, microsecond=0)
-    return tomorrow.timestamp()
-
-
 _work_settings_write_lock = threading.Lock()
 
 
@@ -3463,18 +2865,6 @@ def _set_work_insights_settings(values, path=None, model_consent=False):
                 or updated["backfill_days"] != current["backfill_days"]))}
 
 
-def _safe_update_revision(value):
-    value = str(value or "").strip().lower()
-    return value if re.fullmatch(r"[0-9a-f]{7,40}", value) else ""
-
-
-def _safe_update_int(value):
-    try:
-        return max(0, int(value or 0))
-    except (TypeError, ValueError):
-        return 0
-
-
 def source_checkout_path():
     """Find the installer checkout without returning it through the HTTP API."""
     runtime_root = _SOURCE_ROOT
@@ -3533,44 +2923,6 @@ def _persist_update_status(values, path=None):
     return True
 
 
-def _update_message(state, error_code="", latest_revision=""):
-    if state == "disabled":
-        return "Automatic update checks are off."
-    if state == "checking":
-        return "Checking the configured Git upstream."
-    if state == "updating":
-        return "Pulling and reinstalling Token Meter."
-    if state == "updated":
-        return "Token Meter was updated successfully."
-    if state == "available":
-        return (
-            f"Version {latest_revision} is ready to install."
-            if latest_revision else "A new version is ready to install."
-        )
-    if state == "current":
-        return "This installation matches its configured upstream."
-    if state == "waiting":
-        return "Waiting for the first update check."
-    messages = {
-        "source_unavailable": "The installed source checkout is unavailable.",
-        "git_unavailable": "Git is unavailable, so Token Meter cannot check for updates.",
-        "upstream_unavailable": "The source checkout has no usable tracking upstream.",
-        "unsupported_update_branch": "Automatic updates require a main checkout tracking a remote main branch.",
-        "fetch_failed": "Token Meter could not fetch the configured Git upstream.",
-        "inspect_failed": "Token Meter could not compare the installed and upstream revisions.",
-        "dirty_checkout": "An update exists, but the source checkout has local changes.",
-        "diverged_checkout": "An update exists, but the source checkout has diverged.",
-        "launch_failed": "Token Meter could not start the updater.",
-        "linux_helper_unavailable": (
-            "The installed Linux update helper is unavailable. "
-            "Reinstall Token Meter to repair automatic updates."
-        ),
-        "install_failed": "The update did not install. The existing checkout needs attention.",
-        "update_interrupted": "The last update stopped before it finished. Try installing it again.",
-    }
-    return messages.get(error_code, "Update status is unavailable.")
-
-
 def software_update_status(settings_path=None, status_path=None):
     """Return a bounded, path-free update snapshot for the local dashboard."""
     settings = update_settings(settings_path)
@@ -3916,28 +3268,6 @@ def software_update_watcher():
         _update_wake.wait(UPDATE_CHECK_INTERVAL_S)
 
 
-def toml_named_sections(path, table):
-    """Read simple enabled state from named TOML sections without a TOML dependency."""
-    try:
-        with open(path, encoding="utf-8") as fh:
-            text = fh.read()
-    except OSError:
-        return {}
-    header = re.compile(rf'^\[{re.escape(table)}\.(?:"([^"]+)"|([^\.\]]+))\]\s*$', re.MULTILINE)
-    matches = list(header.finditer(text))
-    result = {}
-    for index, match in enumerate(matches):
-        name = (match.group(1) or match.group(2) or "").strip()
-        end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
-        body = text[match.end():end]
-        enabled_match = re.search(r'^\s*enabled\s*=\s*(true|false)\s*$', body, re.MULTILINE | re.IGNORECASE)
-        result[name] = {
-            "enabled": enabled_match is None or enabled_match.group(1).lower() == "true",
-            "start": match.start(), "body_start": match.end(), "end": end,
-        }
-    return result
-
-
 def safe_mtime(path):
     try:
         return os.path.getmtime(path)
@@ -3945,20 +3275,6 @@ def safe_mtime(path):
         return 0
 
 
-def file_signature(path):
-    """Return a cheap cache key that changes when a trace is replaced or appended."""
-    try:
-        stat = os.stat(path)
-    except OSError:
-        return None
-    return stat.st_mtime_ns, stat.st_size
-
-
-def home_shorten(path):
-    home = os.path.expanduser("~")
-    return path.replace(home, "~", 1) if path and path.startswith(home) else path
-
-
 def source_runtime_label(source):
     """Return the trace runtime whose timing semantics produced this session."""
     source = source or {}
@@ -3980,155 +3296,7 @@ def source_runtime_label(source):
     return "Claude Desktop"
 
 
-def metric_availability(provider, **overrides):
-    """Describe which normalized metrics are backed by the provider trace.
-
-    Missing availability remains backward compatible elsewhere, but every new
-    state carries this object so unavailable Cursor billing values cannot look
-    like measured zeroes.
-    """
-    if provider == "cursor":
-        result = {
-            "cost": False,
-            "tokens": False,
-            "input_tokens": False,
-            "output_tokens": False,
-            "cache": False,
-            "throughput": False,
-            "context": False,
-            "timing": False,
-            "tool_results": False,
-        }
-    else:
-        result = {
-            "cost": True,
-            "tokens": True,
-            "input_tokens": True,
-            "output_tokens": True,
-            "cache": True,
-            "throughput": True,
-            "context": True,
-            "timing": True,
-            "tool_results": True,
-        }
-    result.update({key: bool(value) for key, value in overrides.items() if key in result})
-    return result
-
-
-def metric_available(row, metric):
-    """Treat absent availability as available for legacy states and fixtures."""
-    return _domain_metric_available(row, metric)
-
-
-def make_usage_provenance(session_ids, estimated_ids=(), available_ids=None,
-                          estimated_cost=0.0, estimated_tokens=0):
-    """Describe evidence quality separately from metric coverage."""
-    return _domain_make_usage_provenance(
-        session_ids,
-        estimated_ids,
-        available_ids,
-        estimated_cost,
-        estimated_tokens,
-    )
-
-
-def usage_provenance(rows):
-    """Roll up reported versus local-estimate sessions without changing coverage."""
-    return _domain_usage_provenance(rows)
-
-
-def decode_claude_project(name):
-    user = os.environ.get("USER", "")
-    prefix = "-Users-" + user
-    if user and name.startswith(prefix):
-        name = "~" + name[len(prefix):]
-    return name.strip("-").replace("-", "/").replace("~/", "~/")
-
-
-def decode_cursor_project(name):
-    """Best-effort fallback for Cursor's lossy project directory encoding."""
-    user = os.environ.get("USER", "")
-    prefix = f"Users-{user}-" if user else ""
-    if prefix and name.startswith(prefix):
-        return home_shorten("/Users/" + user + "/" + name[len(prefix):].replace("-", "/"))
-    return name.replace("-", "/") if name else ""
-
-
-def codex_id_from_path(path, meta=None):
-    if meta and meta.get("session_id"):
-        return meta["session_id"]
-    base = os.path.basename(path).rsplit(".", 1)[0]
-    match = re.search(r"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})", base)
-    return match.group(1) if match else base
-
-
-def normalize_dynamic_tools(dynamic_tools):
-    """Flatten old function arrays and newer namespace-grouped tool catalogs."""
-    out = []
-    for item in dynamic_tools or []:
-        if not isinstance(item, dict):
-            out.append({
-                "namespace": "unknown", "name": str(item) or "?", "kind": "tool",
-                "defer_loading": False, "definition_tokens": 0,
-            })
-            continue
-        children = item.get("tools")
-        rows = children if isinstance(children, list) else [item]
-        parent_namespace = item.get("namespace") or item.get("name") or "unknown"
-        parent_deferred = bool(item.get("deferLoading"))
-        for child in rows:
-            if not isinstance(child, dict):
-                child = {"name": str(child)}
-            name = child.get("name") or "?"
-            namespace = child.get("namespace") or parent_namespace or "unknown"
-            raw_identity = name
-            host_provided = False
-            if name.startswith("mcp__"):
-                ident = tool_identity(name)
-                namespace = ident["namespace"]
-                kind = "mcp"
-            elif str(namespace).startswith("mcp__"):
-                parts = str(namespace).split("__")
-                namespace = parts[1] if len(parts) > 1 and parts[1] else "mcp"
-                raw_identity = f"mcp__{namespace}__{name}"
-                kind = "mcp"
-            elif isinstance(children, list) and namespace not in CODEX_BUILTIN_NAMESPACES:
-                raw_identity = f"mcp__{namespace}__{name}"
-                kind = "mcp"
-                host_provided = True
-            else:
-                kind = "tool"
-            definition = {
-                "description": child.get("description") or "",
-                "inputSchema": child.get("inputSchema") or child.get("input_schema") or {},
-            }
-            entry = {
-                "namespace": namespace,
-                "name": raw_identity,
-                "kind": kind,
-                "defer_loading": bool(child.get("deferLoading", parent_deferred)),
-                "definition_tokens": len(json.dumps(definition, sort_keys=True)) // CHARS_PER_TOKEN,
-            }
-            if host_provided:
-                entry["host_provided"] = True
-            out.append(entry)
-    return out[:240]
-
-
-def catalog_counts(catalog):
-    advertised = len(catalog or [])
-    deferred = sum(1 for row in catalog or [] if row.get("defer_loading"))
-    return {"advertised": advertised, "eager": max(0, advertised - deferred), "deferred": deferred}
-
-
-def cursor_model(composer, header=None):
-    return cursor_model_name(composer, header)
-
-
-_claude_native_adapters = {}
 _codex_native_adapters = {}
-_cursor_native_adapters = {}
-_kiro_native_adapters = {}
 
 
 def _claude_compatibility():
@@ -4487,9 +3655,6 @@ def recompute_hermes(source):
     return _hermes_native_adapter().recompute_legacy(source)
 
 
-_agy_native_adapters = {}
-
-
 def _agy_compatibility():
     return {
         "add_model_daily": add_model_daily,
@@ -4548,7 +3713,6 @@ def opencode_db_path():
 
 
 _opencode_native_adapters = {}
-_opencode_adapter_key = {"configured": None, "key": None}
 
 
 def _opencode_compatibility():
@@ -4626,11 +3790,6 @@ def _opencode_db_connection(path=None):
     return OpenCodeRuntimeAdapter(path, OPENCODE_MODELS_PATH).connection()
 
 
-def _opencode_json(value, default=None):
-    """Decode one OpenCode SQLite JSON text value without failing the session."""
-    return _native_opencode_json(value, default)
-
-
 def opencode_session_sources(db_path=None):
     if db_path is not None:
         adapter = OpenCodeRuntimeAdapter(
@@ -4692,11 +3851,6 @@ def cursor_metadata_index(db_path=None):
     return _cursor_adapter_for(database_path=db_path).metadata_index()
 
 
-def reset_cursor_metadata_cache():
-    for adapter in _cursor_native_adapters.values():
-        adapter.reset_metadata_cache()
-
-
 def cursor_snapshot(composer_id, db_path=None):
     return _cursor_adapter_for(database_path=db_path).snapshot_legacy(str(composer_id))
 
@@ -4758,30 +3912,6 @@ def supported_runtime_phrase():
     return "{}, or {}".format(", ".join(labels[:-1]), labels[-1])
 
 
-def git_delivery_project_roots(sources):
-    """Return ordered unique normalized roots relevant to Git candidate selection."""
-    roots = []
-    seen = set()
-    for source in sources or ():
-        raw_project = source.get("project") if isinstance(source, dict) else ""
-        if not isinstance(raw_project, str):
-            continue
-        if project_filter_key(raw_project) == OTHER_LOCAL_SESSIONS_PROJECT:
-            continue
-        root = os.path.abspath(os.path.expanduser(raw_project))
-        if root not in seen:
-            roots.append(root)
-            seen.add(root)
-    return tuple(roots)
-
-
-def git_delivery_source_signature(roots):
-    """Return a private ordered-root membership signature for Git candidates."""
-    return hashlib.sha256(
-        "\0".join(roots).encode("utf-8", "replace"),
-    ).hexdigest()
-
-
 def source_inventory_snapshot():
     """Read one atomically published source inventory reference."""
     with _source_inventory_lock:
@@ -5049,89 +4179,6 @@ def trash_session_log(session_id, sources=None, trash_dir=None, mover=None, trac
     }
 
 
-def _matching_price(model, table):
-    _rule, price = _catalog_matching_price(model, table)
-    return price
-
-
-def cursor_model_parameters(composer, model=None):
-    """Return persisted parameters for the selected Cursor model."""
-    config = composer.get("modelConfig") if isinstance(composer, dict) else {}
-    selected = config.get("selectedModels") if isinstance(config, dict) else []
-    for row in selected or []:
-        if not isinstance(row, dict):
-            continue
-        params = {
-            str(item.get("id")): item.get("value")
-            for item in (row.get("parameters") or []) if isinstance(item, dict) and item.get("id")
-        }
-        if not model or str(row.get("modelId") or "") == str(model):
-            return params
-    return {}
-
-
-def cursor_price_variant(composer, model, spawn_model=""):
-    config = composer.get("modelConfig") if isinstance(composer, dict) else {}
-    if isinstance(config, dict) and config.get("maxMode") is True:
-        for row in config.get("selectedModels") or []:
-            model_id = str(row.get("modelId") or "") if isinstance(row, dict) else ""
-            if model_id and _catalog_model_alias_matches(model, "cursor", model_id):
-                if str(cursor_model_parameters(composer, model_id).get("fast")).lower() == "true":
-                    return "max-fast"
-                break
-        return "max"
-    for cursor_model_id in CURSOR_VARIANT_MODEL_IDS:
-        if not _catalog_model_alias_matches(model, "cursor", cursor_model_id):
-            continue
-        params = cursor_model_parameters(composer, cursor_model_id)
-        fast = str(params.get("fast")).lower()
-        if fast not in ("true", "false"):
-            # A subagent's own config may omit speed; its parent's spawn call names the exact variant.
-            fast = {cursor_model_id + "-fast": "true", cursor_model_id + "-standard": "false"}.get(
-                str(spawn_model or "").lower(), fast)
-        context = str(params.get("context") or "").lower()
-        prefix = (
-            "500k-" if cursor_model_id == "grok-4.7" and context in ("500k", "500000")
-            else ""
-        )
-        if fast == "true":
-            return prefix + "fast"
-        if fast == "false":
-            return prefix + "standard"
-        return ""
-    selected = config.get("selectedModels") if isinstance(config, dict) else []
-    for row in selected or []:
-        model_id = str(row.get("modelId") or "") if isinstance(row, dict) else ""
-        if model_id and _catalog_model_alias_matches(model, "cursor", model_id):
-            if str(cursor_model_parameters(composer, model_id).get("fast")).lower() == "true":
-                return "fast"
-            break
-    return ""
-
-
-@functools.lru_cache(maxsize=2048)
-def _cached_price_query(model_provider, model_id, variant, timestamp):
-    observed_at = (
-        None if timestamp is None else
-        datetime.datetime.fromtimestamp(timestamp, datetime.timezone.utc)
-    )
-    return PriceQuery(
-        ModelRef(model_provider, model_id, variant),
-        observed_at,
-    )
-
-
-def _price_query_from_compat(model_provider, model, variant=None, at=None):
-    """Construct a bounded cached request for the compatibility facade."""
-    model_id = str(model or "").strip() or "unknown-model"
-    if len(model_id) > 160:
-        model_id = "unknown-model"
-    variant = str(variant).strip() if variant is not None else None
-    return _cached_price_query(
-        model_provider, model_id, variant or None, _price_timestamp(at)
-    )
-
-
 def price_quote(query, path=None):
     """Resolve one exact model-provider query without cross-provider fallback."""
     settings_provider = settings_provider_for_model_provider(query.model.provider_id)
@@ -5154,17 +4201,6 @@ def price_quote(query, path=None):
     return quote
 
 
-# OpenCode message rows carry the upstream provider that served the model.
-# Only direct vendor identities may reuse that vendor's public catalog; the
-# OpenCode and OpenCode Go aggregators keep their own (possibly negotiated)
-# rates and never borrow a vendor price.
-OPENCODE_UPSTREAM_MODEL_PROVIDERS = {
-    "anthropic": "anthropic",
-    "openai": "openai",
-    "cursor": "cursor",
-}
-
-
 def _opencode_price_quote(model, model_provider=None, variant=None, at=None):
     """Resolve an OpenCode estimate from its own rows, then a direct vendor."""
 
@@ -5210,66 +4246,17 @@ def price_for(model, provider="claude", variant=None, at=None):
     return (quote.to_legacy_price() or dict(ZERO_PRICE)), approximate
 
 
-def _price_multipliers(u, model, provider, at=None):
-    """Return current published long-context multipliers without repricing history."""
-    timestamp = _price_timestamp(at)
-    if timestamp is not None and timestamp < GPT_56_PRICE_UPDATE_AT:
-        return 1.0, 1.0
-    compact = str(model or "").replace(" ", "-").lower()
-    # Codex bills credits and subscriptions, which OpenAI documents without the API's
-    # long-context surcharge; Cursor passes API pricing through.
-    if (provider != "cursor" or
-            not compact.startswith(("gpt-5.6", "gpt-6-", "gpt-6.1-"))):
-        return 1.0, 1.0
-    input_tokens = (
-        int(u.get("input_tokens", 0) or 0)
-        + int(u.get("cache_creation_input_tokens", 0) or 0)
-        + int(u.get("cache_read_input_tokens", 0) or 0)
+def claude_billing_supported(u, model, variant=None, at=None):
+    usage = (
+        u if isinstance(u, dict) and "cache_duration_available" in u
+        else _normalized_claude_usage(u)
     )
-    if input_tokens > GPT_56_LONG_CONTEXT_TOKENS:
-        return 2.0, 1.5
-    return 1.0, 1.0
-
+    quote, _ = _resolved_price_quote(model, "claude", variant, at=at)
+    return _claude_quote_supports_dimensions(usage, quote)
 
-_CLAUDE_FAST_PREMIUM_RULES = frozenset((
-    "claude-opus-5-5", "claude-opus-5", "claude-opus-4-8",
-))
-_CLAUDE_FAST_STANDARD_RULES = frozenset(("claude-opus-4-6",))
-_CLAUDE_INFERENCE_GEO_RULES = frozenset((
-    "claude-mythos-5", "claude-mythos-5-1",
-    "claude-fable-5", "claude-fable-5-1",
-    "claude-opus-5-5", "claude-opus-5", "claude-opus-4-8", "claude-opus-4-7",
-    "claude-opus-4-6", "claude-sonnet-5-5", "claude-sonnet-5",
-    "claude-sonnet-4-6", "claude-haiku-5-5",
-))
 
-
-def _claude_quote_supports_dimensions(usage, quote):
-    if not quote.available or not usage.get("billing_available"):
-        return False
-    matched_rule = quote.matched_rule
-    if (usage.get("speed") == "fast" and
-            matched_rule not in (
-                _CLAUDE_FAST_PREMIUM_RULES | _CLAUDE_FAST_STANDARD_RULES
-            )):
-        return False
-    if (usage.get("inference_geo") in ("global", "us") and
-            matched_rule not in _CLAUDE_INFERENCE_GEO_RULES):
-        return False
-    return True
-
-
-def claude_billing_supported(u, model, variant=None, at=None):
-    usage = (
-        u if isinstance(u, dict) and "cache_duration_available" in u
-        else _normalized_claude_usage(u)
-    )
-    quote, _ = _resolved_price_quote(model, "claude", variant, at=at)
-    return _claude_quote_supports_dimensions(usage, quote)
-
-
-def cost_of(u, model, provider="claude", variant=None, at=None, channel=None):
-    """Price one request and apply the discount in force at its own time.
+def cost_of(u, model, provider="claude", variant=None, at=None, channel=None):
+    """Price one request and apply the discount in force at its own time.
 
     Returns a ``CostBreakdown``: its values are already discounted (callers
     summing ``values()`` get what you pay) and ``discount_usd`` is the amount
@@ -5367,55 +4354,6 @@ def _list_cost_of(u, model, provider, variant, at, quote):
     )
 
 
-@functools.lru_cache(maxsize=1024)
-def _compat_price_quote(provider_id, model_id, variant, input_price, output_price,
-                        cache_read_price, cache_write_price):
-    return PriceQuote(
-        model=ModelRef(provider_id, model_id, variant or None),
-        input_per_million=input_price,
-        output_per_million=output_price,
-        cache_read_per_million=cache_read_price,
-        cache_write_per_million=cache_write_price,
-        basis=EvidenceBasis.ESTIMATED,
-        matched_rule=None,
-    )
-
-
-def usage_tokens(u):
-    return _domain_usage_token_total_counts(
-        u.get("input_tokens", 0),
-        u.get("output_tokens", 0),
-        u.get("cache_read_input_tokens", 0),
-        u.get("cache_creation_input_tokens", 0),
-    )
-
-
-def usage_io_tokens(u):
-    """Return total trace-reported input, including cache, and output."""
-    return _domain_usage_io_token_counts(
-        u.get("input_tokens", 0),
-        u.get("output_tokens", 0),
-        u.get("cache_read_input_tokens", 0),
-        u.get("cache_creation_input_tokens", 0),
-    )
-
-
-def add_model_summary(stats, model, usage, cost, cost_available=None, discount=None):
-    """Accumulate one request; ``discount`` defaults to the one ``cost`` carries."""
-    return _domain_add_model_summary(
-        stats, model, usage, cost, cost_available=cost_available,
-        discount=discount_of(cost) if discount is None else discount,
-    )
-
-
-def add_model_daily(stats, model, usage, cost, ts, cost_available=None, discount=None):
-    """Accumulate exact trace-reported model I/O into local calendar days."""
-    return _domain_add_model_daily(
-        stats, model, usage, cost, ts, cost_available=cost_available,
-        discount=discount_of(cost) if discount is None else discount,
-    )
-
-
 def claude_performance_samples(objs):
     """Return completed Claude turn samples with attributable trace timing."""
     messages = {rec["id"]: rec for rec in iter_claude_messages(objs)}
@@ -5546,584 +4484,6 @@ def close_turn(obj=None):
     return samples
 
 
-def codex_performance_samples(objs, default_model=None):
-    """Return completed Codex task samples with model-attributable timing."""
-    model = default_model or "unknown-model"
-    samples = []
-    current = None
-
-    def ensure_current(ts=0):
-        nonlocal current
-        if current is None:
-            current = {"started_ts": ts or 0, "usage": {}, "tool_calls": 0}
-        return current
-
-    def close_task(payload, ts):
-        nonlocal current
-        task = current
-        current = None
-        if not task or len(task["usage"]) != 1:
-            return
-        duration_ms = payload.get("duration_ms")
-        ttft_ms = payload.get("time_to_first_token_ms")
-        try:
-            duration_ms = float(duration_ms or 0)
-            ttft_ms = float(ttft_ms or 0)
-        except (TypeError, ValueError):
-            return
-        if duration_ms <= 0:
-            return
-        sample_model, counts = next(iter(task["usage"].items()))
-        output_tokens = int(counts.get("output_tokens") or 0)
-        if output_tokens <= 0:
-            return
-        duration_s = duration_ms / 1000.0
-        generation_s = (duration_ms - ttft_ms) / 1000.0 if 0 < ttft_ms < duration_ms else duration_s
-        samples.append({
-            "provider": "codex", "model": sample_model,
-            "day": time.strftime("%Y-%m-%d", time.localtime(ts)) if ts else "",
-            "ts": ts or 0, "input_tokens": int(counts.get("input_tokens") or 0),
-            "output_tokens": output_tokens, "duration_s": duration_s,
-            "peak_input_tokens": int(counts.get("peak_input_tokens") or 0),
-            "uncached_input_tokens": int(counts.get("uncached_input_tokens") or 0),
-            "cache_read_tokens": int(counts.get("cache_read_tokens") or 0),
-            "cache_write_tokens": int(counts.get("cache_write_tokens") or 0),
-            "model_calls": int(counts.get("model_calls") or 0),
-            "generation_s": generation_s, "ttft_s": max(0.0, ttft_ms / 1000.0),
-            "tool_calls": int(task.get("tool_calls") or 0), "timing_basis": "task_complete",
-        })
-
-    for obj in objs:
-        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-        ptype = payload.get("type")
-        ts = parse_iso(obj.get("timestamp", "")) or 0
-        if obj.get("type") == "turn_context":
-            model = payload.get("model") or model
-            continue
-        if ptype == "task_started":
-            current = {"started_ts": ts, "usage": {}, "tool_calls": 0}
-            continue
-        if ptype in ("function_call", "custom_tool_call", "web_search_call", "tool_search_call"):
-            ensure_current(ts)["tool_calls"] += 1
-            continue
-        if ptype == "token_count":
-            raw = ((payload.get("info") or {}).get("last_token_usage") or {})
-            if not raw:
-                continue
-            usage = codex_usage(raw)
-            task = ensure_current(ts)
-            row = task["usage"].setdefault(model, {
-                "input_tokens": 0, "output_tokens": 0, "peak_input_tokens": 0,
-                "uncached_input_tokens": 0, "cache_read_tokens": 0,
-                "cache_write_tokens": 0, "model_calls": 0,
-            })
-            input_count, output_count = usage_io_tokens(usage)
-            row["input_tokens"] += input_count
-            row["output_tokens"] += output_count
-            row["peak_input_tokens"] = max(row["peak_input_tokens"], input_count)
-            row["uncached_input_tokens"] += int(usage.get("input_tokens") or 0)
-            row["cache_read_tokens"] += int(usage.get("cache_read_input_tokens") or 0)
-            row["cache_write_tokens"] += int(usage.get("cache_creation_input_tokens") or 0)
-            row["model_calls"] += 1
-            continue
-        if ptype == "task_complete":
-            close_task(payload, ts)
-    return samples
-
-
-def codex_live_performance_summary(objs):
-    """Return provisional pace from completed checkpoints in the active task.
-
-    Final throughput remains gated on ``task_complete`` in
-    ``codex_performance_samples``. This separate summary lets the native menu
-    show useful progress sooner without admitting an unfinished task into
-    historical/model analytics. The denominator stops at the latest completed
-    token checkpoint, so the displayed value changes only when another step
-    completes rather than decaying while a tool is still running.
-    """
-    current = None
-
-    for obj in objs:
-        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-        ptype = payload.get("type")
-        ts = parse_iso(obj.get("timestamp", "")) or 0
-        if ptype == "task_started":
-            current = {
-                "started_ts": ts,
-                "latest_checkpoint_ts": 0,
-                "output_tokens": 0,
-                "completed_steps": 0,
-            }
-            continue
-        if ptype == "task_complete":
-            current = None
-            continue
-        if ptype != "token_count" or not current:
-            continue
-        raw = ((payload.get("info") or {}).get("last_token_usage") or {})
-        if not raw:
-            continue
-        output_tokens = usage_io_tokens(codex_usage(raw))[1]
-        if output_tokens <= 0 or not ts:
-            continue
-        current["output_tokens"] += output_tokens
-        current["completed_steps"] += 1
-        current["latest_checkpoint_ts"] = max(
-            float(current.get("latest_checkpoint_ts") or 0), ts,
-        )
-
-    empty = {
-        "available": False,
-        "output_tps": 0,
-        "basis": "unavailable",
-        "completed_steps": 0,
-        "measured_output_tokens": 0,
-        "measured_seconds": 0,
-    }
-    if not current:
-        return empty
-    started_ts = float(current.get("started_ts") or 0)
-    checkpoint_ts = float(current.get("latest_checkpoint_ts") or 0)
-    measured_seconds = checkpoint_ts - started_ts
-    measured_output = int(current.get("output_tokens") or 0)
-    completed_steps = int(current.get("completed_steps") or 0)
-    if measured_seconds <= 0 or measured_output <= 0 or completed_steps <= 0:
-        return empty
-    return {
-        "available": True,
-        "output_tps": measured_output / measured_seconds,
-        "basis": "live_end_to_end",
-        "completed_steps": completed_steps,
-        "measured_output_tokens": measured_output,
-        "measured_seconds": measured_seconds,
-    }
-
-
-def _wait_sample(group, end_ts, duration_s, timing_basis, provider,
-                 wall_duration_s=None, user_pause_s=0.0):
-    """Return one completed prompt-to-response wall-clock sample."""
-    if not group or duration_s <= 0:
-        return None
-    models = sorted(name for name in (group.get("models") or set()) if name)
-    model = models[0] if len(models) == 1 else ("mixed" if models else "unknown")
-    return {
-        "provider": provider,
-        "model": model,
-        "day": time.strftime("%Y-%m-%d", time.localtime(end_ts)) if end_ts else "",
-        "ts": end_ts or 0,
-        "start_ts": float(group.get("start_ts") or 0),
-        "duration_s": float(duration_s),
-        "tool_calls": int(group.get("tool_calls") or 0),
-        "output_tokens": int(group.get("output_tokens") or 0),
-        "timing_basis": timing_basis,
-        "wall_duration_s": float(wall_duration_s if wall_duration_s is not None else duration_s),
-        "user_pause_s": float(user_pause_s or 0),
-    }
-
-
-def claude_wait_samples(objs):
-    """Return completed Claude prompt-to-response wait samples.
-
-    Wait time is deliberately end to end: reasoning, tool use, and model output
-    all count because the user is still waiting for the turn to finish.
-    """
-    samples = []
-    current = None
-
-    def close_turn(end_ts=0, duration_ms=0, allow_observed=False):
-        nonlocal current
-        group = current
-        current = None
-        if not group:
-            return
-        try:
-            duration_ms = float(duration_ms or 0)
-        except (TypeError, ValueError):
-            duration_ms = 0
-        if duration_ms > 0:
-            duration_s = duration_ms / 1000.0
-            basis = "reported"
-        elif allow_observed:
-            end_ts = end_ts or group.get("last_ts") or 0
-            duration_s = float(end_ts or 0) - float(group.get("start_ts") or 0)
-            basis = "observed"
-        else:
-            return
-        wall_duration_s = duration_s
-        duration_s, user_pause_s = _claude_effective_duration(group, duration_s, basis)
-        sample = _wait_sample(group, end_ts or group.get("last_ts") or 0,
-                              duration_s, basis, "claude", wall_duration_s, user_pause_s)
-        if sample:
-            samples.append(sample)
-
-    for obj in objs:
-        otype = obj.get("type")
-        ts = parse_iso(obj.get("timestamp", "")) or 0
-        if _claude_user_prompt(obj):
-            close_turn(allow_observed=bool(current and current.get("terminal")))
-            current = {
-                "start_ts": ts, "last_ts": ts, "models": set(),
-                "tool_ids": set(), "tool_calls": 0, "output_tokens": 0,
-                "seen_usage": set(), "terminal": False,
-                "user_pause_starts": {}, "user_pause_s": 0.0,
-            }
-            continue
-        if otype == "user" and current:
-            msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-            _close_claude_user_pauses(current, msg, ts)
-            current["last_ts"] = max(float(current.get("last_ts") or 0), ts)
-            continue
-        if otype == "assistant" and current:
-            msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-            model = msg.get("model")
-            if model:
-                current["models"].add(model)
-            current["last_ts"] = max(float(current.get("last_ts") or 0), ts)
-            message_id = msg.get("id") or obj.get("uuid")
-            if message_id not in current["seen_usage"]:
-                current["seen_usage"].add(message_id)
-                output_tokens, _ = _domain_normalize_reported_token_count(
-                    (msg.get("usage") or {}).get("output_tokens")
-                )
-                current["output_tokens"] += output_tokens
-            for block in msg.get("content") or []:
-                if not isinstance(block, dict) or block.get("type") != "tool_use":
-                    continue
-                tool_id = block.get("id") or (block.get("name"), len(current["tool_ids"]))
-                current["tool_ids"].add(tool_id)
-                _track_claude_user_pause(current, block, ts)
-            current["tool_calls"] = len(current["tool_ids"])
-            if msg.get("stop_reason") and msg.get("stop_reason") != "tool_use":
-                current["terminal"] = True
-            continue
-        if otype == "system" and obj.get("subtype") == "turn_duration":
-            close_turn(ts, obj.get("durationMs"), allow_observed=True)
-    if current and current.get("terminal"):
-        close_turn(current.get("last_ts") or 0, allow_observed=True)
-    return samples
-
-
-def codex_wait_samples(objs, default_model=None):
-    """Return completed Codex task prompt-to-response wait samples."""
-    samples = []
-    model = default_model or "unknown-model"
-    current = None
-
-    def close_task(end_ts=0, duration_ms=0, allow_observed=False):
-        nonlocal current
-        group = current
-        current = None
-        if not group:
-            return
-        try:
-            duration_ms = float(duration_ms or 0)
-        except (TypeError, ValueError):
-            duration_ms = 0
-        if duration_ms > 0:
-            duration_s = duration_ms / 1000.0
-            basis = "reported"
-        elif allow_observed:
-            end_ts = end_ts or group.get("last_ts") or 0
-            duration_s = float(end_ts or 0) - float(group.get("start_ts") or 0)
-            basis = "observed"
-        else:
-            return
-        sample = _wait_sample(group, end_ts or group.get("last_ts") or 0,
-                              duration_s, basis, "codex")
-        if sample:
-            samples.append(sample)
-
-    for obj in objs:
-        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-        ptype = payload.get("type")
-        ts = parse_iso(obj.get("timestamp", "")) or 0
-        if obj.get("type") == "turn_context":
-            model = payload.get("model") or model
-            if current:
-                current["models"].add(model)
-            continue
-        if ptype == "task_started":
-            close_task(allow_observed=False)
-            current = {
-                "start_ts": ts, "last_ts": ts, "models": {model},
-                "tool_calls": 0, "output_tokens": 0,
-            }
-            continue
-        if not current:
-            continue
-        current["last_ts"] = max(float(current.get("last_ts") or 0), ts)
-        if ptype in ("function_call", "custom_tool_call", "web_search_call", "tool_search_call"):
-            current["tool_calls"] += 1
-            continue
-        if ptype == "token_count":
-            raw = ((payload.get("info") or {}).get("last_token_usage") or {})
-            if raw:
-                current["output_tokens"] += usage_io_tokens(codex_usage(raw))[1]
-            continue
-        if ptype == "task_complete":
-            close_task(ts, payload.get("duration_ms"), allow_observed=True)
-    return samples
-
-
-def wait_time_summary(samples):
-    return _domain_wait_time_summary(samples)
-
-
-def performance_summary(samples, total_output_tokens=0):
-    return _domain_performance_summary(samples, total_output_tokens)
-
-
-def codex_usage(raw):
-    raw = raw or {}
-    input_total, input_reported = _domain_normalize_reported_token_count(
-        raw.get("input_tokens")
-    )
-    cached, cache_reported = _domain_normalize_reported_token_count(
-        raw.get("cached_input_tokens", 0)
-    )
-    output_tokens, output_reported = _domain_normalize_reported_token_count(
-        raw.get("output_tokens")
-    )
-    total_tokens, _ = _domain_normalize_reported_token_count(
-        raw.get("total_tokens", 0)
-    )
-    input_available = input_reported and cache_reported and cached <= input_total
-    reasoning_tokens, reasoning_available = _domain_normalize_reported_token_count(
-        raw.get("reasoning_output_tokens")
-    )
-    reasoning_available = (
-        output_reported
-        and reasoning_available
-        and reasoning_tokens <= output_tokens
-    )
-    return {
-        "input_tokens": max(0, input_total - cached) if input_available else 0,
-        "cache_creation_input_tokens": 0,
-        "cache_read_input_tokens": cached if input_available else 0,
-        "output_tokens": output_tokens if output_reported else 0,
-        "input_available": input_available,
-        "output_available": output_reported,
-        "reasoning_output_tokens": reasoning_tokens if reasoning_available else 0,
-        "reasoning_available": reasoning_available,
-        "total_tokens": total_tokens,
-    }
-
-
-def tool_identity(name):
-    return _domain_tool_identity(name)
-
-
-def trace_event(ts, kind, label, detail="", execution=None, tool=None, tokens=0, cost=0.0, severity="neutral", **meta):
-    event = {
-        "ts": ts or 0,
-        "time": local_tm(ts),
-        "local": local_dt(ts),
-        "kind": kind,
-        "label": label,
-        "detail": detail,
-        "execution": execution,
-        "tool": tool,
-        "tokens": int(tokens or 0),
-        "cost": round(cost or 0.0, 6),
-        "severity": severity,
-    }
-    for key, value in meta.items():
-        if value is not None:
-            event[key] = value
-    return event
-
-
-def trim_trace(trace):
-    return trace[-TRACE_LIMIT:]
-
-
-def compact_text(s, limit=72):
-    s = " ".join((s or "").split())
-    return s[:limit - 1] + "…" if len(s) > limit else s
-
-
-def text_from_content(content):
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        pieces = []
-        for block in content:
-            if isinstance(block, dict):
-                pieces.append(block.get("text") or block.get("content") or "")
-        return " ".join(p for p in pieces if isinstance(p, str))
-    return ""
-
-
-def claude_user_text(msg):
-    content = msg.get("content") if isinstance(msg, dict) else None
-    if isinstance(content, str):
-        return content
-    if not isinstance(content, list):
-        return ""
-    pieces = []
-    for block in content:
-        if not isinstance(block, dict):
-            continue
-        btype = block.get("type")
-        if btype in (None, "text"):
-            pieces.append(block.get("text") or block.get("content") or "")
-    return " ".join(p for p in pieces if isinstance(p, str))
-
-
-def _claude_human_text(obj):
-    """Return human-authored Claude text, None for tool/meta/user-shaped records."""
-    if obj.get("type") != "user" or obj.get("isMeta") or obj.get("isSidechain"):
-        return None
-    if obj.get("sourceToolAssistantUUID") or obj.get("toolUseResult") is not None:
-        return None
-    msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-    content = msg.get("content")
-    if isinstance(content, list):
-        text_blocks = [
-            block.get("text") or block.get("content") or ""
-            for block in content
-            if isinstance(block, dict) and block.get("type") in (None, "text")
-        ]
-        if not text_blocks and any(
-            isinstance(block, dict) and block.get("type") == "tool_result" for block in content
-        ):
-            return None
-        text = " ".join(value for value in text_blocks if isinstance(value, str))
-    elif isinstance(content, str):
-        text = content
-    else:
-        text = ""
-    stripped = text.strip()
-    meta_prefixes = (
-        "<local-command-caveat>", "<local-command-stdout>",
-        "<command-name>", "<system-reminder>",
-    )
-    if stripped.startswith(meta_prefixes):
-        return None
-    return text
-
-
-USER_TURN_CONTEXT_CHARS = 600
-
-
-def _dedupe_user_turns(turns, window_seconds=2.0):
-    result = []
-    for turn in turns:
-        fingerprint = " ".join(str(turn.get("text") or "").lower().split())
-        previous = result[-1] if result else None
-        if previous:
-            previous_fingerprint = " ".join(str(previous.get("text") or "").lower().split())
-            delta = abs(float(turn.get("ts") or 0) - float(previous.get("ts") or 0))
-            if fingerprint == previous_fingerprint and delta <= window_seconds:
-                continue
-        result.append(turn)
-    return result
-
-
-def claude_user_turns(objs, default_model=None):
-    turns = []
-    pending = []
-    current_model = default_model or "unknown-model"
-    context = ""
-    for obj in objs or []:
-        text = _claude_human_text(obj)
-        if text is not None:
-            turn = {
-                "ts": parse_iso(obj.get("timestamp", "")) or 0,
-                "text": text,
-                "model": None,
-                "context": context,
-            }
-            turns.append(turn)
-            pending.append(turn)
-            continue
-        if obj.get("type") != "assistant":
-            continue
-        msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-        content = msg.get("content")
-        if isinstance(content, list) and not obj.get("isSidechain"):
-            said = " ".join(
-                block.get("text") or "" for block in content
-                if isinstance(block, dict) and block.get("type") == "text"
-                and isinstance(block.get("text"), str)
-            ).strip()
-            if said:
-                context = said[-USER_TURN_CONTEXT_CHARS:]
-        model = msg.get("model") or current_model
-        current_model = model
-        if pending:
-            for turn in pending:
-                turn["model"] = model
-            pending = []
-    for turn in pending:
-        turn["model"] = current_model
-    return _dedupe_user_turns(turns)
-
-
-def _codex_fallback_user_text(payload):
-    if payload.get("type") != "message" or payload.get("role") != "user":
-        return None
-    content = payload.get("content")
-    blocks = content if isinstance(content, list) else [content]
-    human_blocks = []
-    for block in blocks:
-        text = text_from_content([block] if isinstance(content, list) else block)
-        stripped = text.strip()
-        if not stripped or stripped.startswith((
-                "<recommended_plugins>",
-                "# AGENTS.md instructions",
-                "<environment_context>",
-        )):
-            continue
-        human_blocks.append(text)
-    return "\n".join(human_blocks) if human_blocks else None
-
-
-def codex_user_turns(objs, default_model=None):
-    """Prefer canonical user_message events; fall back for older Codex logs."""
-    current_model = default_model or "unknown-model"
-    event_turns = []
-    fallback_turns = []
-    context = ""
-    for obj in objs or []:
-        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-        if obj.get("type") == "turn_context":
-            current_model = payload.get("model") or current_model
-            continue
-        ts = parse_iso(obj.get("timestamp", "")) or 0
-        if payload.get("type") == "agent_message" and isinstance(payload.get("message"), str):
-            if payload["message"].strip():
-                context = payload["message"].strip()[-USER_TURN_CONTEXT_CHARS:]
-            continue
-        if payload.get("type") == "message" and payload.get("role") == "assistant":
-            # Current Codex rollouts carry assistant text only as response_item messages.
-            said = text_from_content(payload.get("content")).strip()
-            if said:
-                context = said[-USER_TURN_CONTEXT_CHARS:]
-            continue
-        if payload.get("type") == "user_message":
-            event_turns.append({"ts": ts, "text": payload.get("message") or "",
-                                "model": current_model, "context": context})
-            continue
-        text = _codex_fallback_user_text(payload)
-        if text is not None:
-            fallback_turns.append({"ts": ts, "text": text, "model": current_model, "context": context})
-    return _dedupe_user_turns(event_turns or fallback_turns)
-
-
-def cursor_user_turns(objs, default_model=None):
-    """Extract human turns from Cursor's durable transcript without wrappers."""
-    turns = []
-    for row in objs or []:
-        if not isinstance(row, dict) or row.get("role") != "user":
-            continue
-        text = text_from_content(cursor_message_content(row))
-        match = re.search(r"<user_query>\s*(.*?)\s*</user_query>", text, flags=re.DOTALL)
-        turns.append({"ts": 0, "text": match.group(1) if match else text,
-                      "model": default_model or "unknown"})
-    return turns
-
-
 def user_turns_for_provider(provider, objs, default_model=None):
     if provider == "codex":
         return codex_user_turns(objs, default_model)
@@ -6133,7 +4493,6 @@ def user_turns_for_provider(provider, objs, default_model=None):
 
 
 _WORK_TURNS = threading.local()
-_WORK_TURNS_HANDOFF_KEY = "_work_turns_handoff"
 
 
 def capture_work_turns(turns):
@@ -6150,630 +4509,68 @@ def capture_work_turns(turns):
 
 def work_insights_enabled():
     """Adapters skip Work-only extraction (priced events, tool actions) unless Work insights are on."""
-    return bool(work_insights_settings()["enabled"])
-
-
-def attach_work_requests(row, turns, events=(), actions=()):
-    """Give each typed request its share of cost and what the agent did next, for Work insights.
-
-    ``events`` are (ts, cost, model, effort) per priced assistant event; ``actions`` come from
-    ``_work_evidence.tool_action``. The row keeps only content-free slices; the action summary,
-    which may name edited files, rides with the request text to the in-memory classifier queue.
-    """
-    turns = list(turns or ())
-    slices = None
-    if work_insights_settings()["enabled"]:
-        slices, edited = _work_evidence.request_slices([turn.get("ts") for turn in turns], events, actions)
-        for turn, slice_, paths in zip(turns, slices or (), edited or ()):
-            turn["cost"] = slice_["cost"]
-            turn["evidence"] = _work_evidence.evidence_text(slice_, paths)
-    row["_work_requests"] = slices or []
-    row["_work_turn_days"] = capture_work_turns(turns)
-    return row
-
-
-def attach_provider_work_requests(row, provider, objs, default_model=None, events=(), actions=()):
-    return attach_work_requests(row, user_turns_for_provider(provider, objs, default_model), events, actions)
-
-
-def claude_work_actions(msgs):
-    """Tool calls in Claude messages as Work evidence (kinds, edited paths, command kinds)."""
-    actions = []
-    for rec in msgs or ():
-        for block in rec.get("content") or []:
-            if isinstance(block, dict) and block.get("type") == "tool_use":
-                actions.append(_work_evidence.tool_action(block.get("name"), block.get("input"), rec.get("ts") or 0))
-    return actions
-
-
-def codex_work_actions(objs):
-    """Tool calls in a Codex rollout as Work evidence, including tools called from code-mode scripts."""
-    actions = []
-    for obj in objs or ():
-        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-        ptype = payload.get("type")
-        if ptype not in ("function_call", "custom_tool_call", "local_shell_call", "web_search_call"):
-            continue
-        ts = parse_iso(obj.get("timestamp", "")) or 0
-        name = str(payload.get("name") or "")
-        if ptype == "web_search_call":
-            actions.append(_work_evidence.tool_action("web_search", None, ts))
-        elif ptype == "local_shell_call":
-            action = payload.get("action") if isinstance(payload.get("action"), dict) else {}
-            actions.append(_work_evidence.tool_action("shell", {"command": action.get("command")}, ts))
-        elif ptype == "custom_tool_call" and name == "exec":
-            actions.extend(_work_evidence.code_actions(payload.get("input"), ts))
-        elif ptype == "function_call" and name == "js":
-            arguments = payload.get("arguments")
-            try:
-                code = json.loads(arguments).get("code") if isinstance(arguments, str) else None
-            except (ValueError, AttributeError):
-                code = None
-            actions.extend(_work_evidence.code_actions(code or arguments, ts))
-        else:
-            actions.append(_work_evidence.tool_action(name, payload.get("arguments") or payload.get("input"), ts))
-    return actions
-
-
-def pi_work_actions(turns):
-    """Tool calls in a Pi session as Work evidence, kept content-free.
-
-    Pi's adapter keeps only a normalized tool name and kind, never the call's
-    arguments, so each action carries the kind and its turn's timestamp and no
-    edited paths or command kinds.
-    """
-    actions = []
-    for turn in turns or ():
-        ts = float(turn.get("end") or turn.get("start") or 0)
-        for tool in turn.get("tools") or ():
-            actions.append(_work_evidence.tool_action(tool.get("name"), None, ts))
-    return actions
-
-
-def user_prompt_preview(texts, limit=220):
-    seen = set()
-    unique = []
-    for text in texts:
-        key = " ".join((text or "").split())
-        if not key or key in seen:
-            continue
-        seen.add(key)
-        unique.append(text)
-    return compact_text(" / ".join(unique), limit)
-
-
-def execution_low_yield(execution):
-    return _domain_execution_low_yield(execution)
-
-
-def low_yield_should_warn(executions, context_pct=0):
-    return _domain_low_yield_should_warn(executions, context_pct)
-
-
-def is_operational_warning(insight):
-    return _domain_is_operational_warning(insight)
-
-
-INSIGHT_CATEGORY_ORDER = {
-    "Context": 0,
-    "Yield": 1,
-    "Spend": 2,
-    "Tools": 3,
-    "Cache": 4,
-    "Reasoning": 5,
-    "Flow": 6,
-    "Pricing": 7,
-}
-INSIGHT_KIND_SCORE = {"warn": 0, "good": 1, "neutral": 2}
-
-
-def insight(key, kind, category, title, text, detail="", action="", priority=50):
-    return _domain_insight(key, kind, category, title, text, detail, action, priority)
-
-
-def insight_sort_key(row):
-    return _domain_insight_sort_key(row)
-
-
-def normalize_insights(rows, limit=12):
-    return _domain_normalize_insights(rows, limit)
-
-
-def claude_user_events(objs):
-    events = []
-    for obj in objs:
-        if obj.get("type") != "user":
-            continue
-        msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-        txt = compact_text(claude_user_text(msg), 220)
-        if txt:
-            events.append({"ts": parse_iso(obj.get("timestamp", "")) or 0, "text": txt})
-    return sorted(events, key=lambda e: e["ts"])
-
-
-def tool_summary(executions):
-    return _domain_tool_summary(executions)
-
-
-def iter_claude_messages(objs):
-    return list(_claude_native_adapter().logical_messages(
-        objs, timestamp_parser=parse_iso,
-    ))
-
-
-def tool_result_is_error(value, explicit=False):
-    if explicit:
-        return True
-    if isinstance(value, dict):
-        if value.get("is_error") is True or value.get("success") is False:
-            return True
-        status = str(value.get("status") or "").lower()
-        if status in ("error", "failed", "failure"):
-            return True
-        exit_code = value.get("exit_code", value.get("exitCode"))
-        if exit_code not in (None, 0, "0"):
-            return True
-        if value.get("error") not in (None, "", False):
-            return True
-        return any(tool_result_is_error(v) for v in value.values() if isinstance(v, (dict, list)))
-    if isinstance(value, list):
-        return any(tool_result_is_error(v) for v in value)
-    text = str(value or "").strip().lower()
-    return text.startswith(("error:", "failed:", "tool error", "process exited with code"))
-
-
-def observable_output_chars(value):
-    """Count trace-visible text while excluding embedded image/base64 bytes."""
-    try:
-        text = json.dumps(value, ensure_ascii=False, sort_keys=True)
-    except (TypeError, ValueError):
-        text = str(value or "")
-    text = DATA_URL_RE.sub("<image-data>", text)
-    text = BASE64_FIELD_RE.sub(r'\1<binary-data>\3', text)
-    return len(text)
-
-
-def argument_fingerprint(value):
-    try:
-        text = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
-    except (TypeError, ValueError):
-        text = str(value or "")
-    return hashlib.sha256(text.encode("utf-8", "replace")).hexdigest()[:16] if text else ""
-
-
-_SKILL_MEASURABLE_KEYS = frozenset({
-    "allowed-tools", "tools", "tool-schemas", "mcp-servers", "mcpservers",
-    "mcp", "requires-mcp", "requiresmcp",
-})
-_SKILL_EMPTY_CAPABILITY_VALUES = frozenset({"", "false", "null", "none", "~"})
-
-
-def _skill_frontmatter_key(value):
-    return str(value or "").strip().casefold().replace("_", "-")
-
-
-def _skill_frontmatter(path):
-    try:
-        with open(path, "r", encoding="utf-8") as fh:
-            raw = fh.read(65536)
-    except OSError:
-        return {}
-    lines = raw.splitlines()
-    if not lines or lines[0].lstrip("\ufeff").strip() != "---":
-        return {}
-    closing = next((idx for idx, line in enumerate(lines[1:], 1) if line.strip() == "---"), None)
-    if closing is None:
-        return {}
-    fm = {}
-    current_key = None
-    for raw_line in lines[1:closing]:
-        stripped = raw_line.strip()
-        if not stripped or stripped.startswith("#"):
-            continue
-        if raw_line[:1].isspace():
-            if current_key and fm.get(current_key) == "":
-                fm[current_key] = "<nested-value>"
-            continue
-        m = re.match(r"^([A-Za-z0-9_.@+-]+)\s*:\s*(.*)", raw_line.rstrip())
-        if m:
-            key = m.group(1).strip()
-            val = re.sub(r"\s+#.*$", "", m.group(2)).strip()
-            normalized = val.casefold()
-            if normalized == "true":
-                fm[key] = True
-            elif normalized == "false":
-                fm[key] = False
-            else:
-                fm[key] = val
-            current_key = key
-        else:
-            current_key = None
-    return fm
-
-
-def _skill_capability_value_is_nonempty(value):
-    if value is True:
-        return True
-    if value is False or value is None:
-        return False
-    text = str(value).strip()
-    if len(text) >= 2 and text[0] == text[-1] and text[0] in ("'", '"'):
-        text = text[1:-1].strip()
-    if text.casefold() in _SKILL_EMPTY_CAPABILITY_VALUES:
-        return False
-    if re.fullmatch(r"\[\s*\]|\{\s*\}", text):
-        return False
-    return True
-
-
-def _skill_measurability(path):
-    """Classify whether trace evidence can observe this skill's capabilities."""
-    fm = _skill_frontmatter(path)
-    capability_values = [
-        value for key, value in fm.items()
-        if _skill_frontmatter_key(key) in _SKILL_MEASURABLE_KEYS
-    ]
-    if not capability_values:
-        return "unknown"
-    if any(_skill_capability_value_is_nonempty(value) for value in capability_values):
-        return "measurable"
-    return "instruction"
-
-
-def _skill_has_measurable_capabilities(path):
-    return _skill_measurability(path) == "measurable"
-
-
-def skill_names_from_value(value, tool_name=""):
-    """Infer path-based loads and explicit native Skill-tool activations."""
-    try:
-        text = json.dumps(value, ensure_ascii=False, sort_keys=True)
-    except (TypeError, ValueError):
-        text = str(value or "")
-    names = {
-        match.group(1) for match in SKILL_PATH_RE.finditer(text)
-        if SKILL_NAME_RE.fullmatch(match.group(1))
-    }
-    tool_leaf = str(tool_name or "").rsplit(".", 1)[-1].casefold()
-    direct = value.get("skill") if tool_leaf == "skill" and isinstance(value, dict) else None
-    if isinstance(direct, str):
-        direct = direct.strip()
-        if SKILL_NAME_RE.fullmatch(direct):
-            names.add(direct.rsplit(":", 1)[-1])
-    return sorted(names)
-
-
-def claude_tool_results(objs):
-    chars_by_id = defaultdict(int)
-    ts_by_id = {}
-    errors_by_id = defaultdict(bool)
-    for obj in objs:
-        if obj.get("type") != "user":
-            continue
-        msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
-        content = msg.get("content")
-        if not isinstance(content, list):
-            continue
-        for block in content:
-            if isinstance(block, dict) and block.get("type") == "tool_result":
-                tid = block.get("tool_use_id")
-                chars_by_id[tid] += observable_output_chars(block.get("content", ""))
-                ts_by_id[tid] = parse_iso(obj.get("timestamp", ""))
-                errors_by_id[tid] = errors_by_id[tid] or tool_result_is_error(
-                    block.get("content"), block.get("is_error") is True
-                )
-    return chars_by_id, ts_by_id, errors_by_id
-
-
-def cursor_timestamp(value):
-    if isinstance(value, (int, float)):
-        return float(value) / 1000.0 if float(value) > 10_000_000_000 else float(value)
-    if isinstance(value, str):
-        try:
-            return datetime.datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
-        except (TypeError, ValueError):
-            return float(parse_iso(value) or 0)
-    return 0.0
-
-
-def cursor_message_content(row):
-    message = row.get("message") if isinstance(row, dict) else {}
-    content = message.get("content") if isinstance(message, dict) else []
-    return content if isinstance(content, list) else []
-
-
-def cursor_transcript_groups(rows, source):
-    """Reconstruct coarse turns when Cursor SQLite enrichment is unavailable."""
-    groups = []
-    current = None
-    for row in rows or []:
-        role = row.get("role") if isinstance(row, dict) else None
-        if role == "user":
-            if current:
-                groups.append(current)
-            user_text = text_from_content(cursor_message_content(row))
-            query = re.search(r"<user_query>\s*(.*?)\s*</user_query>", user_text, flags=re.DOTALL)
-            current = {
-                "user_text": query.group(1) if query else user_text,
-                "model": source.get("model") or "unknown", "bubbles": [],
-                "completed": False,
-            }
-            continue
-        if role == "assistant":
-            if current is None:
-                current = {"user_text": "", "model": source.get("model") or "unknown",
-                           "bubbles": [], "completed": False}
-            current["bubbles"].append({"type": 2, "content": cursor_message_content(row)})
-            continue
-        if row.get("type") == "turn_ended" and current:
-            current["completed"] = row.get("status") in (None, "success", "completed")
-            groups.append(current)
-            current = None
-    if current:
-        groups.append(current)
-    return groups
-
-
-def cursor_enriched_groups(snapshot):
-    groups = []
-    current = None
-    for bubble in snapshot.get("bubbles") or []:
-        if bubble.get("type") == 1:
-            if current:
-                groups.append(current)
-            model_info = bubble.get("modelInfo") if isinstance(bubble.get("modelInfo"), dict) else {}
-            current = {
-                "user_text": str(bubble.get("text") or ""),
-                "model": model_info.get("modelName") or
-                         cursor_model(snapshot.get("composer") or {}, snapshot.get("header") or {}),
-                "request_id": bubble.get("requestId") or "",
-                "start_ts": cursor_timestamp(bubble.get("createdAt")),
-                "context": bubble.get("contextWindowStatusAtCreation")
-                           if isinstance(bubble.get("contextWindowStatusAtCreation"), dict) else {},
-                "bubbles": [], "completed": False,
-            }
-            continue
-        if bubble.get("type") != 2:
-            continue
-        if current is None:
-            current = {
-                "user_text": "", "model": cursor_model(
-                    snapshot.get("composer") or {}, snapshot.get("header") or {}
-                ), "request_id": "", "start_ts": 0, "context": {}, "bubbles": [],
-                "completed": False,
-            }
-        current["bubbles"].append(bubble)
-        if bubble.get("turnDurationMs") is not None:
-            current["completed"] = True
-            current["turn_duration_ms"] = bubble.get("turnDurationMs")
-    if current:
-        groups.append(current)
-    return groups
-
-
-CURSOR_SPAN_LEAD_S = 5.0
-
-
-def cursor_turn_timing(spans, start_ts, next_start_ts=0, terminal_ts=0, turn_duration_ms=0,
-                       request_id="", claimed_request_ids=frozenset()):
-    # Spans carrying a known turn requestId belong to that turn. Others are
-    # attributed by start: Cursor opens spans a few seconds before the user
-    # bubble's createdAt, and a turn's spans can outlive the next queued turn.
-    lower = float(start_ts or 0) - CURSOR_SPAN_LEAD_S
-    if next_start_ts:
-        upper = max(lower, float(next_start_ts) - CURSOR_SPAN_LEAD_S)
-    else:
-        upper = float((terminal_ts + 24 * 60 * 60) if terminal_ts else float("inf"))
-
-    def owned(row):
-        row_request = row.get("request_id") or ""
-        if row_request and row_request in claimed_request_ids:
-            return row_request == request_id
-        return lower <= row.get("start_ts", 0) < upper
-
-    matches = [row for row in spans or [] if owned(row)]
-    submits = [row for row in matches if row.get("name") == "ComposerChatService.submitChatMaybeAbortCurrent"]
-    attempts = [row for row in matches if row.get("name") == "agent.request.attempt"]
-    rpc_errors = {
-        row.get("request_id") for row in matches
-        if row.get("name") == "rpc.run" and row.get("error") and row.get("request_id")
-    }
-    ttfts = [row for row in matches if row.get("name") == "client.ttft" and row.get("duration_s", 0) > 0]
-    final_ts = max((row["end_ts"] for row in submits + attempts), default=float(terminal_ts or 0))
-    intervals = [(row["start_ts"], row["end_ts"]) for row in attempts]
-    try:
-        fallback_s = max(0.0, float(turn_duration_ms or 0) / 1000.0)
-    except (TypeError, ValueError):
-        fallback_s = 0.0
-    if not intervals and fallback_s and terminal_ts:
-        intervals = [(max(0.0, float(terminal_ts) - fallback_s), float(terminal_ts))]
-    active_s = _merge_execution_intervals(intervals)
-    if final_ts and start_ts and final_ts >= start_ts:
-        wait_s = final_ts - start_ts
-    else:
-        wait_s = fallback_s
-        final_ts = float(terminal_ts or (start_ts + fallback_s if start_ts else 0))
-    failed = sum(bool(row.get("error") or row.get("request_id") in rpc_errors) for row in attempts)
-    return {
-        "end_ts": final_ts,
-        "wait_s": max(0.0, wait_s),
-        "active_s": max(0.0, active_s),
-        "active_intervals": intervals,
-        "timing_basis": "request_trace" if (submits or attempts) else
-                        ("turn_duration" if fallback_s else "unavailable"),
-        "ttft_s": min((row["duration_s"] for row in ttfts), default=0.0),
-        "attempts": len(attempts),
-        "failed_attempts": failed,
-        "retries": max(0, len(attempts) - 1),
-    }
-
-
-def cursor_prompt_breakdown(composer):
-    raw = composer.get("promptTokenBreakdown") if isinstance(composer, dict) else {}
-    categories = raw.get("categories") if isinstance(raw, dict) else []
-    return [
-        {
-            "id": str(row.get("id") or "unknown"),
-            "label": str(row.get("label") or row.get("id") or "Unknown"),
-            "estimated_tokens": int(row.get("estimatedTokens") or 0),
-        }
-        for row in (categories or []) if isinstance(row, dict)
-    ]
-
-
-def cursor_context_estimates(groups, latest_tokens=0, latest_window=0):
-    """Fill sparse Cursor context checkpoints without calling them billable input."""
-    rows = []
-    for group in groups or []:
-        context = group.get("context") if isinstance(group.get("context"), dict) else {}
-        rows.append({
-            "tokens": max(0, int(context.get("tokensUsed") or 0)),
-            "window": max(0, int(context.get("tokenLimit") or 0)),
-            "interpolated": False,
-        })
-    if not rows:
-        return rows
-    if latest_tokens:
-        rows[-1]["tokens"] = max(0, int(latest_tokens))
-    if latest_window:
-        rows[-1]["window"] = max(0, int(latest_window))
-
-    known_tokens = [index for index, row in enumerate(rows) if row["tokens"] > 0]
-    for index, row in enumerate(rows):
-        if row["tokens"] > 0:
-            continue
-        previous = max((known for known in known_tokens if known < index), default=None)
-        following = min((known for known in known_tokens if known > index), default=None)
-        if following is not None and previous is not None:
-            span = following - previous
-            share = (index - previous) / span
-            start = rows[previous]["tokens"]
-            row["tokens"] = max(1, round(start + (rows[following]["tokens"] - start) * share))
-        elif following is not None:
-            row["tokens"] = max(1, round(rows[following]["tokens"] * (index + 1) / (following + 1)))
-        elif previous is not None:
-            row["tokens"] = rows[previous]["tokens"]
-        row["interpolated"] = bool(row["tokens"])
-
-    known_windows = [index for index, row in enumerate(rows) if row["window"] > 0]
-    for index, row in enumerate(rows):
-        if row["window"] > 0:
-            continue
-        nearest = min(known_windows, key=lambda known: abs(known - index)) if known_windows else None
-        if nearest is not None:
-            row["window"] = rows[nearest]["window"]
-    return rows
-
-
-def cursor_visible_output(bubbles):
-    """Estimate only model-authored text that Cursor persisted in its bubbles."""
-    assistant_chars = 0
-    reasoning_chars = 0
-    for bubble in bubbles or []:
-        if not isinstance(bubble, dict):
-            continue
-        seen = set()
-        text = bubble.get("text")
-        if isinstance(text, str) and text.strip():
-            seen.add(text)
-            assistant_chars += len(text)
-        for block in bubble.get("content") or []:
-            if not isinstance(block, dict) or block.get("type") != "text":
-                continue
-            value = block.get("text")
-            if isinstance(value, str) and value.strip() and value not in seen:
-                seen.add(value)
-                assistant_chars += len(value)
-        thinking = bubble.get("thinking")
-        if isinstance(thinking, str) and thinking.strip() and thinking not in seen:
-            reasoning_chars += len(thinking)
-    return {
-        "assistant_chars": assistant_chars,
-        "reasoning_chars": reasoning_chars,
-        "assistant_tokens": math.ceil(assistant_chars / CHARS_PER_TOKEN) if assistant_chars else 0,
-        "reasoning_tokens": math.ceil(reasoning_chars / CHARS_PER_TOKEN) if reasoning_chars else 0,
-    }
-
-
-def cursor_model_call_count(bubbles):
-    call_ids = set()
-    has_model_activity = False
-    for bubble in bubbles or []:
-        if not isinstance(bubble, dict):
-            continue
-        tool_data = bubble.get("toolFormerData")
-        if isinstance(tool_data, dict):
-            call_id = tool_data.get("modelCallId")
-            if call_id:
-                call_ids.add(str(call_id))
-            has_model_activity = has_model_activity or bool(tool_data.get("name"))
-        has_model_activity = has_model_activity or bool(str(bubble.get("text") or "").strip())
-        has_model_activity = has_model_activity or any(
-            isinstance(block, dict) and block.get("type") in ("text", "tool_use")
-            for block in (bubble.get("content") or [])
-        )
-    return max(len(call_ids), int(has_model_activity))
-
-
-def cursor_pricing_note(model, variant, supported):
-    basis = "one context snapshot per execution plus trace-visible model text"
-    if not supported:
-        return f"Local Cursor token estimate ({basis}); no configured public rate for {model}."
-    rate = "selected-model public API rates"
-    if variant == "max":
-        rate += " plus Cursor's 20% Max Mode markup"
-    elif variant == "max-fast":
-        rate = "selected-model public fast-mode API rates plus Cursor's 20% Max Mode markup"
-    for cursor_model_id in CURSOR_VARIANT_MODEL_IDS:
-        if _catalog_model_alias_matches(model, "cursor", cursor_model_id):
-            rate = (f"{cursor_model_id.replace('-', ' ').title()} "
-                    f"{variant.replace('-', ' ').title()} public rates")
-            break
-    return f"Local Cursor estimate ({basis}), priced with {rate}; cache and hidden model work are excluded."
+    return bool(work_insights_settings()["enabled"])
 
 
-def recompute_cursor(source):
-    return _cursor_native_adapter().recompute_legacy(source)
+def attach_work_requests(row, turns, events=(), actions=()):
+    """Give each typed request its share of cost and what the agent did next, for Work insights.
 
+    ``events`` are (ts, cost, model, effort) per priced assistant event; ``actions`` come from
+    ``_work_evidence.tool_action``. The row keeps only content-free slices; the action summary,
+    which may name edited files, rides with the request text to the in-memory classifier queue.
+    """
+    turns = list(turns or ())
+    slices = None
+    if work_insights_settings()["enabled"]:
+        slices, edited = _work_evidence.request_slices([turn.get("ts") for turn in turns], events, actions)
+        for turn, slice_, paths in zip(turns, slices or (), edited or ()):
+            turn["cost"] = slice_["cost"]
+            turn["evidence"] = _work_evidence.evidence_text(slice_, paths)
+    row["_work_requests"] = slices or []
+    row["_work_turn_days"] = capture_work_turns(turns)
+    return row
 
-def _opencode_int(value, default=0):
-    return _native_opencode_int(value, default)
 
+def attach_provider_work_requests(row, provider, objs, default_model=None, events=(), actions=()):
+    return attach_work_requests(row, user_turns_for_provider(provider, objs, default_model), events, actions)
 
-def _opencode_usage(data):
-    """Return OpenCode's five independent token components."""
-    return _native_opencode_usage(data)
 
+def claude_work_actions(msgs):
+    """Tool calls in Claude messages as Work evidence (kinds, edited paths, command kinds)."""
+    actions = []
+    for rec in msgs or ():
+        for block in rec.get("content") or []:
+            if isinstance(block, dict) and block.get("type") == "tool_use":
+                actions.append(_work_evidence.tool_action(block.get("name"), block.get("input"), rec.get("ts") or 0))
+    return actions
 
-def _opencode_context_tokens(usage):
-    return _native_opencode_context_tokens(usage)
 
+def iter_claude_messages(objs):
+    return list(_claude_native_adapter().logical_messages(
+        objs, timestamp_parser=parse_iso,
+    ))
 
-def _opencode_reported_cost(data):
-    """Return (cost, available); a reported numeric zero remains available."""
-    return _native_opencode_reported_cost(data)
 
+def _skill_measurability(path):
+    """Classify whether trace evidence can observe this skill's capabilities."""
+    fm = _skill_frontmatter(path)
+    capability_values = [
+        value for key, value in fm.items()
+        if _skill_frontmatter_key(key) in _SKILL_MEASURABLE_KEYS
+    ]
+    if not capability_values:
+        return "unknown"
+    if any(_skill_capability_value_is_nonempty(value) for value in capability_values):
+        return "measurable"
+    return "instruction"
 
-# OpenCode records an authoritative total cost per message from its own
-# provider. No public rate table can cover arbitrary OpenCode backends, so
-# Token Meter distributes that exact total across the input / cache-write /
-# cache-read / output buckets using a documented token-weighted proxy that
-# preserves the authoritative total. The proxy does not invent cost.
-def _opencode_distribute(msg_cost, usage):
-    """Split one authoritative OpenCode-reported cost into five proxy buckets.
 
-    OpenCode records an authoritative total cost per message from its own
-    provider. No bundled rate table can cover arbitrary OpenCode backends, so
-    Token Meter distributes that exact total across the five independent token
-    components with a documented token-weighted proxy. The total is never
-    invented; only its category split is estimated.
-    """
-    return _native_opencode_distribute(msg_cost, usage)
+def _skill_has_measurable_capabilities(path):
+    return _skill_measurability(path) == "measurable"
 
 
-def _opencode_display_cost(breakdown):
-    """Fold reasoning into output for Token Meter's four-bucket UI contract."""
-    return _native_opencode_display_cost(breakdown)
+def recompute_cursor(source):
+    return _cursor_native_adapter().recompute_legacy(source)
 
 
 def recompute_opencode(source):
@@ -6840,7 +4637,6 @@ def recompute(source):
     return result.value
 
 
-
 def source_revision_signature(source):
     """Track trace activity plus display metadata stored outside the trace."""
     if not source:
@@ -6997,12 +4793,6 @@ def flush_mcp_evidence_cache():
     return _mcp_evidence_cache.flush()
 
 
-def enable_mcp_parallel_index():
-    """Let the MCP fill cold summaries and stat rows on the load-aware worker pool."""
-    global _parallel_index_enabled
-    _parallel_index_enabled = True
-
-
 def _index_stat_rows_worker(source):
     """Return one session's content-free stat rows, or None so the caller parses in-process."""
     _follow_index_pressure()
@@ -7116,51 +4906,6 @@ def recompute_claude(source):
     return _claude_native_adapter().recompute_legacy(source)
 
 
-def analysis_block(tot, total_cost, think_out, think_turns, think_cost, model_tok, model_cost,
-                   tool_data, side_cost, side_turns, completed):
-    tool_bloat = [{
-        "name": row["name"],
-        "calls": row["calls"],
-        "tokens": row["output_tokens"],
-        "chars": row["output_chars"],
-        "namespace": row["namespace"],
-        "kind": row["kind"],
-    } for row in tool_data["by_name"][:8]]
-    return {
-        "reasoning": {
-            "share": (think_out / tot["output"]) if tot["output"] else 0.0,
-            "think_turns": think_turns,
-            "tokens": think_out,
-            "cost": think_cost,
-        },
-        "model_mix": sorted(
-            [{"model": k, "tokens": model_tok[k], "cost": model_cost[k]} for k in model_tok],
-            key=lambda x: -x["cost"]),
-        "tool_bloat": tool_bloat,
-        "coordination": {
-            "share": (side_cost / total_cost) if total_cost else 0.0,
-            "turns": side_turns,
-            "cost": side_cost,
-        },
-        "cost_per_task": {
-            "completed": completed,
-            "per_task": (total_cost / completed) if completed else 0.0,
-        },
-    }
-
-
-def new_codex_pending():
-    return {"trace": [], "calls": {}, "has_reasoning": False, "start_ts": None,
-            "context_window": None, "user_inputs": [], "fallback_user_inputs": []}
-
-
-def codex_approval_policy_label(value):
-    """Return a compact label for legacy strings and structured Codex policies."""
-    if isinstance(value, dict):
-        value = next(iter(value), "")
-    return str(value or "").replace("_", " ")
-
-
 def recompute_codex(source):
     return _codex_native_adapter().recompute_legacy(source)
 
@@ -7353,19 +5098,6 @@ def build_state(source, tot, cost, total_tokens, total_cost, series, executions,
     }
 
 
-def enrich_insights(insights, executions, tool_data, context_window, context_latest,
-                    context_peak, provider):
-    return _domain_enrich_insights(
-        insights,
-        executions,
-        tool_data,
-        context_window,
-        context_latest,
-        context_peak,
-        provider,
-    )
-
-
 def cache_savings(tot, provider, model, executions=None, model_provider=None,
                   channel=None, at=None):
     if executions:
@@ -7505,10 +5237,6 @@ def build_insights(tot, cost, total_cost, cache_ratio, biggest, n_turns, an,
     )
 
 
-def summarize_tool_evidence(calls, catalog=None):
-    return _domain_summarize_tool_evidence(calls, catalog)
-
-
 def claude_tool_call_evidence(objs, msgs=None):
     msgs = msgs if msgs is not None else iter_claude_messages(objs)
     result_chars, result_ts, result_errors = claude_tool_results(objs)
@@ -7591,18 +5319,6 @@ def codex_summary(source, objs):
     return _codex_native_adapter().summarize_legacy(source, objs)
 
 
-def _cache_pricing_provider(facts):
-    provider = facts.get("pricing_provider")
-    if provider in ("claude", "codex", "cursor"):
-        return provider
-    model = str(facts.get("model") or "").lower()
-    if "claude" in model:
-        return "claude"
-    if re.match(r"(?:openai/)?(?:gpt-(?!oss)|o\d)", model):
-        return "codex"
-    return None
-
-
 def cache_cold_cost_delta(facts, window_s):
     """Estimate the extra cost of re-sending the latest prefix after expiry."""
     prefix = int(facts.get("prefix_tokens") or 0)
@@ -7812,12 +5528,6 @@ def agy_summary(source, objs=None):
     return _agy_native_adapter().summarize_legacy(source, objs)
 
 
-def _is_child_agent_row(row):
-    """A row is a child run only when every agent record names a parent."""
-    records = [r for r in row.get("_agent_records") or () if isinstance(r, dict)]
-    return bool(records) and all(r.get("parent_id") for r in records)
-
-
 def session_summary(source, opencode_conn=None):
     signature = summary_cache_signature(source)
     with _summary_cache_lock:
@@ -7864,9 +5574,6 @@ def _store_session_summary(source, signature, row, work_turns=None):
     return row
 
 
-_index_worker_pressure = {"event": None, "yielding": False}
-
-
 def _index_worker_runtime_state():
     """Collect adapter warm-start state (discovery metadata, never trace content)."""
     registry = runtime_registry()
@@ -7952,13 +5659,6 @@ def _index_summary_worker(source):
     return row
 
 
-def _system_load_average():
-    try:
-        return os.getloadavg()[0]
-    except (AttributeError, OSError):
-        return None
-
-
 def _usable_cpu_count():
     """CPUs this process may run on (respects Linux cpusets and pinning)."""
     try:
@@ -7974,13 +5674,6 @@ def _physical_memory_bytes():
         return None
 
 
-def _source_size(source):
-    try:
-        return os.path.getsize(source.get("path") or "")
-    except (OSError, TypeError, ValueError):
-        return 0
-
-
 def _index_executor(max_workers, pressure_event=None):
     if not _index_process_pool_supported(sys.version_info):
         raise NotImplementedError("this Python requires sequential indexing")
@@ -8044,7 +5737,6 @@ def on_result(job, row):
         return stored[0]
 
 
-_shared_index_pool = {"owner": None, "pools": {}}
 _shared_index_pool_lock = threading.Lock()
 
 
@@ -8157,52 +5849,6 @@ def selected_session_stats(source):
     }
 
 
-def current_session_summaries(rows, now=None, max_age_s=CURRENT_SESSION_MAX_AGE_S,
-                              limit=CURRENT_SESSION_LIMIT):
-    return _domain_current_session_summaries(
-        rows,
-        now=now,
-        max_age_s=max_age_s,
-        limit=limit,
-        working_age_s=CURRENT_SESSION_WORKING_S,
-        context_sample_limit=CURRENT_SESSION_CONTEXT_SAMPLES,
-    )
-
-
-def folded_child_root_id(source):
-    """Return the root session id an additive child source folds into, if any.
-
-    Only OpenCode child sessions with a resolved root carry `agent_root_id`;
-    every other source returns an empty string and keeps its own identity.
-    """
-    if not isinstance(source, dict) or source.get("provider") != "opencode":
-        return ""
-    return str(source.get("agent_root_id") or "")
-
-
-def fold_child_source(selected, sources):
-    """Map a folded child source to its discovered root source, else keep it."""
-    root_id = folded_child_root_id(selected)
-    if not root_id:
-        return selected
-    for source in sources or ():
-        if (
-            source.get("provider") == selected.get("provider")
-            and str(source.get("id") or "") == root_id
-        ):
-            return source
-    return selected
-
-
-def newest_current_source(sources):
-    """Pick the live source, keeping a child run under its root session."""
-    rows = list(sources or ())
-    if not rows:
-        return None
-    newest = max(rows, key=lambda source: source.get("mtime") or 0)
-    return fold_child_source(newest, rows)
-
-
 def session_budget_family(session_id, rows=None, root_id=None):
     """Return the budget owner id, root row, and child rows for one session.
 
@@ -8258,19 +5904,9 @@ def codex_mcp_states():
     return {name: bool(row.get("enabled")) for name, row in toml_named_sections(CODEX_CONFIG, "mcp_servers").items()}
 
 
-_CONFIGURED_CAPABILITY_TTL_S = 60.0
-_configured_capability_cache = {}
 _configured_capability_cache_lock = threading.Lock()
 
 
-def _skill_dir_names(*roots):
-    names = set()
-    for root in roots:
-        for path in glob.glob(os.path.join(root, "*", "SKILL.md")):
-            names.add(os.path.basename(os.path.dirname(path)))
-    return names
-
-
 def _json_mcp_server_names(*paths):
     names = set()
     for path in paths:
@@ -8363,13 +5999,6 @@ def claude_plugin_installations():
     return result
 
 
-def skill_identity(runtime, name, origin_id, plugin_id=""):
-    """Return a stable identity that cannot collide across runtimes or origins."""
-    runtime_key = re.sub(r"[^a-z0-9]+", "-", str(runtime or "unknown").lower()).strip("-") or "unknown"
-    owner = str(plugin_id or origin_id or "unknown").strip()
-    return f"skill:{runtime_key}:{owner}:{name}"
-
-
 def claude_project_skill_roots():
     """Return bounded absolute project roots of Claude Code sessions."""
     sources = [
@@ -8549,22 +6178,6 @@ def _observed_claude_skill_rows(skill_usage, inventory_rows):
     return observed
 
 
-def capability_control_groups(mcp_items, skill_items):
-    return _domain_capability_control_groups(mcp_items, skill_items)
-
-
-def optional_capability_summary(control_groups):
-    return _domain_optional_capability_summary(control_groups)
-
-
-def capability_content_revision(*parts):
-    """Return a stable revision for JSON-safe capability evidence."""
-    encoded = json.dumps(
-        parts, ensure_ascii=True, sort_keys=True, separators=(",", ":"),
-    ).encode("utf-8")
-    return hashlib.sha256(encoded).hexdigest()[:20]
-
-
 def capability_inventory(waste=None):
     waste = waste or {}
     tool_evidence = waste.get("inventory_tools") or waste.get("by_name") or []
@@ -8748,32 +6361,6 @@ def mcp_key(name):
     }
 
 
-def capability_summary_payload(capabilities):
-    """Return decision evidence without the heavy inventory rows."""
-    capabilities = capabilities or {}
-    payload = {key: value for key, value in capabilities.items() if key != "items"}
-    payload["inventory_count"] = len(capabilities.get("items") or [])
-    if isinstance(payload.get("claude_desktop"), dict):
-        payload["claude_desktop"] = {
-            key: value for key, value in payload["claude_desktop"].items() if key != "roots"
-        }
-    return payload
-
-
-@functools.lru_cache(maxsize=16384)
-def _trace_path_key(path):
-    return _compare_trace_key({"path": path})
-
-
-def _browser_session_row(row):
-    """Swap a trace path for the opaque compare key the dashboard selects by."""
-    if not isinstance(row, dict) or not row.get("path"):
-        return row
-    public = {key: value for key, value in row.items() if key != "path"}
-    public["key"] = _trace_path_key(str(row["path"]))
-    return public
-
-
 def dashboard_state_payload(state):
     """Bound browser polling to data used by dashboard surfaces."""
     if not isinstance(state, dict):
@@ -8823,15 +6410,7 @@ def _dashboard_public_cross(cross):
     return public_cross
 
 
-# Cross-session snapshots are replaced wholesale, never mutated, so one
-# encoding per snapshot object serves every poll until the next rebuild.
-# /state serves the published snapshot and /session the latest rebuild; they
-# differ while idle, so both stay encoded. The nonce keeps a page that
-# outlived a server restart from matching a fresh revision.
-_dashboard_cross_cache = {"serial": 0, "entries": []}
 _dashboard_cross_lock = threading.Lock()
-_dashboard_cross_nonce = os.urandom(4).hex()
-_DASHBOARD_CROSS_SLOTS = 2
 
 
 def _dashboard_cross_encoded(cross):
@@ -8963,13 +6542,6 @@ def attach_cross_session(state, cross=None):
     return state
 
 
-def capability_action_capability():
-    return {
-        "token": _ACTION_TOKEN,
-        "skill_pack_toggle": True,
-    }
-
-
 def session_action_capability():
     trash_plan = _PLATFORM_SERVICES.trash_plan("")
     return {
@@ -9078,33 +6650,6 @@ def agent_access_command(client, enabled, launcher=None, cli_path=None):
     raise ValueError("Unsupported agent client.")
 
 
-def agent_access_command_display(command):
-    command = list(command or [])
-    if command:
-        command[0] = os.path.basename(command[0])
-    return shlex.join(command)
-
-
-def agent_cli_error_detail(completed):
-    raw = str(getattr(completed, "stderr", "") or getattr(completed, "stdout", "") or "")
-    lines = [line.strip() for line in raw.splitlines() if line.strip()]
-    if not lines:
-        return ""
-    return compact_text(lines[-1].replace(os.path.expanduser("~"), "~"), 220)
-
-
-def _agent_access_matches(command, args, env, launcher, runtime):
-    try:
-        command_match = os.path.realpath(os.path.expanduser(str(command or ""))) == os.path.realpath(launcher)
-    except OSError:
-        command_match = False
-    return bool(command_match and list(args or []) == [] and str((env or {}).get("TOKEN_METER_CALLER") or "") == runtime)
-
-
-_ABSENT = object()
-CLAUDE_DESKTOP_CLIENT = "claude_desktop"
-CLAUDE_CODE_CLIENT = "claude_code"
-AGENT_ACCESS_CLIENTS = ("codex", "claude")
 _AGENT_ACCESS_PARTS = ("codex", CLAUDE_CODE_CLIENT, CLAUDE_DESKTOP_CLIENT)
 
 
@@ -9122,36 +6667,6 @@ def claude_app_running(runner=None):
     return completed.returncode == 0
 
 
-def claude_desktop_access_entry(launcher):
-    env = {"TOKEN_METER_CALLER": "claude"}
-    # Electron's spawn refuses .cmd/.bat without a shell, so Windows launchers go through cmd.exe.
-    if str(launcher).lower().endswith((".cmd", ".bat")):
-        return {"command": "cmd.exe", "args": ["/c", launcher], "env": env}
-    return {"command": launcher, "args": [], "env": env}
-
-
-def _same_path(left, right):
-    try:
-        resolve = lambda value: os.path.normcase(os.path.realpath(os.path.expanduser(str(value or ""))))
-        return resolve(left) == resolve(right)
-    except (OSError, ValueError):
-        return False
-
-
-def _claude_desktop_entry_matches(row, launcher):
-    if not isinstance(row, dict):
-        return False
-    env = row.get("env")
-    args = row.get("args", [])
-    if not isinstance(env, dict) or str(env.get("TOKEN_METER_CALLER") or "") != "claude" or not isinstance(args, list):
-        return False
-    expected = claude_desktop_access_entry(launcher)
-    if expected["command"] == "cmd.exe":
-        return (os.path.basename(str(row.get("command") or "")).lower() in ("cmd", "cmd.exe")
-                and len(args) == 2 and str(args[0]).lower() == "/c" and _same_path(args[1], launcher))
-    return _same_path(row.get("command"), launcher) and args == []
-
-
 def _claude_desktop_config_paths(config_paths=None):
     paths = CLAUDE_DESKTOP_CONFIGS if config_paths is None else config_paths
     return [path for path in paths if os.path.isdir(os.path.dirname(path))]
@@ -9209,14 +6724,6 @@ def claude_desktop_access_status(launcher, config_paths=None, app_running=None):
     }
 
 
-def _config_stamp(path):
-    try:
-        stat = os.stat(path)
-    except FileNotFoundError:
-        return None
-    return stat.st_mtime_ns, stat.st_size
-
-
 def write_claude_desktop_access(enabled, launcher, config_paths=None):
     """Change only mcpServers.tokenmeter in every Claude app config; read all before writing any."""
     planned = []
@@ -9323,18 +6830,6 @@ def agent_access_client_status(client, launcher=None, runner=None, which=None, c
     }
 
 
-CLAUDE_APP_RUNNING_ERROR = "Quit the Claude app first. It rewrites its config while open and would drop the change."
-CLAUDE_APP_UNREADABLE_ERROR = "Token Meter could not read the Claude app's MCP config, so it left the file unchanged."
-
-
-def _claude_part_todo(part, enabled):
-    return bool(part.get("detected") and ((not part.get("connected")) if enabled else part.get("configured")))
-
-
-def _claude_app_stuck(app):
-    return bool(app.get("unreadable") or app.get("app_running"))
-
-
 def combined_claude_access_status(code, app):
     """One Claude row: the claude CLI config and every Claude app config, connected together."""
     parts = [part for part in (code, app) if part.get("detected")]
@@ -9414,14 +6909,6 @@ def agent_access_status(**kwargs):
 }
 
 
-AGENT_SKILL_LABELS = {"codex": "Codex", "claude": "Claude Code"}
-
-
-def _agent_skill_part(client):
-    client = str(client or "").strip().lower()
-    return {"codex": "codex", "claude": CLAUDE_CODE_CLIENT}.get(client)
-
-
 def agent_skills_status(client, roots=None, source_root=None, which=None):
     """Skill-package state for one client; the Claude app has no file-based skills."""
     part = _agent_skill_part(client)
@@ -9591,159 +7078,6 @@ def _set_agent_access_part(client, enabled, repair, runner, status_getter):
                                          "Start a new agent session.")
 
 
-def _verified_agent_access_change(client, enabled, repairing, status_getter, restart_hint):
-    after = status_getter(client)
-    verified = bool(after.get("connected")) if enabled else not bool(after.get("configured"))
-    if not verified:
-        return {"ok": False, "error": "The connection command completed, but the saved configuration could not be verified."}
-    label = after.get("label") or client
-    return {
-        "ok": True, "changed": True, "repaired": repairing, "client": after,
-        "restart_required": True,
-        "message": (f"{label} connection repaired. {restart_hint}"
-                    if repairing else
-                    f"{label} {'connected' if enabled else 'disconnected'}. {restart_hint}"),
-    }
-
-
-def _toml_line_structure(line, state="normal", array_depth=0):
-    """Track TOML string state so root-table scanning never enters a literal."""
-    index = 0
-    while index < len(line):
-        char = line[index]
-        if state == "triple-basic":
-            if line.startswith('\"\"\"', index):
-                state, index = "normal", index + 3
-            else:
-                index += 1
-        elif state == "triple-literal":
-            if line.startswith("'''", index):
-                state, index = "normal", index + 3
-            else:
-                index += 1
-        elif state == "basic":
-            if char == "\\":
-                index += 2
-            elif char == '"':
-                state, index = "normal", index + 1
-            else:
-                index += 1
-        elif state == "literal":
-            if char == "'":
-                state = "normal"
-            index += 1
-        else:
-            if char == "#":
-                break
-            if line.startswith('\"\"\"', index):
-                state, index = "triple-basic", index + 3
-            elif line.startswith("'''", index):
-                state, index = "triple-literal", index + 3
-            elif char == '"':
-                state, index = "basic", index + 1
-            elif char == "'":
-                state, index = "literal", index + 1
-            elif char == "[":
-                array_depth, index = array_depth + 1, index + 1
-            elif char == "]":
-                array_depth, index = max(0, array_depth - 1), index + 1
-            else:
-                index += 1
-    return state, array_depth
-
-
-def _toml_line_state(line, state="normal"):
-    return _toml_line_structure(line, state)[0]
-
-
-def _toml_is_table_header(line, state, array_depth):
-    if state != "normal" or array_depth:
-        return False
-    return bool(re.match(r"^[ \t]*(?:\[\[.*\]\]|\[.*\])[ \t]*(?:#.*)?(?:\r?\n)?$", line))
-
-
-def _toml_root_prefix(text):
-    offset, state, array_depth = 0, "normal", 0
-    for line in text.splitlines(keepends=True):
-        if _toml_is_table_header(line, state, array_depth):
-            return text[:offset], text[offset:]
-        state, array_depth = _toml_line_structure(line, state, array_depth)
-        offset += len(line)
-    return text, ""
-
-
-def _toml_comment_index(value):
-    index, state = 0, "normal"
-    while index < len(value):
-        char = value[index]
-        if state == "basic":
-            if char == "\\":
-                index += 2
-                continue
-            if char == '"':
-                state = "normal"
-        elif state == "literal":
-            if char == "'":
-                state = "normal"
-        elif char == "#":
-            return index
-        elif char == '"':
-            state = "basic"
-        elif char == "'":
-            state = "literal"
-        index += 1
-    return len(value)
-
-
-def _toml_root_assignment(prefix, key):
-    pattern = re.compile(rf"^(?P<before>[ \t]*(?:{re.escape(key)}|\"{re.escape(key)}\")[ \t]*=[ \t]*)(?P<after>.*)$")
-    offset, state = 0, "normal"
-    for line in prefix.splitlines(keepends=True):
-        line_body = line.rstrip("\r\n")
-        line_end = line[len(line_body):]
-        match = pattern.match(line_body) if state == "normal" else None
-        if match:
-            after = match.group("after")
-            comment_at = _toml_comment_index(after)
-            value = after[:comment_at].rstrip()
-            suffix = after[len(value):] + line_end
-            return {
-                "start": offset,
-                "end": offset + len(line),
-                "before": match.group("before"),
-                "value": value,
-                "suffix": suffix,
-            }
-        state = _toml_line_state(line, state)
-        offset += len(line)
-    return None
-
-
-def _toml_root_scalar(text, key):
-    prefix, _ = _toml_root_prefix(text)
-    assignment = _toml_root_assignment(prefix, key)
-    if not assignment:
-        return None
-    value = assignment["value"]
-    if value.startswith(('\"\"\"', "'''")):
-        return None
-    if len(value) >= 2 and value[0] == '"' and value[-1] == '"':
-        try:
-            return json.loads(value)
-        except json.JSONDecodeError:
-            return None
-    if len(value) >= 2 and value[0] == "'" and value[-1] == "'":
-        return value[1:-1]
-    try:
-        return int(value)
-    except ValueError:
-        return None
-
-
-def _toml_root_scalar_text(value):
-    return str(int(value)) if isinstance(value, int) else json.dumps(value, ensure_ascii=False)
-
-
 def _set_toml_root_scalar(text, key, value):
     prefix, suffix = _toml_root_prefix(text)
     assignment = _toml_root_assignment(prefix, key)
@@ -9901,27 +7235,6 @@ def refresh_capability_state():
     return cross.get("capabilities") or {}
 
 
-def daily_summaries(session_rows, limit=30):
-    return _domain_daily_summaries(
-        session_rows, limit=limit, availability_resolver=metric_availability,
-    )
-
-
-def spend_projection(daily_rows):
-    return _domain_spend_projection(daily_rows)
-
-
-def spend_log_summaries(session_rows, start_day, end_day):
-    return _domain_spend_log_summaries(
-        session_rows, start_day, end_day,
-        availability_resolver=metric_availability,
-    )
-
-
-def monthly_summaries(session_rows, limit=12):
-    return _domain_monthly_summaries(session_rows, limit=limit)
-
-
 def monthly_budget_status(months, settings=None, now=None):
     """Combine the current calendar-month rollup with configured budget targets."""
     settings = normalize_budget_settings(settings or {})
@@ -10044,42 +7357,7 @@ def monthly_budget_status(months, settings=None, now=None):
     }
 
 
-MATCHED_PACE_MIN_PAIRS = 20
-MATCHED_PACE_MIN_COVERAGE = 0.30
-
-
-# Features are precomputed once per sample with exactly the conversions the
-# per-pair arithmetic used, so every distance is bit-identical to computing it
-# from the sample dictionaries directly.
-_PACE_TOOLS, _PACE_OUTPUT, _PACE_PEAK, _PACE_INPUT, _PACE_MODEL = range(5)
 _PACE_CACHE, _PACE_TS, _PACE_TOOLS_F, _PACE_LOG_OUTPUT = range(5, 9)
-_PACE_LOG_PEAK, _PACE_LOG_INPUT, _PACE_LOG_MODEL = range(9, 12)
-# Prefilter slack: |log2(a) - log2(b)| and |log(a / b, 2)| differ only by
-# rounding, so a pair this far outside the output gate can never pass it.
-_PACE_PREFILTER_SLACK = 1e-9
-
-
-def _pace_features(sample):
-    tools = int(sample.get("tool_calls") or 0)
-    output = max(1.0, float(sample.get("output_tokens") or 0))
-    peak = max(1.0, float(sample.get("peak_input_tokens") or sample.get("input_tokens") or 0))
-    input_value = max(1.0, float(sample.get("input_tokens") or 0))
-    model = max(1.0, float(sample.get("model_calls") or 1))
-    input_tokens = max(1, int(sample.get("input_tokens") or 0))
-    return (
-        tools,
-        output,
-        peak,
-        input_value,
-        model,
-        min(1.0, float(sample.get("cache_read_tokens") or 0) / input_tokens),
-        float(sample.get("ts") or 0),
-        max(1.0, float(tools or 0)),
-        math.log2(output),
-        math.log2(peak),
-        math.log2(input_value),
-        math.log2(model),
-    )
 
 
 def _pace_feature_distance(left, right):
@@ -10136,41 +7414,6 @@ def pace_match_distance(left, right):
     return _pace_feature_distance(_pace_features(left), _pace_features(right))
 
 
-def _percentile(values, quantile):
-    if not values:
-        return 0.0
-    ordered = sorted(float(value) for value in values)
-    return ordered[min(len(ordered) - 1, max(0, int(round((len(ordered) - 1) * quantile))))]
-
-
-def _bootstrap_median_interval(values, seed_key, repetitions=400):
-    if not values:
-        return 0.0, 0.0
-    if len(values) == 1:
-        return float(values[0]), float(values[0])
-    seed = int(hashlib.sha256(str(seed_key).encode("utf-8")).hexdigest()[:16], 16)
-    rng = random.Random(seed)
-    # Bit-for-bit the draws of ``statistics.median(rng.choice(values) ...)``:
-    # ``choice`` is rejection sampling over ``getrandbits(n.bit_length())``,
-    # inlined here because the call layers dominated the build time.
-    getrandbits = rng.getrandbits
-    count = len(values)
-    bits = count.bit_length()
-    middle = count // 2
-    odd = count % 2
-    medians = []
-    for _ in range(repetitions):
-        drawn = []
-        for _ in range(count):
-            index = getrandbits(bits)
-            while index >= count:
-                index = getrandbits(bits)
-            drawn.append(values[index])
-        drawn.sort()
-        medians.append(drawn[middle] if odd else (drawn[middle - 1] + drawn[middle]) / 2)
-    return _percentile(medians, 0.025), _percentile(medians, 0.975)
-
-
 def matched_pace_comparison(a_id, a_samples, b_id, b_samples, distance_cache=None):
     """Compare two model-runtime histories using deterministic workload matching."""
     def usable(sample):
@@ -10250,106 +7493,11 @@ def features(sample):
     if matched_pairs < MATCHED_PACE_MIN_PAIRS:
         result["reason"] = f"only {matched_pairs} comparable turns; needs {MATCHED_PACE_MIN_PAIRS}"
     elif coverage < MATCHED_PACE_MIN_COVERAGE:
-        result["reason"] = f"only {round(coverage * 100)}% of the smaller history overlaps"
-    else:
-        result["available"] = True
-        result["reason"] = ""
-    return result
-
-
-def _pace_samples_signature(samples, fields):
-    """Return a stable digest of the fields that affect a pace comparison."""
-    digest = hashlib.sha256()
-    for sample in samples or ():
-        digest.update(b"\0sample\0")
-        digest.update(
-            repr(tuple(sample.get(field) for field in fields)).encode(
-                "utf-8", errors="replace",
-            )
-        )
-    return digest.hexdigest()
-
-
-MATCHED_PACE_WINDOW_KEYS = (
-    "today", "yesterday", "7", "30", "90", "month", "last_month", "all",
-)
-_MATCHED_PACE_INT_FIELDS = ("a_samples", "b_samples", "matched_pairs")
-_MATCHED_PACE_FLOAT_FIELDS = ("coverage", "pace_ratio", "ci_low", "ci_high")
-
-
-_MATCHED_PACE_COMPARISON_KEYS = frozenset(
-    ("a_id", "b_id", "available", "reason")
-    + _MATCHED_PACE_INT_FIELDS + _MATCHED_PACE_FLOAT_FIELDS
-)
-# Stored numbers outside these bounds are corrupt; the pair is recomputed.
-_MATCHED_PACE_MAX_COUNT = 10 ** 9
-_MATCHED_PACE_MAX_RATIO = 1e15
-_MATCHED_PACE_MAX_REASON = 200
-# Every reason string matched_pace_comparison can produce.
-_MATCHED_PACE_REASON_RE = re.compile(
-    r"|needs \d{1,9} timed turns per runtime"
-    r"|only \d{1,9} comparable turns; needs \d{1,9}"
-    r"|only \d{1,9}% of the smaller history overlaps"
-)
-
-
-def _valid_matched_pace_comparison(value, a_id, b_id):
-    """Return a rebuilt comparison with exactly the builder keys, else None.
-
-    Never raises: magnitude checks run before any float conversion, so a huge
-    JSON integer cannot overflow. Unknown keys reject the comparison so stored
-    content can never reach API output beyond the builder's own fields.
-    """
-    if not isinstance(value, dict) or set(value) != _MATCHED_PACE_COMPARISON_KEYS:
-        return None
-    if value["a_id"] != a_id or value["b_id"] != b_id:
-        return None
-    for field in _MATCHED_PACE_INT_FIELDS:
-        number = value[field]
-        if (isinstance(number, bool) or not isinstance(number, int)
-                or not 0 <= number <= _MATCHED_PACE_MAX_COUNT):
-            return None
-    for field in _MATCHED_PACE_FLOAT_FIELDS:
-        number = value[field]
-        if isinstance(number, bool) or not isinstance(number, (int, float)):
-            return None
-        # Chained comparison is exact for ints of any size and rejects NaN.
-        if not 0 <= number <= _MATCHED_PACE_MAX_RATIO:
-            return None
-        if isinstance(number, float) and not math.isfinite(number):
-            return None
-    if not 0 <= value["coverage"] <= 1:
-        return None
-    if not isinstance(value["available"], bool):
-        return None
-    reason = value["reason"]
-    if (not isinstance(reason, str) or len(reason) > _MATCHED_PACE_MAX_REASON
-            or not _MATCHED_PACE_REASON_RE.fullmatch(reason)):
-        return None
-    return {key: value[key] for key in (
-        "a_id", "b_id", "a_samples", "b_samples", "matched_pairs", "coverage",
-        "pace_ratio", "ci_low", "ci_high", "available", "reason",
-    )}
-
-
-def _valid_matched_pace_entry(entry):
-    """Return the (key, cached) pair for a usable stored entry, else None."""
-    if not isinstance(entry, dict):
-        return None
-    a_id, b_id = entry.get("a_id"), entry.get("b_id")
-    signature, windows = entry.get("signature"), entry.get("windows")
-    if not (isinstance(a_id, str) and isinstance(b_id, str)
-            and isinstance(signature, str) and isinstance(windows, dict)):
-        return None
-    if set(windows) != set(MATCHED_PACE_WINDOW_KEYS):
-        return None
-    rebuilt = {}
-    for window in MATCHED_PACE_WINDOW_KEYS:
-        comparison = _valid_matched_pace_comparison(windows[window], a_id, b_id)
-        if comparison is None:
-            return None
-        rebuilt[window] = comparison
-    return (a_id, b_id), {"signature": signature, "windows": rebuilt}
+        result["reason"] = f"only {round(coverage * 100)}% of the smaller history overlaps"
+    else:
+        result["available"] = True
+        result["reason"] = ""
+    return result
 
 
 def _ensure_matched_pace_cache_loaded():
@@ -10576,66 +7724,6 @@ def matched_pace_windows(sample_groups, now_ts=None, persistent=True):
         return data
 
 
-def _finalize_throughput_fields(row):
-    """Add weighted speed and coverage fields to a model or model/day row."""
-    tool_free_samples = int(row.get("tool_free_samples") or 0)
-    timed_samples = int(row.get("timed_samples") or 0)
-    if tool_free_samples and row.get("tool_free_seconds", 0) > 0:
-        speed_output = int(row.get("tool_free_output_tokens") or 0)
-        speed_seconds = float(row.get("tool_free_seconds") or 0)
-        basis = "tool_free"
-        sample_count = tool_free_samples
-    elif timed_samples and row.get("timed_seconds", 0) > 0:
-        speed_output = int(row.get("timed_output_tokens") or 0)
-        speed_seconds = float(row.get("timed_seconds") or 0)
-        basis = "end_to_end"
-        sample_count = timed_samples
-    else:
-        speed_output = 0
-        speed_seconds = 0.0
-        basis = "unavailable"
-        sample_count = 0
-    total_output = int(row.get("output_tokens") or 0)
-    row["output_tps"] = (speed_output / speed_seconds) if speed_seconds > 0 else 0
-    row["throughput_basis"] = basis
-    row["throughput_samples"] = sample_count
-    row["timing_coverage"] = (speed_output / total_output) if total_output > 0 else 0
-    ttft_samples = int(row.get("ttft_samples") or 0)
-    row["avg_ttft_ms"] = (float(row.get("ttft_total_s") or 0) * 1000 / ttft_samples) if ttft_samples else 0
-    wait_samples = int(row.get("wait_samples") or 0)
-    row["avg_wait_s"] = (float(row.get("wait_seconds") or 0) / wait_samples) if wait_samples else 0
-    durations = sorted(
-        float(value) for value in (row.get("wait_durations_s") or [])
-        if float(value or 0) > 0
-    )
-    p95_index = min(len(durations) - 1, max(0, math.ceil(len(durations) * 0.95) - 1)) if durations else 0
-    row["median_wait_s"] = statistics.median(durations) if durations else 0
-    row["p95_wait_s"] = durations[p95_index] if durations else 0
-    workload_fields = {
-        "workload_peak_inputs": "median_peak_input_tokens",
-        "workload_outputs": "median_workload_output_tokens",
-        "workload_tool_calls": "median_tool_calls",
-        "workload_model_calls": "median_model_calls",
-        "workload_cache_ratios": "median_cache_ratio",
-    }
-    for source_key, target_key in workload_fields.items():
-        values = [float(value) for value in (row.get(source_key) or []) if float(value or 0) >= 0]
-        row[target_key] = statistics.median(values) if values else 0
-    return row
-
-
-def project_filter_key(value):
-    """Keep project controls to folder-like paths; retain all other sessions together."""
-    project = str(value or "").strip().replace("\\", "/")
-    if (project.startswith("/") and not project.startswith("/private/")
-            or project.startswith("~/") and not project.startswith((
-                "~/.codex/", "~/Library/", "~/Documents/Codex/",
-            ))
-            or re.match(r"^[A-Za-z]:/", project)):
-        return project
-    return OTHER_LOCAL_SESSIONS_PROJECT
-
-
 def delivery_project_label(value):
     """Return a compact project label without exposing its local path."""
     project = project_filter_key(value)
@@ -10943,9 +8031,6 @@ def _work_output_price(model, provider):
     return float(value) if isinstance(value, (int, float)) and value > 0 else None
 
 
-_work_source_keys = {"sources": None, "salt": None, "keys": {}}
-
-
 def work_insights_refill(session_keys):
     """Re-load backlog sources through the normal adapter path so their turns re-enter the queue."""
     service = work_insights_service()
@@ -11227,34 +8312,6 @@ def public_project(value):
     return rows, service
 
 
-WORK_DRILL_ENUMS = {
-    "work_type": set(_work.WORK_TYPES) | {"unclear"},
-    "complexity": {"routine", "everyday", "complex"},
-    "tier": {"light", "standard", "premium"},
-    "effort": {"default", "low", "medium", "high", "xhigh", "max", "ultra"},
-    "outcome": {"single_shot", "accepted", "recovered", "ended_on_pushback", "unclear", "pending"},
-    "tag": set(_domain_work_tags),
-}
-
-
-def _work_bucket_valid(value, grain):
-    if grain == "day":
-        if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
-            return False
-        try:
-            datetime.date.fromisoformat(value)
-        except ValueError:
-            return False
-        return True
-    return bool(re.fullmatch(r"\d{4}-(0[1-9]|1[0-2])", value))
-
-
-def _work_label_since(settings):
-    """First day the classifier labels, from the history setting; empty when it labels all history."""
-    days = settings.get("backfill_days") or 0
-    return (datetime.date.today() - datetime.timedelta(days=days)).isoformat() if days else ""
-
-
 def work_sessions_state(query):
     """Bounded list of sessions behind one Work module cell (allowlisted fields only)."""
     if not work_insights_supported():
@@ -11459,10 +8516,6 @@ def aggregate_model_stats(session_rows, global_scope=True):
     )
 
 
-def metric_coverage(rows, metric):
-    return _domain_metric_coverage(rows, metric)
-
-
 def canonical_aggregation_sources(sources):
     """Honor adapter-owned aggregation identities without generic ID deduplication."""
     source_rows = list(sources or ())
@@ -11692,18 +8745,6 @@ def source_key(source):
     return data
 
 
-def _builder_recap_line_count(value, maximum=(1 << 53) - 1):
-    if isinstance(value, bool):
-        return None
-    if isinstance(value, int):
-        return value if 0 <= value <= maximum else None
-    if isinstance(value, float):
-        if (math.isfinite(value) and value.is_integer()
-                and 0 <= value <= maximum):
-            return int(value)
-    return None
-
-
 def builder_recap_state(range_key):
     """Build a privacy-bounded recap from aggregate session and Git evidence."""
     try:
@@ -11880,26 +8921,6 @@ def open_id(row):
     }, 200
 
 
-def enqueue_latest(q_, data):
-    """Keep a slow SSE client subscribed by replacing queued stale snapshots."""
-    try:
-        q_.put_nowait(data)
-        return True
-    except queue.Full:
-        try:
-            while True:
-                q_.get_nowait()
-        except queue.Empty:
-            pass
-        try:
-            q_.put_nowait(data)
-        except queue.Full:
-            pass
-        return True
-    except Exception:
-        return False
-
-
 def publish(state):
     global STATE
     STATE = state
@@ -11925,35 +8946,6 @@ def source_mtime_signature(sources):
     ))
 
 
-def source_identity_signature(sources):
-    """Track session membership independently from ordinary log updates."""
-    return tuple(sorted(
-        (str(source.get("provider") or ""),
-         str(source.get("id") or ""),
-         str(source.get("path") or ""))
-        for source in (sources or [])
-        if source.get("id") or source.get("path")
-    ))
-
-
-def source_membership_probe_due(now, last_probe):
-    """Check cheap filesystem revisions every two seconds."""
-    return now - last_probe >= _SOURCE_MEMBERSHIP_PROBE_S
-
-
-def source_membership_fallback_due(now, last_fallback):
-    """Bound path-only session discovery to a four-second worst case."""
-    return now - last_fallback >= _SOURCE_MEMBERSHIP_FALLBACK_S
-
-
-def source_discovery_refresh_due(inventory_ready, now, last_refresh):
-    """Bound adapter-wide enumeration while keeping known-file checks fast."""
-    return bool(
-        not inventory_ready
-        or now - last_refresh >= _SOURCE_DISCOVERY_REFRESH_S
-    )
-
-
 def _source_inventory_roots():
     return (
         CLAUDE_PROJECTS,
@@ -11968,13 +8960,6 @@ def _source_inventory_roots():
     )
 
 
-def _physical_source_path(value):
-    value = str(value or "")
-    if not value or not os.path.isabs(os.path.expanduser(value)):
-        return ""
-    return os.path.abspath(os.path.expanduser(value))
-
-
 def source_inventory_probe_targets(sources, roots=None, extra_files=None):
     """Build a bounded target set for cheap new/resumed-session detection."""
     roots = tuple(
@@ -12030,36 +9015,6 @@ def add_path_and_ancestors(value):
     return tuple(sorted(targets))
 
 
-def source_inventory_probe_signature(targets, current_path=""):
-    """Stat probe targets while ignoring ordinary growth of the active trace."""
-    current_path = _physical_source_path(current_path)
-    current_is_dir = bool(current_path and os.path.isdir(current_path))
-    signature = []
-    for value in targets or ():
-        path = _physical_source_path(value)
-        if not path:
-            continue
-        is_current = path == current_path or bool(
-            current_is_dir and path.startswith(current_path + os.sep)
-        )
-        if is_current:
-            signature.append((path, "active", 0, 0))
-            continue
-        try:
-            row = os.stat(path)
-        except OSError:
-            signature.append((path, "missing", 0, 0))
-            continue
-        is_directory = stat.S_ISDIR(row.st_mode)
-        signature.append((
-            path,
-            "directory" if is_directory else "file",
-            int(row.st_mtime_ns),
-            0 if is_directory else int(row.st_size),
-        ))
-    return tuple(signature)
-
-
 def runtime_candidate_paths():
     """Enumerate path identities only, without parsing adapter metadata."""
     paths = set()
@@ -12107,26 +9062,6 @@ def refresh_known_source_activity(sources, current_path):
     return refreshed if refreshed is not None else sources
 
 
-def cross_session_refresh_due(dirty, membership_changed, now, last_refresh):
-    """Refresh membership immediately while throttling ordinary log updates."""
-    return bool(
-        dirty and (
-            membership_changed
-            or now - last_refresh >= _XSESS_LIVE_REFRESH_S
-        )
-    )
-
-
-def current_session_refresh_due(signature, last_signature, now, last_refresh):
-    """Observe revisions every watcher tick but coalesce whole-trace rebuilds."""
-    if signature == last_signature:
-        return False
-    return bool(
-        last_signature is None
-        or now - last_refresh >= _CURRENT_SESSION_REBUILD_S
-    )
-
-
 def refresh_cross_session_state(state=None, builder=None, publisher=None):
     """Force a fresh cross-log snapshot and publish it with the live state."""
     builder = builder or cross_session
@@ -12183,30 +9118,6 @@ def current_state():
     }
 
 
-AGENT_RESULT_MAX_CHARS = 8000
-AGENT_CHECK_FOCUS = {"continue", "cost", "context", "tools", "next_phase"}
-AGENT_USAGE_WINDOWS = {"today": 1, "7d": 7, "14d": 14}
-AGENT_USAGE_FOCUS = {"spend", "models", "tools", "changes"}
-
-
-def agent_as_of():
-    return time.strftime("%Y-%m-%dT%H:%M:%S%z", time.localtime())
-
-
-def agent_project_key(value):
-    value = str(value or "").strip()
-    if not value or value == "No project":
-        return ""
-    return os.path.normcase(os.path.realpath(os.path.expanduser(value)))
-
-
-def agent_project_name(value):
-    value = str(value or "").strip().rstrip("/\\")
-    if not value or value == "No project":
-        return "No project"
-    return compact_text(value.replace("\\", "/").rsplit("/", 1)[-1], 52)
-
-
 def agent_provider(value):
     value = str(value or "").strip().lower()
     for runtime_id in sorted(runtime_registry().runtime_ids, key=len, reverse=True):
@@ -12276,50 +9187,6 @@ def agent_dashboard_url(session_id=None, panel="summary"):
     return f"{base}/#{panel}"
 
 
-def compact_agent_value(value, depth=0):
-    if depth > 5:
-        return None
-    if isinstance(value, str):
-        return compact_text(value, 500)
-    if isinstance(value, list):
-        return [compact_agent_value(item, depth + 1) for item in value[:10]]
-    if isinstance(value, dict):
-        return {str(key): compact_agent_value(item, depth + 1)
-                for key, item in list(value.items())[:50]}
-    return value
-
-
-def bounded_agent_result(result):
-    """Keep a model-facing result useful even if an upstream label grows unexpectedly."""
-    result = dict(result or {})
-    result["evidence"] = list(result.get("evidence") or [])[:3]
-    if isinstance(result.get("candidates"), list):
-        result["candidates"] = result["candidates"][:5]
-    result.setdefault("truncated", False)
-    encoded = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
-    if len(encoded) <= AGENT_RESULT_MAX_CHARS:
-        return result
-    result = compact_agent_value(result)
-    result["truncated"] = True
-    result["evidence"] = list(result.get("evidence") or [])[:2]
-    if isinstance(result.get("candidates"), list):
-        result["candidates"] = result["candidates"][:3]
-    if isinstance(result.get("categories"), list):
-        result["categories"] = result["categories"][:3]
-    for key in ("answer", "caveat", "recommended_action"):
-        if isinstance(result.get(key), str):
-            result[key] = compact_text(result[key], 240)
-    encoded = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
-    if len(encoded) > AGENT_RESULT_MAX_CHARS:
-        result.pop("categories", None)
-        result.pop("candidates", None)
-        result.pop("execution", None)
-    encoded = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
-    if len(encoded) > AGENT_RESULT_MAX_CHARS:
-        result["evidence"] = []
-    return result
-
-
 def agent_no_session(message, panel="summary"):
     return bounded_agent_result({
         "ok": False,
@@ -12458,21 +9325,6 @@ def agent_set_default_session_budget(budget_usd=None,
     })
 
 
-def safe_execution_trace(state, execution_idx, limit=5):
-    allowed = {"tool_call", "tool_result", "usage", "complete", "context", "reasoning", "coordination", "start"}
-    out = []
-    for event in state.get("trace") or []:
-        if event.get("execution") != execution_idx or event.get("kind") not in allowed:
-            continue
-        item = {"kind": event.get("kind"), "label": compact_text(event.get("label") or "Activity", 64)}
-        if event.get("kind") == "tool_result" and event.get("tokens") is not None:
-            item["returned_tokens"] = int(event.get("tokens") or 0)
-        if event.get("cost"):
-            item["cost"] = round(float(event.get("cost") or 0), 4)
-        out.append(item)
-    return out[:limit]
-
-
 def agent_check(focus="continue", execution=None, session_id=None, caller=None):
     focus = str(focus or "continue").strip().lower()
     if focus not in AGENT_CHECK_FOCUS:
@@ -12626,15 +9478,6 @@ def agent_check(focus="continue", execution=None, session_id=None, caller=None):
     return bounded_agent_result(result)
 
 
-def agent_usage_day_keys(window, today=None):
-    today = today or datetime.date.today()
-    day_count = AGENT_USAGE_WINDOWS[window]
-    return {
-        (today - datetime.timedelta(days=offset)).isoformat()
-        for offset in range(day_count)
-    }
-
-
 def agent_usage_model_categories(session_rows, day_keys, limit=5):
     categories = {}
     for session in session_rows or []:
@@ -12661,53 +9504,6 @@ def agent_usage_model_categories(session_rows, day_keys, limit=5):
     return ranked
 
 
-def agent_usage_tool_categories(session_rows, day_keys, limit=5):
-    categories = {}
-    total_tokens = 0
-    flagged_tokens = 0
-    for session in session_rows or []:
-        evidence = session.get("_tool_evidence") or {}
-        total_tokens += sum(
-            int(value or 0) for day, value in (evidence.get("day_tokens") or {}).items()
-            if day in day_keys
-        )
-        flagged_tokens += sum(
-            int(value or 0) for day, value in (evidence.get("day_flagged") or {}).items()
-            if day in day_keys
-        )
-        provider = session.get("provider") or "unknown"
-        for tool in evidence.get("tools") or []:
-            name = tool.get("name") or "?"
-            namespace = tool.get("namespace") or "unknown"
-            kind = tool.get("kind") or "tool"
-            diagnostic = kind == "mcp" and (
-                namespace == "tokenmeter" or str(name).startswith("mcp__tokenmeter__")
-            )
-            if diagnostic:
-                continue
-            key = (name, namespace, "" if kind == "mcp" else provider)
-            row = categories.setdefault(key, {
-                "name": tool.get("display") or name,
-                "namespace": namespace, "returned_tokens": 0, "calls": 0,
-            })
-            daily_rows = tool.get("daily") or []
-            if isinstance(daily_rows, dict):
-                daily_rows = daily_rows.values()
-            for daily in daily_rows:
-                if daily.get("day") not in day_keys:
-                    continue
-                row["returned_tokens"] += int(daily.get("output_tokens") or 0)
-                row["calls"] += int(daily.get("calls") or 0)
-    ranked = sorted(
-        (row for row in categories.values() if row["calls"] or row["returned_tokens"]),
-        key=lambda row: (-row["returned_tokens"], -row["calls"], row["name"]),
-    )[:limit]
-    return ranked, total_tokens, flagged_tokens
-
-
-# Runtimes whose every priced record is timestamped no later than the newest
-# file mtime the source revision tracks, so an older source cannot reach a window.
-_ACTIVITY_BOUNDED_PROVIDERS = frozenset(("claude", "codex"))
 AGENT_USAGE_RECENT_SESSIONS = 60
 
 
@@ -12734,19 +9530,6 @@ def _source_can_reach(source, start_ts):
     return bound is None or bound >= start_ts
 
 
-def _window_start_ts(day_keys):
-    earliest = datetime.date.fromisoformat(min(day_keys))
-    # One spare day covers DST and local/UTC day-boundary differences.
-    return datetime.datetime.combine(earliest, datetime.time()).timestamp() - 86400.0
-
-
-def _source_order_mtime(source):
-    try:
-        return float(source.get("mtime") or 0)
-    except (TypeError, ValueError, OverflowError):
-        return 0.0
-
-
 def agent_usage_evidence(day_keys):
     """Return the daily rows, session rows, and recent sessions ``agent_usage`` reads.
 
@@ -12953,10 +9736,7 @@ def agent_usage(window="7d", focus="changes"):
 HISTORY_SCAN_CHUNK_MAX = 256
 # With a complete scan already in hand, a refresh gets only this long before the call reuses it.
 HISTORY_REFRESH_WAIT_S = 2.0
-# Older discovered sources may miss the caller's run, so scope=current reuses only this fresh a scan.
-HISTORY_SOURCE_REUSE_S = 60.0
 _history_scan_lock = threading.Lock()
-_history_scan = {"progress": None, "last_complete": None}
 
 
 def _history_scan_worker(progress):
@@ -13055,10 +9835,6 @@ def _history_scan_progress():
     return progress
 
 
-def _history_scan_failed():
-    return RuntimeError("Token Meter could not scan session history.")
-
-
 def _cross_session_snapshot_fresh():
     # While history is being repriced the previous snapshot keeps serving.
     return bool(_xsess["data"]) and (
@@ -13114,12 +9890,6 @@ def agent_capability_evidence(deadline, progress=None):
     return capability_inventory(global_tool_waste(rows)), coverage
 
 
-def _capability_scan_label(coverage):
-    scanned = int(coverage.get("sessions_scanned") or 0)
-    total = coverage.get("sessions_total")
-    return f"{scanned} of {total}" if total is not None else f"{scanned}; discovery still running"
-
-
 def _capability_scan_pending(scope, answer, caveat, coverage=None):
     """Answer without candidates while the background scan has no evidence to name them."""
     coverage = coverage or {"complete": False, "sessions_scanned": 0, "sessions_total": None}
@@ -13278,211 +10048,6 @@ def agent_capabilities(scope="current", limit=5, caller=None):
     return bounded_agent_result(result)
 
 
-def compact_duration_ms(ms):
-    try:
-        seconds = max(0, int(ms) / 1000.0)
-    except Exception:
-        return ""
-    if seconds < 1:
-        return f"{int(seconds * 1000)}ms"
-    if seconds < 10:
-        return f"{seconds:.1f}s"
-    if seconds < 60:
-        return f"{int(round(seconds))}s"
-    minutes, sec = divmod(int(round(seconds)), 60)
-    if minutes < 60:
-        return f"{minutes}m {sec:02d}s"
-    hours, minutes = divmod(minutes, 60)
-    return f"{hours}h {minutes:02d}m"
-
-
-def menubar_activity(st):
-    trace = st.get("trace") or []
-    preferred = {
-        "tool_call", "tool_result", "message", "reasoning", "complete",
-        "context", "goal", "start", "user",
-    }
-    event = None
-    for ev in reversed(trace[-24:]):
-        if ev.get("kind") in preferred:
-            event = ev
-            break
-    if event is None and trace:
-        event = trace[-1]
-    if not event:
-        return {
-            "kind": "idle",
-            "title": "Waiting for activity",
-            "detail": "No trace events yet.",
-            "time": "",
-            "execution": None,
-        }
-
-    kind = event.get("kind") or "activity"
-    label = event.get("label") or kind.replace("_", " ").title()
-    detail = event.get("detail") or ""
-    tool = event.get("tool")
-    execution = event.get("execution")
-    duration_ms = event.get("duration_ms")
-
-    if kind == "tool_call":
-        title = f"Running {label}"
-    elif kind == "tool_result":
-        title = f"Received {label}"
-    elif kind == "reasoning":
-        title = "Reasoning"
-    elif kind == "message":
-        title = label if label != "Agent update" else "Agent update"
-    elif kind == "complete":
-        title = f"Completed #{execution}" if execution else "Execution complete"
-    elif kind == "context":
-        title = label
-    elif kind == "user":
-        title = "User message"
-    else:
-        title = label
-
-    bits = []
-    duration = compact_duration_ms(duration_ms)
-    if not duration and isinstance(detail, str) and detail.endswith("ms") and detail[:-2].isdigit():
-        duration = compact_duration_ms(detail[:-2])
-    if duration:
-        bits.append(f"in {duration}" if kind == "complete" else duration)
-    elif detail:
-        bits.append(detail)
-    if execution:
-        if kind == "complete":
-            pass
-        else:
-            bits.append(f"#{execution}")
-    if tool and tool not in title:
-        bits.append(tool)
-    if event.get("cost"):
-        bits.append(format_usd(event["cost"]))
-    detail = " · ".join(bits)
-    return {
-        "kind": kind,
-        "title": compact_text(title, 64),
-        "detail": compact_text(detail, 120),
-        "time": event.get("time") or "",
-        "execution": execution,
-        "tool": tool,
-    }
-
-
-def menubar_recommendation(st):
-    context = st.get("context") or {}
-    pct = context.get("latest_pct") or 0
-    insights = st.get("insights") or []
-    warn = next((i for i in insights if i.get("kind") == "warn"), None)
-    last_cost = st.get("last_turn_cost") or 0
-    cost_available = metric_available(st, "cost") and not st.get("token_estimate")
-    low_yield_actionable = (not st.get("token_estimate") and
-                            low_yield_should_warn(st.get("executions") or [], pct))
-
-    if st.get("ended"):
-        return {
-            "label": "Pinned log",
-            "detail": "This is a frozen log view; return to live to follow newest activity.",
-            "severity": "idle",
-            "target": "summary",
-        }
-    if pct >= MENUBAR_CONTEXT_INTERVENE_PCT:
-        return {
-            "label": "Compact now",
-            "detail": f"Context is {pct * 100:.0f}% of the model window.",
-            "severity": "bad",
-            "target": "summary",
-        }
-    if cost_available and last_cost >= MENUBAR_COST_SPIKE:
-        return {
-            "label": "Review spike",
-            "detail": f"Last execution cost {format_usd(last_cost)}.",
-            "severity": "bad",
-            "target": "summary",
-        }
-    if low_yield_actionable:
-        return {
-            "label": "Summarize soon",
-            "detail": "Latest execution replayed large context for low output.",
-            "severity": "warn",
-            "target": "summary",
-        }
-    if pct >= MENUBAR_CONTEXT_WATCH_PCT:
-        return {
-            "label": "Summarize soon",
-            "detail": f"Context is {pct * 100:.0f}%; prepare before 85%.",
-            "severity": "warn",
-            "target": "summary",
-        }
-    if pct >= MENUBAR_CONTEXT_SOFT_PCT:
-        return {
-            "label": "Watch context",
-            "detail": f"Context is {pct * 100:.0f}% of the model window.",
-            "severity": "idle",
-            "target": "summary",
-        }
-    if warn:
-        return {
-            "label": "Check signal",
-            "detail": warn.get("text") or "A warning signal is active.",
-            "severity": "warn",
-            "target": "summary",
-        }
-    return {
-        "label": "Let it run",
-        "detail": "No immediate intervention needed.",
-        "severity": "good",
-        "target": "summary",
-    }
-
-
-def menubar_verdict(st, recommendation):
-    context = st.get("context") or {}
-    reported_pct = context.get("latest_pct")
-    pct = reported_pct or 0
-    last_cost = st.get("last_turn_cost") or 0
-    cost_available = metric_available(st, "cost") and not st.get("token_estimate")
-    insights = st.get("insights") or []
-    operational_warn = next((i for i in insights if i.get("kind") == "warn" and is_operational_warning(i)), None)
-
-    def payload(key, detail):
-        labels = {
-            "healthy": ("Healthy", "TM", "good"),
-            "watch": ("Watch closely", "TM !", "warn"),
-            "intervene": ("Intervene now", "TM !!", "bad"),
-            "idle": ("Idle", "TM idle", "idle"),
-        }
-        label, prefix, severity = labels[key]
-        return {"key": key, "label": label, "prefix": prefix, "severity": severity, "detail": detail}
-
-    if st.get("ended"):
-        return payload("idle", "This is a frozen log view; return to live to follow newest activity.")
-    if pct >= MENUBAR_CONTEXT_INTERVENE_PCT:
-        return payload(
-            "intervene",
-            f"Context is {pct * 100:.0f}% of the model window; compact now.",
-        )
-    if cost_available and last_cost >= MENUBAR_COST_SPIKE:
-        return payload(
-            "intervene",
-            f"Last execution cost {format_usd(last_cost)}; review the spike before continuing.",
-        )
-    if pct >= MENUBAR_CONTEXT_WATCH_PCT:
-        return payload(
-            "watch",
-            f"Context is {pct * 100:.0f}% of the model window; prepare to summarize before 85%.",
-        )
-    if operational_warn:
-        detail = operational_warn.get("text") or recommendation.get("detail") or "An operational warning is active."
-        return payload("watch", detail)
-
-    detail = (f"Context is {pct * 100:.0f}% and no operational warning needs intervention."
-              if reported_pct is not None else
-              "Context percentage is not reported; no operational warning needs intervention.")
-    return payload("healthy", detail)
-
-
 def provider_cli_path(name):
     resolved = shutil.which(name)
     if resolved:
@@ -13534,24 +10099,6 @@ def codex_app_server_rate_limits(timeout=QUOTA_PROCESS_TIMEOUT_S):
     )
 
 
-def _codex_limit_label(value):
-    return openai_quotas.limit_label(value)
-
-
-def _codex_window(provider_id, raw, kind, label, now=None):
-    return openai_quotas._window(provider_id, raw, kind, label, now=now)
-
-
-def parse_codex_quota(payload, source="Codex app-server", now=None):
-    return openai_quotas.parse_quota(payload, source=source, now=now)
-
-
-def codex_oauth_quota(now=None, opener=None):
-    return openai_quotas.oauth_quota(
-        CODEX_AUTH, quota_http_json, now=now, opener=opener
-    )
-
-
 def load_codex_quota(now=None):
     return openai_quotas.load_quota(
         codex_app_server_rate_limits, codex_oauth_quota, now=now
@@ -13574,16 +10121,6 @@ def claude_oauth_credentials(auth_status=None, timeout=3.0):
     )
 
 
-def _claude_window(field, raw, kind, label, duration, now=None):
-    return anthropic_quotas._window(field, raw, kind, label, duration, now=now)
-
-
-def parse_claude_quota(payload, credentials=None, now=None):
-    return anthropic_quotas.parse_quota(
-        payload, credentials=credentials, now=now
-    )
-
-
 def load_claude_quota(now=None, opener=None):
     return anthropic_quotas.load_quota(
         claude_auth_status,
@@ -13602,23 +10139,12 @@ def cursor_auth_session(now=None, db_path=None):
     )
 
 
-def parse_cursor_quota(payload, now=None):
-    return cursor_quotas.parse_quota(payload, now=now)
-
-
 def load_cursor_quota(now=None, opener=None):
     return cursor_quotas.load_quota(
         cursor_auth_session, quota_http_json, now=now, opener=opener
     )
 
 
-def _quota_loading_row(provider):
-    labels = {"claude": "Claude", "codex": "Codex", "cursor": "Cursor"}
-    return quota_provider(
-        provider, labels[provider], "loading", "Provider account", error="Loading provider quotas.",
-    )
-
-
 def _quota_failure_row(provider, error, now):
     safe_error = str(error) if isinstance(error, QuotaUnavailable) else "Provider quota refresh failed."
     with _quota_lock:
@@ -13723,123 +10249,6 @@ def reset_provider_quota_cache():
         _quota_inflight.clear()
 
 
-def menubar_project_name(value):
-    """Return only a display-safe project leaf for the native payload."""
-    project = str(value or "").rstrip("/\\")
-    if not project or project == "No project":
-        return ""
-    return compact_text(project.replace("\\", "/").rsplit("/", 1)[-1], 52)
-
-
-def menubar_session_name(source):
-    session_name = compact_text(source.get("session_name") or "", 52).strip()
-    if session_name and session_name.lower() not in ("untitled", "untitled session"):
-        return session_name
-    title = compact_text(source.get("title") or "", 52).strip()
-    if title and title.lower() not in ("untitled", "untitled session"):
-        return title
-    project = menubar_project_name(source.get("project"))
-    if project:
-        return project
-    return str(source.get("id") or "session")[:12]
-
-
-def menubar_recent_sessions(sources, selected_id=None, limit=5, summaries=None):
-    summary_names = {}
-    for summary in summaries or ():
-        key = (str(summary.get("provider") or ""), str(summary.get("id") or ""))
-        name = compact_text(summary.get("session_name") or "", 52).strip()
-        if key[1] and name and key not in summary_names:
-            summary_names[key] = name
-
-    # A child run is listed through its root session, which inherits the
-    # child's newer activity, so the menu never offers a child as its own run.
-    source_list = list(sources or [])
-    root_keys = {
-        (str(row.get("provider") or ""), str(row.get("id") or ""))
-        for row in source_list
-    }
-    child_activity = {}
-    for row in source_list:
-        root_id = folded_child_root_id(row)
-        key = (str(row.get("provider") or ""), root_id)
-        if root_id and key in root_keys:
-            child_activity[key] = max(
-                child_activity.get(key, 0), float(row.get("mtime") or 0),
-            )
-    listed = []
-    for row in source_list:
-        key = (str(row.get("provider") or ""), folded_child_root_id(row))
-        if key[1] and key in root_keys:
-            continue
-        own_key = (str(row.get("provider") or ""), str(row.get("id") or ""))
-        if own_key in child_activity and child_activity[own_key] > float(row.get("mtime") or 0):
-            row = dict(row, mtime=child_activity[own_key])
-        listed.append(row)
-
-    ordered, seen = [], set()
-    for source in sorted(listed, key=lambda row: -(row.get("mtime") or 0)):
-        sid = str(source.get("id") or "")
-        if not sid or sid in seen:
-            continue
-        seen.add(sid)
-        ordered.append(source)
-
-    selected = next((row for row in ordered if row.get("id") == selected_id), None)
-    choices = ordered[:max(0, limit)]
-    if selected and selected not in choices and limit > 0:
-        choices = [selected] + [row for row in ordered if row is not selected][:limit - 1]
-
-    result = []
-    for row in choices:
-        display_row = dict(row)
-        key = (str(row.get("provider") or ""), str(row.get("id") or ""))
-        if summary_names.get(key):
-            display_row["session_name"] = summary_names[key]
-        result.append({
-            "id": row.get("id"),
-            "provider": row.get("provider"),
-            "client": row.get("client") or row.get("provider"),
-            "label": row.get("label"),
-            "name": menubar_session_name(display_row),
-            "mtime": row.get("mtime") or 0,
-        })
-    return result
-
-
-def menubar_cache_window(current_sessions, selected_id, root_id=None):
-    """Return the selected session's cache window; a folded child run resolves to its root."""
-    for wanted in (str(selected_id or ""), str(root_id or "")):
-        if not wanted:
-            continue
-        for summary in current_sessions or ():
-            if isinstance(summary, dict) and str(summary.get("id") or "") == wanted:
-                return _domain_cache_window_projection(summary.get("cache_window"))
-    return None
-
-
-def menubar_context_pulse(st, limit=18):
-    """Return a short numeric context history for the native Run Pulse.
-
-    The native companion needs a visual indication of whether measured context
-    is rising or settling, but it must never receive trace text, paths, tool
-    inputs, or other session contents. Keep only finite context percentages
-    from the most recent completed executions.
-    """
-    values = []
-    for execution in (st.get("executions") or []):
-        value = execution.get("context_pct")
-        if isinstance(value, bool):
-            continue
-        try:
-            value = float(value)
-        except (TypeError, ValueError):
-            continue
-        if math.isfinite(value):
-            values.append(round(max(0.0, min(1.0, value)), 4))
-    return values[-max(1, limit):]
-
-
 def menubar_software_update(status=None):
     """Project update state into the native menu without local checkout details."""
     status = status if isinstance(status, dict) else software_update_status()
@@ -13869,29 +10278,6 @@ def menubar_software_update(status=None):
     }
 
 
-def menubar_today_spend(cross, today=None):
-    """Return a bounded current-day spend projection for the native title."""
-    day = (today or datetime.date.today()).isoformat()
-    daily = cross.get("daily") if isinstance(cross, dict) else []
-    row = next(
-        (item for item in (daily or [])
-         if isinstance(item, dict) and item.get("day") == day),
-        None,
-    )
-    availability = row.get("availability") if isinstance(row, dict) else {}
-    available = bool(isinstance(availability, dict) and availability.get("cost") is True)
-    provenance = row.get("provenance") if isinstance(row, dict) else {}
-    estimated_cost = (
-        float(provenance.get("estimated_cost") or 0)
-        if isinstance(provenance, dict) else 0.0
-    )
-    return {
-        "available": available,
-        "total_cost": float(row.get("cost") or 0) if available else None,
-        "estimated": estimated_cost > 0,
-    }
-
-
 def menubar_work_insights():
     settings = work_insights_settings()
     if not settings["enabled"]:
@@ -14218,21 +10604,6 @@ def page_path():
     return None
 
 
-def page_root(path):
-    """Directory that holds the dashboard and its bundled assets."""
-    if dashboard_page.is_manifest(path):
-        return dashboard_page.dashboard_root(path)
-    return os.path.dirname(path)
-
-
-def page_bytes(path):
-    """Assembled dashboard bytes, or None when a part is missing or unreadable."""
-    try:
-        return dashboard_page.read_page(path).encode("utf-8")
-    except (OSError, UnicodeDecodeError, ValueError):
-        return None
-
-
 def performance_page_candidates():
     return [
         os.path.join(_SOURCE_ROOT, "performance.html"),
@@ -14250,32 +10621,6 @@ def performance_page_path():
     return None
 
 
-def is_dashboard_page_path(req_path):
-    return req_path == "/" or bool(re.fullmatch(r"/sessions/[^/]{1,240}/?", req_path or ""))
-
-
-_DASHBOARD_ASSETS = {
-    "/assets/fonts/Tektur-Variable.ttf": ("assets/fonts/Tektur-Variable.ttf", "font/ttf"),
-    "/assets/brand/logo-splunk-by-cisco-rgb-w.png": (
-        "assets/brand/logo-splunk-by-cisco-rgb-w.png",
-        "image/png",
-    ),
-    **{
-        f"/{asset}": (asset, "text/javascript; charset=utf-8")
-        for asset in (
-            "assets/session-effects.js",
-            "assets/vendor/paper-shaders/get-shader-color-from-string.js",
-            "assets/vendor/paper-shaders/get-shader-noise-texture.js",
-            "assets/vendor/paper-shaders/shader-mount.js",
-            "assets/vendor/paper-shaders/shader-sizing.js",
-            "assets/vendor/paper-shaders/shader-utils.js",
-            "assets/vendor/paper-shaders/vertex-shader.js",
-            "assets/vendor/paper-shaders/shaders/pulsing-border.js",
-        )
-    },
-}
-
-
 def dashboard_asset_path(req_path):
     """Resolve explicitly bundled dashboard assets without exposing arbitrary files."""
     spec = _DASHBOARD_ASSETS.get(req_path)
@@ -14288,11 +10633,6 @@ def dashboard_asset_path(req_path):
     return path if os.path.isfile(path) else None
 
 
-def dashboard_asset_content_type(req_path):
-    spec = _DASHBOARD_ASSETS.get(req_path)
-    return spec[1] if spec else None
-
-
 def missing_page_html():
     candidates = "\n".join(
         f"<li><code>{html.escape(path)}</code></li>" for path in PAGE_CANDIDATES
@@ -14317,29 +10657,6 @@ def missing_page_html():
 </html>"""
 
 
-def missing_performance_html():
-    return """<!doctype html>
-<html>
-<head><meta charset="utf-8"><title>Token Meter setup error</title></head>
-<body><h1>performance.html is missing</h1>
-<p>Reinstall Token Meter from a complete source checkout.</p></body>
-</html>"""
-
-
-def _page_within_runtime(page, runtime):
-    """True when the served page lives under ``runtime``; installers ask this instead of reading a path."""
-    if not page or not isinstance(runtime, str) or not runtime or len(runtime) > 4096:
-        return False
-    if not os.path.isabs(runtime):
-        return False
-    try:
-        root = os.path.normcase(os.path.realpath(runtime))
-        served = os.path.normcase(os.path.realpath(page))
-        return os.path.commonpath([root, served]) == root
-    except (OSError, ValueError):
-        return False
-
-
 def health_state(expected_runtime=None):
     """Return constant-time liveness/readiness from watcher-owned cached state.
 
@@ -14953,21 +11270,6 @@ def do_GET(self):
             self.send_error(404)
 
 
-class TokenMeterHTTPServer(ThreadingHTTPServer):
-    allow_reuse_address = True
-    daemon_threads = True
-    request_queue_size = 64
-
-    def server_bind(self):
-        # http.server stores socket.getfqdn(host) as server_name, a blocking
-        # reverse lookup. The bind address is loopback and no code reads the
-        # FQDN, so keep the host as-is and let listen() start without DNS.
-        socketserver.TCPServer.server_bind(self)
-        host, port = self.server_address[:2]
-        self.server_name = host
-        self.server_port = port
-
-
 _APPLICATION = None
 
 
diff --git a/token_meter/app_helpers/__init__.py b/token_meter/app_helpers/__init__.py
new file mode 100644
index 00000000..09839e3d
--- /dev/null
+++ b/token_meter/app_helpers/__init__.py
@@ -0,0 +1,7 @@
+"""Leaf helpers extracted from ``token_meter.app``.
+
+Each module holds code that depends only on the standard library, other
+Token Meter packages, and ``app_helpers.common``. ``token_meter.app`` imports
+every name back, so ``meter.NAME`` keeps working. Code that tests patch on
+``meter`` stays in ``app.py`` until those tests patch the owning module.
+"""
diff --git a/token_meter/app_helpers/agents.py b/token_meter/app_helpers/agents.py
new file mode 100644
index 00000000..de2f77fd
--- /dev/null
+++ b/token_meter/app_helpers/agents.py
@@ -0,0 +1,113 @@
+"""Agent identity and presentation helpers."""
+
+import datetime
+import os
+import shlex
+import time
+
+from token_meter.app_helpers.common import compact_text
+
+
+def agent_access_command_display(command):
+    command = list(command or [])
+    if command:
+        command[0] = os.path.basename(command[0])
+    return shlex.join(command)
+
+
+def agent_cli_error_detail(completed):
+    raw = str(getattr(completed, "stderr", "") or getattr(completed, "stdout", "") or "")
+    lines = [line.strip() for line in raw.splitlines() if line.strip()]
+    if not lines:
+        return ""
+    return compact_text(lines[-1].replace(os.path.expanduser("~"), "~"), 220)
+
+
+def _agent_access_matches(command, args, env, launcher, runtime):
+    try:
+        command_match = os.path.realpath(os.path.expanduser(str(command or ""))) == os.path.realpath(launcher)
+    except OSError:
+        command_match = False
+    return bool(command_match and list(args or []) == [] and str((env or {}).get("TOKEN_METER_CALLER") or "") == runtime)
+
+
+CLAUDE_CODE_CLIENT = "claude_code"
+
+
+def _agent_skill_part(client):
+    client = str(client or "").strip().lower()
+    return {"codex": "codex", "claude": CLAUDE_CODE_CLIENT}.get(client)
+
+
+AGENT_USAGE_WINDOWS = {"today": 1, "7d": 7, "14d": 14}
+
+
+def agent_as_of():
+    return time.strftime("%Y-%m-%dT%H:%M:%S%z", time.localtime())
+
+
+def agent_project_key(value):
+    value = str(value or "").strip()
+    if not value or value == "No project":
+        return ""
+    return os.path.normcase(os.path.realpath(os.path.expanduser(value)))
+
+
+def agent_project_name(value):
+    value = str(value or "").strip().rstrip("/\\")
+    if not value or value == "No project":
+        return "No project"
+    return compact_text(value.replace("\\", "/").rsplit("/", 1)[-1], 52)
+
+
+def agent_usage_day_keys(window, today=None):
+    today = today or datetime.date.today()
+    day_count = AGENT_USAGE_WINDOWS[window]
+    return {
+        (today - datetime.timedelta(days=offset)).isoformat()
+        for offset in range(day_count)
+    }
+
+
+def agent_usage_tool_categories(session_rows, day_keys, limit=5):
+    categories = {}
+    total_tokens = 0
+    flagged_tokens = 0
+    for session in session_rows or []:
+        evidence = session.get("_tool_evidence") or {}
+        total_tokens += sum(
+            int(value or 0) for day, value in (evidence.get("day_tokens") or {}).items()
+            if day in day_keys
+        )
+        flagged_tokens += sum(
+            int(value or 0) for day, value in (evidence.get("day_flagged") or {}).items()
+            if day in day_keys
+        )
+        provider = session.get("provider") or "unknown"
+        for tool in evidence.get("tools") or []:
+            name = tool.get("name") or "?"
+            namespace = tool.get("namespace") or "unknown"
+            kind = tool.get("kind") or "tool"
+            diagnostic = kind == "mcp" and (
+                namespace == "tokenmeter" or str(name).startswith("mcp__tokenmeter__")
+            )
+            if diagnostic:
+                continue
+            key = (name, namespace, "" if kind == "mcp" else provider)
+            row = categories.setdefault(key, {
+                "name": tool.get("display") or name,
+                "namespace": namespace, "returned_tokens": 0, "calls": 0,
+            })
+            daily_rows = tool.get("daily") or []
+            if isinstance(daily_rows, dict):
+                daily_rows = daily_rows.values()
+            for daily in daily_rows:
+                if daily.get("day") not in day_keys:
+                    continue
+                row["returned_tokens"] += int(daily.get("output_tokens") or 0)
+                row["calls"] += int(daily.get("calls") or 0)
+    ranked = sorted(
+        (row for row in categories.values() if row["calls"] or row["returned_tokens"]),
+        key=lambda row: (-row["returned_tokens"], -row["calls"], row["name"]),
+    )[:limit]
+    return ranked, total_tokens, flagged_tokens
diff --git a/token_meter/app_helpers/capabilities.py b/token_meter/app_helpers/capabilities.py
new file mode 100644
index 00000000..30e28ff1
--- /dev/null
+++ b/token_meter/app_helpers/capabilities.py
@@ -0,0 +1,149 @@
+"""Skill and capability inventory helpers."""
+
+import glob
+import hashlib
+import json
+import os
+import re
+import secrets
+
+from token_meter.domain.tools import capability_control_groups as _domain_capability_control_groups
+from token_meter.app_helpers.common import SKILL_NAME_RE
+
+
+SKILL_PATH_RE = re.compile(r"(?:^|[/\\])([^/\\\s'\"]+)[/\\]SKILL\.md(?:\b|$)", re.IGNORECASE)
+
+
+_ACTION_TOKEN = secrets.token_urlsafe(24)
+
+
+_SKILL_EMPTY_CAPABILITY_VALUES = frozenset({"", "false", "null", "none", "~"})
+
+
+def _skill_frontmatter_key(value):
+    return str(value or "").strip().casefold().replace("_", "-")
+
+
+def _skill_frontmatter(path):
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            raw = fh.read(65536)
+    except OSError:
+        return {}
+    lines = raw.splitlines()
+    if not lines or lines[0].lstrip("\ufeff").strip() != "---":
+        return {}
+    closing = next((idx for idx, line in enumerate(lines[1:], 1) if line.strip() == "---"), None)
+    if closing is None:
+        return {}
+    fm = {}
+    current_key = None
+    for raw_line in lines[1:closing]:
+        stripped = raw_line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        if raw_line[:1].isspace():
+            if current_key and fm.get(current_key) == "":
+                fm[current_key] = "<nested-value>"
+            continue
+        m = re.match(r"^([A-Za-z0-9_.@+-]+)\s*:\s*(.*)", raw_line.rstrip())
+        if m:
+            key = m.group(1).strip()
+            val = re.sub(r"\s+#.*$", "", m.group(2)).strip()
+            normalized = val.casefold()
+            if normalized == "true":
+                fm[key] = True
+            elif normalized == "false":
+                fm[key] = False
+            else:
+                fm[key] = val
+            current_key = key
+        else:
+            current_key = None
+    return fm
+
+
+def _skill_capability_value_is_nonempty(value):
+    if value is True:
+        return True
+    if value is False or value is None:
+        return False
+    text = str(value).strip()
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in ("'", '"'):
+        text = text[1:-1].strip()
+    if text.casefold() in _SKILL_EMPTY_CAPABILITY_VALUES:
+        return False
+    if re.fullmatch(r"\[\s*\]|\{\s*\}", text):
+        return False
+    return True
+
+
+def skill_names_from_value(value, tool_name=""):
+    """Infer path-based loads and explicit native Skill-tool activations."""
+    try:
+        text = json.dumps(value, ensure_ascii=False, sort_keys=True)
+    except (TypeError, ValueError):
+        text = str(value or "")
+    names = {
+        match.group(1) for match in SKILL_PATH_RE.finditer(text)
+        if SKILL_NAME_RE.fullmatch(match.group(1))
+    }
+    tool_leaf = str(tool_name or "").rsplit(".", 1)[-1].casefold()
+    direct = value.get("skill") if tool_leaf == "skill" and isinstance(value, dict) else None
+    if isinstance(direct, str):
+        direct = direct.strip()
+        if SKILL_NAME_RE.fullmatch(direct):
+            names.add(direct.rsplit(":", 1)[-1])
+    return sorted(names)
+
+
+def _skill_dir_names(*roots):
+    names = set()
+    for root in roots:
+        for path in glob.glob(os.path.join(root, "*", "SKILL.md")):
+            names.add(os.path.basename(os.path.dirname(path)))
+    return names
+
+
+def skill_identity(runtime, name, origin_id, plugin_id=""):
+    """Return a stable identity that cannot collide across runtimes or origins."""
+    runtime_key = re.sub(r"[^a-z0-9]+", "-", str(runtime or "unknown").lower()).strip("-") or "unknown"
+    owner = str(plugin_id or origin_id or "unknown").strip()
+    return f"skill:{runtime_key}:{owner}:{name}"
+
+
+def capability_control_groups(mcp_items, skill_items):
+    return _domain_capability_control_groups(mcp_items, skill_items)
+
+
+def capability_content_revision(*parts):
+    """Return a stable revision for JSON-safe capability evidence."""
+    encoded = json.dumps(
+        parts, ensure_ascii=True, sort_keys=True, separators=(",", ":"),
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()[:20]
+
+
+def capability_summary_payload(capabilities):
+    """Return decision evidence without the heavy inventory rows."""
+    capabilities = capabilities or {}
+    payload = {key: value for key, value in capabilities.items() if key != "items"}
+    payload["inventory_count"] = len(capabilities.get("items") or [])
+    if isinstance(payload.get("claude_desktop"), dict):
+        payload["claude_desktop"] = {
+            key: value for key, value in payload["claude_desktop"].items() if key != "roots"
+        }
+    return payload
+
+
+def capability_action_capability():
+    return {
+        "token": _ACTION_TOKEN,
+        "skill_pack_toggle": True,
+    }
+
+
+def _capability_scan_label(coverage):
+    scanned = int(coverage.get("sessions_scanned") or 0)
+    total = coverage.get("sessions_total")
+    return f"{scanned} of {total}" if total is not None else f"{scanned}; discovery still running"
diff --git a/token_meter/app_helpers/claude_traces.py b/token_meter/app_helpers/claude_traces.py
new file mode 100644
index 00000000..193c2958
--- /dev/null
+++ b/token_meter/app_helpers/claude_traces.py
@@ -0,0 +1,312 @@
+"""Claude trace helpers used by the composition module."""
+
+import os
+from collections import defaultdict
+from urllib.parse import quote
+
+from token_meter.domain.usage import normalize_reported_token_count as _domain_normalize_reported_token_count
+from token_meter.quotas import anthropic as anthropic_quotas
+from token_meter.app_helpers.common import (
+    USER_TURN_CONTEXT_CHARS,
+    _CLAUDE_FAST_PREMIUM_RULES,
+    _close_claude_user_pauses,
+    _dedupe_user_turns,
+    _same_path,
+    _track_claude_user_pause,
+    _wait_sample,
+    compact_text,
+    observable_output_chars,
+    parse_iso,
+    tool_result_is_error,
+)
+
+
+def _claude_user_prompt(obj):
+    if obj.get("type") != "user":
+        return False
+    msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+    content = msg.get("content")
+    if isinstance(content, str):
+        return bool(content.strip())
+    if not isinstance(content, list):
+        return False
+    return any(
+        isinstance(block, dict)
+        and block.get("type") == "text"
+        and str(block.get("text") or "").strip()
+        for block in content
+    )
+
+
+def _claude_effective_duration(group, duration_s, timing_basis):
+    """Remove trace-visible human-response pauses from observed wall time."""
+    duration_s = float(duration_s or 0)
+    paused_s = float((group or {}).get("user_pause_s") or 0)
+    excluded_s = min(duration_s, paused_s) if timing_basis == "observed" else 0.0
+    return max(0.0, duration_s - excluded_s), excluded_s
+
+
+_CLAUDE_FAST_STANDARD_RULES = frozenset(("claude-opus-4-6",))
+
+
+_CLAUDE_INFERENCE_GEO_RULES = frozenset((
+    "claude-mythos-5", "claude-mythos-5-1",
+    "claude-fable-5", "claude-fable-5-1",
+    "claude-opus-5-5", "claude-opus-5", "claude-opus-4-8", "claude-opus-4-7",
+    "claude-opus-4-6", "claude-sonnet-5-5", "claude-sonnet-5",
+    "claude-sonnet-4-6", "claude-haiku-5-5",
+))
+
+
+def _claude_quote_supports_dimensions(usage, quote):
+    if not quote.available or not usage.get("billing_available"):
+        return False
+    matched_rule = quote.matched_rule
+    if (usage.get("speed") == "fast" and
+            matched_rule not in (
+                _CLAUDE_FAST_PREMIUM_RULES | _CLAUDE_FAST_STANDARD_RULES
+            )):
+        return False
+    if (usage.get("inference_geo") in ("global", "us") and
+            matched_rule not in _CLAUDE_INFERENCE_GEO_RULES):
+        return False
+    return True
+
+
+def claude_wait_samples(objs):
+    """Return completed Claude prompt-to-response wait samples.
+
+    Wait time is deliberately end to end: reasoning, tool use, and model output
+    all count because the user is still waiting for the turn to finish.
+    """
+    samples = []
+    current = None
+
+    def close_turn(end_ts=0, duration_ms=0, allow_observed=False):
+        nonlocal current
+        group = current
+        current = None
+        if not group:
+            return
+        try:
+            duration_ms = float(duration_ms or 0)
+        except (TypeError, ValueError):
+            duration_ms = 0
+        if duration_ms > 0:
+            duration_s = duration_ms / 1000.0
+            basis = "reported"
+        elif allow_observed:
+            end_ts = end_ts or group.get("last_ts") or 0
+            duration_s = float(end_ts or 0) - float(group.get("start_ts") or 0)
+            basis = "observed"
+        else:
+            return
+        wall_duration_s = duration_s
+        duration_s, user_pause_s = _claude_effective_duration(group, duration_s, basis)
+        sample = _wait_sample(group, end_ts or group.get("last_ts") or 0,
+                              duration_s, basis, "claude", wall_duration_s, user_pause_s)
+        if sample:
+            samples.append(sample)
+
+    for obj in objs:
+        otype = obj.get("type")
+        ts = parse_iso(obj.get("timestamp", "")) or 0
+        if _claude_user_prompt(obj):
+            close_turn(allow_observed=bool(current and current.get("terminal")))
+            current = {
+                "start_ts": ts, "last_ts": ts, "models": set(),
+                "tool_ids": set(), "tool_calls": 0, "output_tokens": 0,
+                "seen_usage": set(), "terminal": False,
+                "user_pause_starts": {}, "user_pause_s": 0.0,
+            }
+            continue
+        if otype == "user" and current:
+            msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+            _close_claude_user_pauses(current, msg, ts)
+            current["last_ts"] = max(float(current.get("last_ts") or 0), ts)
+            continue
+        if otype == "assistant" and current:
+            msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+            model = msg.get("model")
+            if model:
+                current["models"].add(model)
+            current["last_ts"] = max(float(current.get("last_ts") or 0), ts)
+            message_id = msg.get("id") or obj.get("uuid")
+            if message_id not in current["seen_usage"]:
+                current["seen_usage"].add(message_id)
+                output_tokens, _ = _domain_normalize_reported_token_count(
+                    (msg.get("usage") or {}).get("output_tokens")
+                )
+                current["output_tokens"] += output_tokens
+            for block in msg.get("content") or []:
+                if not isinstance(block, dict) or block.get("type") != "tool_use":
+                    continue
+                tool_id = block.get("id") or (block.get("name"), len(current["tool_ids"]))
+                current["tool_ids"].add(tool_id)
+                _track_claude_user_pause(current, block, ts)
+            current["tool_calls"] = len(current["tool_ids"])
+            if msg.get("stop_reason") and msg.get("stop_reason") != "tool_use":
+                current["terminal"] = True
+            continue
+        if otype == "system" and obj.get("subtype") == "turn_duration":
+            close_turn(ts, obj.get("durationMs"), allow_observed=True)
+    if current and current.get("terminal"):
+        close_turn(current.get("last_ts") or 0, allow_observed=True)
+    return samples
+
+
+def claude_user_text(msg):
+    content = msg.get("content") if isinstance(msg, dict) else None
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    pieces = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        btype = block.get("type")
+        if btype in (None, "text"):
+            pieces.append(block.get("text") or block.get("content") or "")
+    return " ".join(p for p in pieces if isinstance(p, str))
+
+
+def _claude_human_text(obj):
+    """Return human-authored Claude text, None for tool/meta/user-shaped records."""
+    if obj.get("type") != "user" or obj.get("isMeta") or obj.get("isSidechain"):
+        return None
+    if obj.get("sourceToolAssistantUUID") or obj.get("toolUseResult") is not None:
+        return None
+    msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+    content = msg.get("content")
+    if isinstance(content, list):
+        text_blocks = [
+            block.get("text") or block.get("content") or ""
+            for block in content
+            if isinstance(block, dict) and block.get("type") in (None, "text")
+        ]
+        if not text_blocks and any(
+            isinstance(block, dict) and block.get("type") == "tool_result" for block in content
+        ):
+            return None
+        text = " ".join(value for value in text_blocks if isinstance(value, str))
+    elif isinstance(content, str):
+        text = content
+    else:
+        text = ""
+    stripped = text.strip()
+    meta_prefixes = (
+        "<local-command-caveat>", "<local-command-stdout>",
+        "<command-name>", "<system-reminder>",
+    )
+    if stripped.startswith(meta_prefixes):
+        return None
+    return text
+
+
+def claude_user_turns(objs, default_model=None):
+    turns = []
+    pending = []
+    current_model = default_model or "unknown-model"
+    context = ""
+    for obj in objs or []:
+        text = _claude_human_text(obj)
+        if text is not None:
+            turn = {
+                "ts": parse_iso(obj.get("timestamp", "")) or 0,
+                "text": text,
+                "model": None,
+                "context": context,
+            }
+            turns.append(turn)
+            pending.append(turn)
+            continue
+        if obj.get("type") != "assistant":
+            continue
+        msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+        content = msg.get("content")
+        if isinstance(content, list) and not obj.get("isSidechain"):
+            said = " ".join(
+                block.get("text") or "" for block in content
+                if isinstance(block, dict) and block.get("type") == "text"
+                and isinstance(block.get("text"), str)
+            ).strip()
+            if said:
+                context = said[-USER_TURN_CONTEXT_CHARS:]
+        model = msg.get("model") or current_model
+        current_model = model
+        if pending:
+            for turn in pending:
+                turn["model"] = model
+            pending = []
+    for turn in pending:
+        turn["model"] = current_model
+    return _dedupe_user_turns(turns)
+
+
+def claude_user_events(objs):
+    events = []
+    for obj in objs:
+        if obj.get("type") != "user":
+            continue
+        msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+        txt = compact_text(claude_user_text(msg), 220)
+        if txt:
+            events.append({"ts": parse_iso(obj.get("timestamp", "")) or 0, "text": txt})
+    return sorted(events, key=lambda e: e["ts"])
+
+
+def claude_tool_results(objs):
+    chars_by_id = defaultdict(int)
+    ts_by_id = {}
+    errors_by_id = defaultdict(bool)
+    for obj in objs:
+        if obj.get("type") != "user":
+            continue
+        msg = obj.get("message") if isinstance(obj.get("message"), dict) else {}
+        content = msg.get("content")
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "tool_result":
+                tid = block.get("tool_use_id")
+                chars_by_id[tid] += observable_output_chars(block.get("content", ""))
+                ts_by_id[tid] = parse_iso(obj.get("timestamp", ""))
+                errors_by_id[tid] = errors_by_id[tid] or tool_result_is_error(
+                    block.get("content"), block.get("is_error") is True
+                )
+    return chars_by_id, ts_by_id, errors_by_id
+
+
+def claude_desktop_access_entry(launcher):
+    env = {"TOKEN_METER_CALLER": "claude"}
+    # Electron's spawn refuses .cmd/.bat without a shell, so Windows launchers go through cmd.exe.
+    if str(launcher).lower().endswith((".cmd", ".bat")):
+        return {"command": "cmd.exe", "args": ["/c", launcher], "env": env}
+    return {"command": launcher, "args": [], "env": env}
+
+
+def _claude_desktop_entry_matches(row, launcher):
+    if not isinstance(row, dict):
+        return False
+    env = row.get("env")
+    args = row.get("args", [])
+    if not isinstance(env, dict) or str(env.get("TOKEN_METER_CALLER") or "") != "claude" or not isinstance(args, list):
+        return False
+    expected = claude_desktop_access_entry(launcher)
+    if expected["command"] == "cmd.exe":
+        return (os.path.basename(str(row.get("command") or "")).lower() in ("cmd", "cmd.exe")
+                and len(args) == 2 and str(args[0]).lower() == "/c" and _same_path(args[1], launcher))
+    return _same_path(row.get("command"), launcher) and args == []
+
+
+def _claude_part_todo(part, enabled):
+    return bool(part.get("detected") and ((not part.get("connected")) if enabled else part.get("configured")))
+
+
+def _claude_app_stuck(app):
+    return bool(app.get("unreadable") or app.get("app_running"))
+
+
+def _claude_window(field, raw, kind, label, duration, now=None):
+    return anthropic_quotas._window(field, raw, kind, label, duration, now=now)
diff --git a/token_meter/app_helpers/codex_traces.py b/token_meter/app_helpers/codex_traces.py
new file mode 100644
index 00000000..40e9ae21
--- /dev/null
+++ b/token_meter/app_helpers/codex_traces.py
@@ -0,0 +1,382 @@
+"""Codex trace helpers used by the composition module."""
+
+import json
+import os
+import re
+import time
+
+from token_meter.domain.usage import normalize_reported_token_count as _domain_normalize_reported_token_count
+from token_meter.domain import work_evidence as _work_evidence
+from token_meter.quotas.common import quota_http_json
+from token_meter.quotas import openai as openai_quotas
+from token_meter.app_helpers.common import (
+    USER_TURN_CONTEXT_CHARS,
+    _dedupe_user_turns,
+    _wait_sample,
+    parse_iso,
+    text_from_content,
+    usage_io_tokens,
+)
+
+
+CODEX_AUTH = os.path.expanduser("~/.codex/auth.json")
+
+
+def codex_id_from_path(path, meta=None):
+    if meta and meta.get("session_id"):
+        return meta["session_id"]
+    base = os.path.basename(path).rsplit(".", 1)[0]
+    match = re.search(r"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})", base)
+    return match.group(1) if match else base
+
+
+def codex_performance_samples(objs, default_model=None):
+    """Return completed Codex task samples with model-attributable timing."""
+    model = default_model or "unknown-model"
+    samples = []
+    current = None
+
+    def ensure_current(ts=0):
+        nonlocal current
+        if current is None:
+            current = {"started_ts": ts or 0, "usage": {}, "tool_calls": 0}
+        return current
+
+    def close_task(payload, ts):
+        nonlocal current
+        task = current
+        current = None
+        if not task or len(task["usage"]) != 1:
+            return
+        duration_ms = payload.get("duration_ms")
+        ttft_ms = payload.get("time_to_first_token_ms")
+        try:
+            duration_ms = float(duration_ms or 0)
+            ttft_ms = float(ttft_ms or 0)
+        except (TypeError, ValueError):
+            return
+        if duration_ms <= 0:
+            return
+        sample_model, counts = next(iter(task["usage"].items()))
+        output_tokens = int(counts.get("output_tokens") or 0)
+        if output_tokens <= 0:
+            return
+        duration_s = duration_ms / 1000.0
+        generation_s = (duration_ms - ttft_ms) / 1000.0 if 0 < ttft_ms < duration_ms else duration_s
+        samples.append({
+            "provider": "codex", "model": sample_model,
+            "day": time.strftime("%Y-%m-%d", time.localtime(ts)) if ts else "",
+            "ts": ts or 0, "input_tokens": int(counts.get("input_tokens") or 0),
+            "output_tokens": output_tokens, "duration_s": duration_s,
+            "peak_input_tokens": int(counts.get("peak_input_tokens") or 0),
+            "uncached_input_tokens": int(counts.get("uncached_input_tokens") or 0),
+            "cache_read_tokens": int(counts.get("cache_read_tokens") or 0),
+            "cache_write_tokens": int(counts.get("cache_write_tokens") or 0),
+            "model_calls": int(counts.get("model_calls") or 0),
+            "generation_s": generation_s, "ttft_s": max(0.0, ttft_ms / 1000.0),
+            "tool_calls": int(task.get("tool_calls") or 0), "timing_basis": "task_complete",
+        })
+
+    for obj in objs:
+        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+        ptype = payload.get("type")
+        ts = parse_iso(obj.get("timestamp", "")) or 0
+        if obj.get("type") == "turn_context":
+            model = payload.get("model") or model
+            continue
+        if ptype == "task_started":
+            current = {"started_ts": ts, "usage": {}, "tool_calls": 0}
+            continue
+        if ptype in ("function_call", "custom_tool_call", "web_search_call", "tool_search_call"):
+            ensure_current(ts)["tool_calls"] += 1
+            continue
+        if ptype == "token_count":
+            raw = ((payload.get("info") or {}).get("last_token_usage") or {})
+            if not raw:
+                continue
+            usage = codex_usage(raw)
+            task = ensure_current(ts)
+            row = task["usage"].setdefault(model, {
+                "input_tokens": 0, "output_tokens": 0, "peak_input_tokens": 0,
+                "uncached_input_tokens": 0, "cache_read_tokens": 0,
+                "cache_write_tokens": 0, "model_calls": 0,
+            })
+            input_count, output_count = usage_io_tokens(usage)
+            row["input_tokens"] += input_count
+            row["output_tokens"] += output_count
+            row["peak_input_tokens"] = max(row["peak_input_tokens"], input_count)
+            row["uncached_input_tokens"] += int(usage.get("input_tokens") or 0)
+            row["cache_read_tokens"] += int(usage.get("cache_read_input_tokens") or 0)
+            row["cache_write_tokens"] += int(usage.get("cache_creation_input_tokens") or 0)
+            row["model_calls"] += 1
+            continue
+        if ptype == "task_complete":
+            close_task(payload, ts)
+    return samples
+
+
+def codex_live_performance_summary(objs):
+    """Return provisional pace from completed checkpoints in the active task.
+
+    Final throughput remains gated on ``task_complete`` in
+    ``codex_performance_samples``. This separate summary lets the native menu
+    show useful progress sooner without admitting an unfinished task into
+    historical/model analytics. The denominator stops at the latest completed
+    token checkpoint, so the displayed value changes only when another step
+    completes rather than decaying while a tool is still running.
+    """
+    current = None
+
+    for obj in objs:
+        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+        ptype = payload.get("type")
+        ts = parse_iso(obj.get("timestamp", "")) or 0
+        if ptype == "task_started":
+            current = {
+                "started_ts": ts,
+                "latest_checkpoint_ts": 0,
+                "output_tokens": 0,
+                "completed_steps": 0,
+            }
+            continue
+        if ptype == "task_complete":
+            current = None
+            continue
+        if ptype != "token_count" or not current:
+            continue
+        raw = ((payload.get("info") or {}).get("last_token_usage") or {})
+        if not raw:
+            continue
+        output_tokens = usage_io_tokens(codex_usage(raw))[1]
+        if output_tokens <= 0 or not ts:
+            continue
+        current["output_tokens"] += output_tokens
+        current["completed_steps"] += 1
+        current["latest_checkpoint_ts"] = max(
+            float(current.get("latest_checkpoint_ts") or 0), ts,
+        )
+
+    empty = {
+        "available": False,
+        "output_tps": 0,
+        "basis": "unavailable",
+        "completed_steps": 0,
+        "measured_output_tokens": 0,
+        "measured_seconds": 0,
+    }
+    if not current:
+        return empty
+    started_ts = float(current.get("started_ts") or 0)
+    checkpoint_ts = float(current.get("latest_checkpoint_ts") or 0)
+    measured_seconds = checkpoint_ts - started_ts
+    measured_output = int(current.get("output_tokens") or 0)
+    completed_steps = int(current.get("completed_steps") or 0)
+    if measured_seconds <= 0 or measured_output <= 0 or completed_steps <= 0:
+        return empty
+    return {
+        "available": True,
+        "output_tps": measured_output / measured_seconds,
+        "basis": "live_end_to_end",
+        "completed_steps": completed_steps,
+        "measured_output_tokens": measured_output,
+        "measured_seconds": measured_seconds,
+    }
+
+
+def codex_wait_samples(objs, default_model=None):
+    """Return completed Codex task prompt-to-response wait samples."""
+    samples = []
+    model = default_model or "unknown-model"
+    current = None
+
+    def close_task(end_ts=0, duration_ms=0, allow_observed=False):
+        nonlocal current
+        group = current
+        current = None
+        if not group:
+            return
+        try:
+            duration_ms = float(duration_ms or 0)
+        except (TypeError, ValueError):
+            duration_ms = 0
+        if duration_ms > 0:
+            duration_s = duration_ms / 1000.0
+            basis = "reported"
+        elif allow_observed:
+            end_ts = end_ts or group.get("last_ts") or 0
+            duration_s = float(end_ts or 0) - float(group.get("start_ts") or 0)
+            basis = "observed"
+        else:
+            return
+        sample = _wait_sample(group, end_ts or group.get("last_ts") or 0,
+                              duration_s, basis, "codex")
+        if sample:
+            samples.append(sample)
+
+    for obj in objs:
+        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+        ptype = payload.get("type")
+        ts = parse_iso(obj.get("timestamp", "")) or 0
+        if obj.get("type") == "turn_context":
+            model = payload.get("model") or model
+            if current:
+                current["models"].add(model)
+            continue
+        if ptype == "task_started":
+            close_task(allow_observed=False)
+            current = {
+                "start_ts": ts, "last_ts": ts, "models": {model},
+                "tool_calls": 0, "output_tokens": 0,
+            }
+            continue
+        if not current:
+            continue
+        current["last_ts"] = max(float(current.get("last_ts") or 0), ts)
+        if ptype in ("function_call", "custom_tool_call", "web_search_call", "tool_search_call"):
+            current["tool_calls"] += 1
+            continue
+        if ptype == "token_count":
+            raw = ((payload.get("info") or {}).get("last_token_usage") or {})
+            if raw:
+                current["output_tokens"] += usage_io_tokens(codex_usage(raw))[1]
+            continue
+        if ptype == "task_complete":
+            close_task(ts, payload.get("duration_ms"), allow_observed=True)
+    return samples
+
+
+def codex_usage(raw):
+    raw = raw or {}
+    input_total, input_reported = _domain_normalize_reported_token_count(
+        raw.get("input_tokens")
+    )
+    cached, cache_reported = _domain_normalize_reported_token_count(
+        raw.get("cached_input_tokens", 0)
+    )
+    output_tokens, output_reported = _domain_normalize_reported_token_count(
+        raw.get("output_tokens")
+    )
+    total_tokens, _ = _domain_normalize_reported_token_count(
+        raw.get("total_tokens", 0)
+    )
+    input_available = input_reported and cache_reported and cached <= input_total
+    reasoning_tokens, reasoning_available = _domain_normalize_reported_token_count(
+        raw.get("reasoning_output_tokens")
+    )
+    reasoning_available = (
+        output_reported
+        and reasoning_available
+        and reasoning_tokens <= output_tokens
+    )
+    return {
+        "input_tokens": max(0, input_total - cached) if input_available else 0,
+        "cache_creation_input_tokens": 0,
+        "cache_read_input_tokens": cached if input_available else 0,
+        "output_tokens": output_tokens if output_reported else 0,
+        "input_available": input_available,
+        "output_available": output_reported,
+        "reasoning_output_tokens": reasoning_tokens if reasoning_available else 0,
+        "reasoning_available": reasoning_available,
+        "total_tokens": total_tokens,
+    }
+
+
+def _codex_fallback_user_text(payload):
+    if payload.get("type") != "message" or payload.get("role") != "user":
+        return None
+    content = payload.get("content")
+    blocks = content if isinstance(content, list) else [content]
+    human_blocks = []
+    for block in blocks:
+        text = text_from_content([block] if isinstance(content, list) else block)
+        stripped = text.strip()
+        if not stripped or stripped.startswith((
+                "<recommended_plugins>",
+                "# AGENTS.md instructions",
+                "<environment_context>",
+        )):
+            continue
+        human_blocks.append(text)
+    return "\n".join(human_blocks) if human_blocks else None
+
+
+def codex_user_turns(objs, default_model=None):
+    """Prefer canonical user_message events; fall back for older Codex logs."""
+    current_model = default_model or "unknown-model"
+    event_turns = []
+    fallback_turns = []
+    context = ""
+    for obj in objs or []:
+        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+        if obj.get("type") == "turn_context":
+            current_model = payload.get("model") or current_model
+            continue
+        ts = parse_iso(obj.get("timestamp", "")) or 0
+        if payload.get("type") == "agent_message" and isinstance(payload.get("message"), str):
+            if payload["message"].strip():
+                context = payload["message"].strip()[-USER_TURN_CONTEXT_CHARS:]
+            continue
+        if payload.get("type") == "message" and payload.get("role") == "assistant":
+            # Current Codex rollouts carry assistant text only as response_item messages.
+            said = text_from_content(payload.get("content")).strip()
+            if said:
+                context = said[-USER_TURN_CONTEXT_CHARS:]
+            continue
+        if payload.get("type") == "user_message":
+            event_turns.append({"ts": ts, "text": payload.get("message") or "",
+                                "model": current_model, "context": context})
+            continue
+        text = _codex_fallback_user_text(payload)
+        if text is not None:
+            fallback_turns.append({"ts": ts, "text": text, "model": current_model, "context": context})
+    return _dedupe_user_turns(event_turns or fallback_turns)
+
+
+def codex_work_actions(objs):
+    """Tool calls in a Codex rollout as Work evidence, including tools called from code-mode scripts."""
+    actions = []
+    for obj in objs or ():
+        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+        ptype = payload.get("type")
+        if ptype not in ("function_call", "custom_tool_call", "local_shell_call", "web_search_call"):
+            continue
+        ts = parse_iso(obj.get("timestamp", "")) or 0
+        name = str(payload.get("name") or "")
+        if ptype == "web_search_call":
+            actions.append(_work_evidence.tool_action("web_search", None, ts))
+        elif ptype == "local_shell_call":
+            action = payload.get("action") if isinstance(payload.get("action"), dict) else {}
+            actions.append(_work_evidence.tool_action("shell", {"command": action.get("command")}, ts))
+        elif ptype == "custom_tool_call" and name == "exec":
+            actions.extend(_work_evidence.code_actions(payload.get("input"), ts))
+        elif ptype == "function_call" and name == "js":
+            arguments = payload.get("arguments")
+            try:
+                code = json.loads(arguments).get("code") if isinstance(arguments, str) else None
+            except (ValueError, AttributeError):
+                code = None
+            actions.extend(_work_evidence.code_actions(code or arguments, ts))
+        else:
+            actions.append(_work_evidence.tool_action(name, payload.get("arguments") or payload.get("input"), ts))
+    return actions
+
+
+def codex_approval_policy_label(value):
+    """Return a compact label for legacy strings and structured Codex policies."""
+    if isinstance(value, dict):
+        value = next(iter(value), "")
+    return str(value or "").replace("_", " ")
+
+
+def _codex_limit_label(value):
+    return openai_quotas.limit_label(value)
+
+
+def _codex_window(provider_id, raw, kind, label, now=None):
+    return openai_quotas._window(provider_id, raw, kind, label, now=now)
+
+
+def codex_oauth_quota(now=None, opener=None):
+    return openai_quotas.oauth_quota(
+        CODEX_AUTH, quota_http_json, now=now, opener=opener
+    )
diff --git a/token_meter/app_helpers/common.py b/token_meter/app_helpers/common.py
new file mode 100644
index 00000000..88dc204e
--- /dev/null
+++ b/token_meter/app_helpers/common.py
@@ -0,0 +1,2112 @@
+"""Shared leaf helpers extracted from the composition module."""
+
+import calendar
+import contextlib
+import datetime
+import functools
+import hashlib
+import json
+import math
+import os
+import queue
+import random
+import re
+import secrets
+import socketserver
+import stat
+import statistics
+import time
+from http.server import ThreadingHTTPServer
+
+from token_meter import dashboard_page
+from token_meter.contracts import EvidenceBasis, ModelRef, PriceQuery, PriceQuote
+from token_meter.domain.usage import make_usage_provenance as _domain_make_usage_provenance, metric_available as _domain_metric_available, usage_io_token_counts as _domain_usage_io_token_counts, usage_provenance as _domain_usage_provenance, usage_token_total_counts as _domain_usage_token_total_counts
+from token_meter.domain.aggregates import add_model_daily as _domain_add_model_daily, add_model_summary as _domain_add_model_summary, current_session_summaries as _domain_current_session_summaries, daily_summaries as _domain_daily_summaries, metric_coverage as _domain_metric_coverage, monthly_summaries as _domain_monthly_summaries, spend_log_summaries as _domain_spend_log_summaries, spend_projection as _domain_spend_projection
+from token_meter.domain.compare import trace_key as _compare_trace_key
+from token_meter.domain.insights import enrich_insights as _domain_enrich_insights, execution_low_yield as _domain_execution_low_yield, insight as _domain_insight, insight_sort_key as _domain_insight_sort_key, is_operational_warning as _domain_is_operational_warning, low_yield_should_warn as _domain_low_yield_should_warn
+from token_meter.domain.timing import merge_execution_intervals as _domain_merge_execution_intervals, performance_summary as _domain_performance_summary, wait_time_summary as _domain_wait_time_summary
+from token_meter.domain.tools import optional_capability_summary as _domain_optional_capability_summary, summarize_tool_evidence as _domain_summarize_tool_evidence, tool_identity as _domain_tool_identity, tool_summary as _domain_tool_summary
+from token_meter.services import work_insights as _work
+from token_meter.domain import work_evidence as _work_evidence
+from token_meter.domain.work import TAG_ORDER as _domain_work_tags
+from token_meter.models.catalog import ANTHROPIC_PRICE as CLAUDE_PRICE, BUILTIN_MODEL_PRICE_HISTORY as _CANONICAL_BUILTIN_MODEL_PRICE_HISTORY, CURSOR_PRICE, DEFAULT_MODELS as _DEFAULT_MODELS, GOOGLE_PRICE, OPENAI_PRICE, canonical_model_provider
+from token_meter.models.pricing import matching_price as _catalog_matching_price
+from token_meter.models import discounts as _discounts
+from token_meter.quotas import anthropic as anthropic_quotas
+from token_meter.quotas.common import quota_provider
+from token_meter.quotas import cursor as cursor_quotas
+from token_meter.quotas import openai as openai_quotas
+from token_meter.runtimes.opencode import context_tokens as _native_opencode_context_tokens, decode_json as _native_opencode_json, display_cost as _native_opencode_display_cost, distribute_cost as _native_opencode_distribute, int_value as _native_opencode_int, reported_cost as _native_opencode_reported_cost, usage_counts as _native_opencode_usage
+from token_meter.runtimes.agy import default_brain_dir as _default_agy_brain_dir
+from token_meter.runtimes.path_cache import BoundedPathCache
+
+
+MAX_PROJECT_SKILL_ROOTS = 64
+
+
+CLAUDE_ROOT_CONFIG = os.path.expanduser("~/.claude.json")
+
+
+CLAUDE_CREDENTIALS = os.path.expanduser("~/.claude/.credentials.json")
+
+
+_opencode_db_override = os.path.expanduser(os.environ.get("OPENCODE_DB", ""))
+
+
+def hermes_state_db_path(environ=None):
+    environ = os.environ if environ is None else environ
+    state_db = str(environ.get("HERMES_STATE_DB") or "").strip()
+    home = str(environ.get("HERMES_HOME") or "").strip() or "~/.hermes"
+    return os.path.abspath(os.path.expanduser(state_db or os.path.join(home, "state.db")))
+
+
+def agy_brain_dir_path(environ=None):
+    return _default_agy_brain_dir(os.path.expanduser("~"), environ)
+
+
+TOKEN_METER_SESSION_MODEL_IDENTITIES = os.path.expanduser(
+    os.environ.get(
+        "TOKEN_METER_SESSION_MODEL_IDENTITIES",
+        "~/.token-meter/session-model-identities.json",
+    )
+)
+
+
+TOKEN_METER_UPDATE_STATUS = os.path.expanduser(
+    os.environ.get("TOKEN_METER_UPDATE_STATUS", "~/.token-meter/update-status.json")
+)
+
+
+TOKEN_METER_GIT_DELIVERY_DB = os.path.expanduser(
+    os.environ.get("TOKEN_METER_GIT_DELIVERY_DB", "~/.token-meter/git-delivery.sqlite3")
+)
+
+
+TOKEN_METER_MCP_EVIDENCE_CACHE = os.path.expanduser(
+    os.environ.get(
+        "TOKEN_METER_MCP_EVIDENCE_CACHE",
+        "~/.token-meter/mcp-evidence-cache.json",
+    )
+)
+
+
+MAX_CUSTOM_MODEL_PRICES = 100
+
+
+MAX_MODEL_PRICE_PERIODS = 256
+
+
+MAX_MODEL_PRICE_CHANGES = 256
+
+
+MODEL_PRICING_MTIME_TTL_S = 0.25
+
+
+MAX_SESSION_MODEL_IDENTITIES = 2_048
+
+
+HERMES_MODEL_IDENTITY_LABEL = "Bedrock application profile"
+
+
+BUDGET_PROVIDERS = ("claude", "codex", "cursor", "opencode", "kiro", "pi", "hermes", "agy")
+
+
+# Runtimes whose character-count cost estimates run far below real cost (#91):
+# budgets still show them, but budget notifications are measured without them.
+BUDGET_ALERT_EXCLUDED_ESTIMATE_PROVIDERS = ("agy",)
+
+
+# Runtimes whose session storage Token Meter must never move or delete.
+READ_ONLY_SESSION_PROVIDERS = ("opencode", "hermes", "agy")
+
+
+GIT_DELIVERY_INTERVAL_S = 5 * 60
+
+
+UPDATE_FETCH_TIMEOUT_S = 45
+
+
+# Comfortably past the installer's default 600-second readiness wait.
+UPDATE_STALE_AFTER_S = 30 * 60
+
+
+UPDATE_REF_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._/-]{1,199}$")
+
+
+# Compatibility re-exports retain the existing runtime-oriented names while
+# their authoritative data now lives in the model-provider catalog.
+BUILTIN_MODEL_PRICE_HISTORY = {
+    "codex": _CANONICAL_BUILTIN_MODEL_PRICE_HISTORY["openai"],
+}
+
+
+DEFAULT_CLAUDE_MODEL = _DEFAULT_MODELS["anthropic"]
+
+
+DEFAULT_OPENAI_MODEL = _DEFAULT_MODELS["openai"]
+
+
+CHARS_PER_TOKEN = 4
+
+
+TRACE_LIMIT = 220
+
+
+EXEC_LIMIT = 180
+
+
+QUOTA_REFRESH_S = 60.0
+
+
+QUOTA_STALE_S = 10 * 60.0
+
+
+QUOTA_HTTP_TIMEOUT_S = 8.0
+
+
+QUOTA_PROCESS_TIMEOUT_S = 8.0
+
+
+LOW_YIELD_RATIO = 0.005
+
+
+LOW_YIELD_COST = 0.05
+
+
+LOW_YIELD_CONTEXT_PCT = 0.25
+
+
+LOW_YIELD_INPUT_TOKENS = 60000
+
+
+TOOL_OVERSIZED_TOKENS = 8000
+
+
+PLUGIN_ID_RE = re.compile(r"^[A-Za-z0-9_.@:/-]{1,180}$")
+
+
+SKILL_NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,179}$")
+
+
+DATA_URL_RE = re.compile(r"data:image/[^;\s]+;base64,[A-Za-z0-9+/=]+")
+
+
+BASE64_FIELD_RE = re.compile(r'("(?:data|image_url)"\s*:\s*")([A-Za-z0-9+/=]{512,})(")')
+
+
+_XSESS_TTL = 15.0
+
+
+_XSESS_LIVE_REFRESH_S = _XSESS_TTL
+
+
+_CURRENT_SESSION_REBUILD_S = 1.5
+
+
+_SOURCE_MEMBERSHIP_PROBE_S = 2.0
+
+
+_SOURCE_MEMBERSHIP_FALLBACK_S = 4.0
+
+
+_SOURCE_DISCOVERY_REFRESH_S = 10.0
+
+
+CURRENT_SESSION_MAX_AGE_S = 30 * 60
+
+
+CURRENT_SESSION_WORKING_S = 90
+
+
+CURRENT_SESSION_LIMIT = 200
+
+
+CURRENT_SESSION_CONTEXT_SAMPLES = 32
+
+
+SESSION_STATE_CACHE_LIMIT = 32
+
+
+MODEL_PROJECT_OPTION_LIMIT = 500
+
+
+OTHER_LOCAL_SESSIONS_PROJECT = "__other_local_sessions__"
+
+
+_matched_pace_cache = {"signature": None, "data": None}
+
+
+# One entry per model-runtime pair for the global (all-session) scope, so a
+# changed model only rebuilds the pairs it participates in. Reused across
+# restarts via TOKEN_METER_MATCHED_PACE_CACHE. Loaded, read, mutated, and saved
+# only by the thread holding the single-flight build flag below; it is never
+# touched by project-scoped builds.
+_matched_pace_pair_cache = {}
+
+
+_matched_pace_build_state = {"building": False}
+
+
+# Bump whenever the matching algorithm, thresholds, result fields, or pair-key
+# format change, so stale persisted comparisons are discarded on load.
+MATCHED_PACE_CACHE_SCHEMA = 2
+
+
+_SKILL_CATALOG_TTL_S = 60.0
+
+
+_skill_catalog_cache = {"rows": None, "at": 0.0}
+
+
+_session_state_cache = {}
+
+
+_session_state_build_locks = {}
+
+
+_recursive_path_cache = BoundedPathCache(ttl_seconds=4.0, max_entries=64)
+
+
+_model_pricing_cache = {
+    "path": None, "mtime_ns": None, "mtime_checked_at": 0.0,
+    "histories": {}, "effective": {}, "quotes": {},
+}
+
+
+_quota_cache = {}
+
+
+_quota_inflight = set()
+
+
+AGENT_ACCESS_SERVER = "tokenmeter"
+
+
+AGENT_CURRENT_MAX_AGE_S = 6 * 60 * 60
+
+
+_ISO_UTC_SUFFIX_RE = re.compile(r"(?:[Zz]|[+-]00:?00)$")
+
+
+def parse_iso(ts):
+    """Parse a trace timestamp; anything that is not a string is undated (None).
+
+    The guard runs before the cache, so a list or dict value (unhashable) can
+    never raise and stop a build.
+    """
+    if not isinstance(ts, str):
+        return None
+    return _parse_iso_text(ts)
+
+
+@functools.lru_cache(maxsize=65536)
+def _parse_iso_text(ts):
+    # Logs are UTC (trailing Z). calendar.timegm treats the struct as UTC, so
+    # idle/elapsed line up with time.time(). A whole-second stamp ending in Z
+    # (or +00:00) is the same instant; other forms keep their existing result.
+    text = ts.split(".")[0]
+    if len(text) > 19:
+        text = _ISO_UTC_SUFFIX_RE.sub("", text)
+    try:
+        return calendar.timegm(time.strptime(text, "%Y-%m-%dT%H:%M:%S"))
+    except Exception:
+        return None
+
+
+# The cached string parser stays observable through the public name.
+parse_iso.cache_clear = _parse_iso_text.cache_clear
+
+
+parse_iso.cache_info = _parse_iso_text.cache_info
+
+
+def local_dt(ts):
+    return time.strftime("%Y-%m-%d %I:%M:%S %p", time.localtime(ts)).lower() if ts else ""
+
+
+def local_tm(ts):
+    return time.strftime("%H:%M:%S", time.localtime(ts)) if ts else ""
+
+
+def duration_label(seconds):
+    seconds = int(seconds or 0)
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, sec = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {sec:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes:02d}m"
+
+
+def _merge_execution_intervals(intervals):
+    """Return wall-active seconds after collapsing overlapping execution windows."""
+    return _domain_merge_execution_intervals(intervals)
+
+
+def _is_user_input_tool(name):
+    """Return whether a tool explicitly pauses the agent for human input."""
+    normalized = re.sub(r"[^a-z0-9]", "", str(name or "").lower())
+    return normalized in ("askuserquestion", "requestuserinput")
+
+
+def _track_claude_user_pause(group, block, ts):
+    if not group or not isinstance(block, dict) or block.get("type") != "tool_use":
+        return
+    if not _is_user_input_tool(block.get("name")):
+        return
+    tool_id = block.get("id")
+    if tool_id:
+        group.setdefault("user_pause_starts", {}).setdefault(tool_id, float(ts or 0))
+
+
+def _close_claude_user_pauses(group, message, ts):
+    if not group or not isinstance(message, dict):
+        return
+    starts = group.setdefault("user_pause_starts", {})
+    for block in message.get("content") or []:
+        if not isinstance(block, dict) or block.get("type") != "tool_result":
+            continue
+        started = starts.pop(block.get("tool_use_id"), None)
+        if started is not None and float(ts or 0) >= started:
+            group["user_pause_s"] = float(group.get("user_pause_s") or 0) + float(ts or 0) - started
+
+
+OBSOLETE_SETTINGS_KEYS = ("language_signal_terms", "frustration_terms")
+
+
+def sweep_orphaned_atomic_writes(path):
+    """Remove temp files a killed writer of ``path`` left behind (its process is gone)."""
+    # Signal 0 probes liveness only on POSIX; on Windows ``os.kill`` delivers it.
+    if os.name != "posix":
+        return 0
+    directory = os.path.dirname(path)
+    prefix = f".{os.path.basename(path)}.token-meter-"
+    try:
+        names = os.listdir(directory)
+    except OSError:
+        return 0
+    removed = 0
+    for name in names:
+        if not name.startswith(prefix):
+            continue
+        pid_text, _separator, suffix = name[len(prefix):].partition("-")
+        if not (pid_text.isascii() and pid_text.isdecimal()) or not suffix:
+            continue
+        pid = int(pid_text)
+        if pid == os.getpid():
+            continue
+        try:
+            os.kill(pid, 0)
+            continue
+        except ProcessLookupError:
+            pass
+        except (PermissionError, OSError, OverflowError):
+            continue
+        candidate = os.path.join(directory, name)
+        try:
+            if os.path.islink(candidate) or not os.path.isfile(candidate):
+                continue
+            os.unlink(candidate)
+            removed += 1
+        except OSError:
+            continue
+    return removed
+
+
+def builtin_model_price_tables():
+    return {
+        "claude": CLAUDE_PRICE,
+        "codex": OPENAI_PRICE,
+        "cursor": CURSOR_PRICE,
+        "opencode": {},
+        "google": GOOGLE_PRICE,
+    }
+
+
+def _same_model_price_action(left, right):
+    if not left or not right:
+        return False
+    for key in ("prices", "use_builtin", "inactive"):
+        if key in left or key in right:
+            return left.get(key) == right.get(key)
+    return False
+
+
+def _last_model_price(periods):
+    for revision in reversed(periods or ()):
+        if "prices" in revision:
+            return revision["prices"]
+    return None
+
+
+def _has_scheduled_builtin_prices(provider, model):
+    """Return whether a bundled model's price changes on a scheduled date."""
+    history = _CANONICAL_BUILTIN_MODEL_PRICE_HISTORY.get(canonical_model_provider(provider), {})
+    return model in history
+
+
+COST_DISCOUNTS_SETTINGS_KEY = "cost_discounts"
+
+
+COST_DISCOUNT_READ_ONLY_ERRORS = {
+    "newer_version": "Discounts were saved by a newer Token Meter.",
+    "unsupported_format": "Discounts in settings.json can't be changed by this version.",
+}
+
+
+MAX_COST_DISCOUNT_OPS = 64
+
+
+_COST_DISCOUNT_SERVER_FIELDS = frozenset((
+    "source", "set_by", "updated_at", "start_iso", "end_iso", "updated_at_iso",
+))
+
+
+_COST_DISCOUNT_RULE_FIELDS = frozenset((
+    "id", "external_id", "price_list", "channel", "percent", "start", "end", "label",
+))
+
+
+_cost_discount_cache = {"path": None, "mtime_ns": None, "checked_at": 0.0, "state": None}
+
+
+def _reset_cost_discount_cache():
+    _cost_discount_cache.update(path=None, mtime_ns=None, checked_at=0.0, state=None)
+
+
+def discount_of(value):
+    """Return the discount carried by a priced figure, or 0 for a plain one."""
+    return float(getattr(value, "discount_usd", 0.0) or 0.0)
+
+
+def _public_cost_discount_rule(rule):
+    public = dict(rule)
+    public["start_iso"] = _discounts.iso_timestamp(rule.get("start"))
+    public["end_iso"] = _discounts.iso_timestamp(rule.get("end"))
+    public["updated_at_iso"] = _discounts.iso_timestamp(rule.get("updated_at"))
+    return public
+
+
+def _new_cost_discount_id(taken):
+    while True:
+        rule_id = "d_" + secrets.token_hex(6)
+        if rule_id not in taken:
+            return rule_id
+
+
+def _discount_rule_content(rule):
+    return {field: rule.get(field) for field in _discounts.CONTENT_FIELDS}
+
+
+def _submitted_discount_fields(raw):
+    if not isinstance(raw, dict):
+        raise ValueError("Each discount must be an object.")
+    unknown = sorted(set(raw) - _COST_DISCOUNT_RULE_FIELDS - _COST_DISCOUNT_SERVER_FIELDS, key=str)
+    if unknown:
+        raise ValueError("Unknown field: {}".format(str(unknown[0])[:40]))
+    return {key: value for key, value in raw.items() if key in _COST_DISCOUNT_RULE_FIELDS}
+
+
+def _merge_discount_rule(raw, existing, taken_ids, now, source, set_by, scope=None):
+    """Merge one submitted rule over the rule it matches; unchanged keeps the original."""
+    submitted = _submitted_discount_fields(raw)
+    merged = {
+        field: existing[field] for field in _discounts.CONTENT_FIELDS
+        if existing and field in existing
+    }
+    for field in _discounts.CONTENT_FIELDS:
+        if field in submitted:
+            merged[field] = submitted[field]
+    if scope is not None:
+        for field, value in zip(("price_list", "channel"), scope):
+            supplied = submitted.get(field)
+            if supplied is not None and str(supplied).strip().lower() != value:
+                raise ValueError("A replaced schedule may only contain its own discounts.")
+            merged[field] = value
+    merged["id"] = existing["id"] if existing else _new_cost_discount_id(taken_ids)
+    candidate = _discounts.normalize_rule({
+        **merged, "source": source, "set_by": set_by, "updated_at": now,
+    })
+    if existing and _discount_rule_content(candidate) == _discount_rule_content(
+            _discounts.normalize_rule(existing)):
+        return existing
+    return candidate
+
+
+def _matched_discount(rules, raw):
+    """Return the index of the rule a submission names, or ``None`` to create one."""
+    if not isinstance(raw, dict):
+        raise ValueError("Each discount must be an object.")
+    rule_id = raw.get("id")
+    if rule_id not in (None, ""):
+        for position, rule in enumerate(rules):
+            if rule["id"] == rule_id:
+                return position
+        raise ValueError("No discount has that id.")
+    external_id = raw.get("external_id")
+    if external_id not in (None, ""):
+        for position, rule in enumerate(rules):
+            if rule.get("external_id") == external_id:
+                return position
+    return None
+
+
+def _discount_scope(op):
+    price_list = str(op.get("price_list") or "").strip().lower()
+    if price_list not in _discounts.PRICE_LISTS:
+        raise ValueError("Choose Anthropic, OpenAI, Cursor, Kiro, or OpenCode.")
+    channel = op.get("channel")
+    channel = _discounts.ANY_CHANNEL if channel is None else str(channel).strip().lower()
+    if channel not in _discounts.RULE_CHANNELS:
+        raise ValueError("Choose who bills you: the provider, AWS Bedrock, Google Vertex, Microsoft Azure, or anyone.")
+    if price_list in _discounts.FIXED_CHANNEL_PRICE_LISTS and channel != _discounts.ANY_CHANNEL:
+        raise ValueError("{} discounts apply however it is billed.".format(
+            _discounts.PRICE_LIST_LABELS[price_list]))
+    return price_list, channel
+
+
+_COST_DISCOUNT_OP_FIELDS = {
+    "delete": frozenset(("op", "id", "external_id")),
+    "replace_scope": frozenset(("op", "price_list", "channel", "rules")),
+    "set_runtime_channels": frozenset(("op", "runtime_channels", *_discounts.RUNTIME_CHANNEL_KEYS)),
+}
+
+
+def _reject_unknown_op_fields(op, kind):
+    allowed = _COST_DISCOUNT_OP_FIELDS.get(kind)
+    if kind == "upsert" and "rule" in op:
+        allowed = frozenset(("op", "rule"))
+    if allowed is None:
+        return
+    unknown = sorted((key for key in op if key not in allowed), key=str)
+    if unknown:
+        raise ValueError("Unknown field: {}".format(str(unknown[0])[:40]))
+
+
+def _op_removes_stored_entry(op, raw):
+    """Whether a delete or replace_scope names a preserved invalid stored entry."""
+    if not isinstance(op, dict) or not isinstance(raw, dict):
+        return False
+    if op.get("op") == "delete":
+        return any(op.get(key) not in (None, "") and op.get(key) == raw.get(key)
+                   for key in ("id", "external_id"))
+    if op.get("op") == "replace_scope":
+        channel = raw.get("channel")
+        return (str(raw.get("price_list") or "").strip().lower() == str(op.get("price_list") or "").strip().lower()
+                and str(channel if channel is not None else "any").strip().lower()
+                == str(op.get("channel") if op.get("channel") is not None else "any").strip().lower())
+    return False
+
+
+def _apply_cost_discount_op(rules, channels, op, now, source, set_by):
+    if not isinstance(op, dict):
+        raise ValueError("Each discount change must be an object.")
+    kind = op.get("op")
+    _reject_unknown_op_fields(op, kind)
+    taken = {rule["id"] for rule in rules}
+    if kind == "upsert":
+        raw = op.get("rule") if "rule" in op else {
+            key: value for key, value in op.items() if key != "op"
+        }
+        position = _matched_discount(rules, raw)
+        existing = rules[position] if position is not None else None
+        merged = _merge_discount_rule(raw, existing, taken, now, source, set_by)
+        if position is None:
+            rules.append(merged)
+        else:
+            rules[position] = merged
+        return
+    if kind == "delete":
+        rule_id, external_id = op.get("id"), op.get("external_id")
+        if rule_id in (None, "") and external_id in (None, ""):
+            raise ValueError("Delete needs an id or external id.")
+        rules[:] = [
+            rule for rule in rules
+            if not ((rule_id not in (None, "") and rule["id"] == rule_id)
+                    or (external_id not in (None, "") and rule.get("external_id") == external_id))
+        ]
+        return
+    if kind == "replace_scope":
+        scope = _discount_scope(op)
+        submitted = op.get("rules")
+        if not isinstance(submitted, list) or len(submitted) > _discounts.MAX_RULES_PER_SCOPE:
+            raise ValueError("A schedule needs a list of at most {} discounts.".format(
+                _discounts.MAX_RULES_PER_SCOPE))
+        in_scope = [rule for rule in rules if (rule["price_list"], rule["channel"]) == scope]
+        outside = [rule for rule in rules if (rule["price_list"], rule["channel"]) != scope]
+        replacement = []
+        for raw in submitted:
+            position = _matched_discount(in_scope, raw)
+            existing = in_scope[position] if position is not None else None
+            if existing is not None and any(rule is existing for rule in replacement):
+                raise ValueError("A schedule lists the same discount twice.")
+            replacement.append(_merge_discount_rule(
+                raw, existing, taken | {rule["id"] for rule in replacement},
+                now, source, set_by, scope=scope,
+            ))
+        rules[:] = outside + replacement
+        return
+    if kind == "set_runtime_channels":
+        values = op.get("runtime_channels") if "runtime_channels" in op else {
+            key: value for key, value in op.items() if key != "op"
+        }
+        if not isinstance(values, dict) or not values:
+            raise ValueError("Choose how each Claude app is billed.")
+        updated = _discounts.normalize_runtime_channels(values, strict=True)
+        for key in values:
+            channels[key] = updated[key]
+        return
+    raise ValueError("Discount changes must be upsert, delete, replace_scope, or set_runtime_channels.")
+
+
+_pricing_state = {"cache_revision": None, "fingerprint_key": None, "fingerprint": None}
+
+
+_pricing_recalc = {"running": False, "pending": False, "thread": None}
+
+
+_API_TOKEN_RE = re.compile(r"^[A-Za-z0-9_-]{32,128}$")
+
+
+def _write_api_token(path, token):
+    directory = os.path.dirname(path)
+    os.makedirs(directory, exist_ok=True)
+    tmp = os.path.join(directory, ".{}.token-meter-{}".format(
+        os.path.basename(path), secrets.token_hex(8)))
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    try:
+        with os.fdopen(fd, "w", encoding="ascii") as fh:
+            fh.write(token + "\n")
+            fh.flush()
+            os.fsync(fh.fileno())
+        os.chmod(tmp, 0o600)
+        os.replace(tmp, path)
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(tmp)
+
+
+BUDGET_API_FIELDS = ("allocations", "thresholds", "native_notifications", "default_session_budget")
+
+
+def _public_budget_settings(settings):
+    """Budget settings for the local API; session ids never leave the server."""
+    return {
+        "currency": settings["currency"],
+        "allocations": {provider: settings["allocations"][provider] for provider in BUDGET_PROVIDERS},
+        "monthly_total": settings["monthly_total"],
+        "thresholds": list(settings["thresholds"]),
+        "native_notifications": settings["native_notifications"],
+        "default_session_budget": settings["default_session_budget"],
+    }
+
+
+def budget_settings_revision(settings):
+    canonical = json.dumps(_public_budget_settings(settings), sort_keys=True, separators=(",", ":"))
+    return "b_" + hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:16]
+
+
+INVALID_STORED_BUDGETS_ERROR = "Stored budgets are invalid; fix them in Token Meter first."
+
+
+def _opaque_session_identity_key(value, namespace):
+    value = str(value or "").strip()
+    if not value or len(value) > 512:
+        return ""
+    return hashlib.sha256(
+        (str(namespace) + "\0" + value).encode("utf-8")
+    ).hexdigest()
+
+
+def session_model_identity_key(source):
+    """Return an opaque, physical-trace-scoped key without retaining its ID."""
+    if not isinstance(source, dict):
+        return ""
+    if source.get("provider") == "codex":
+        return _opaque_session_identity_key(
+            source.get("physical_trace_id"), "token-meter-codex-session-v1",
+        )
+    if source.get("provider") == "hermes":
+        return _opaque_session_identity_key(
+            source.get("id"), "token-meter-hermes-session-v1",
+        )
+    return ""
+
+
+def _session_model_identity_parent_key(parent_id):
+    return _opaque_session_identity_key(
+        parent_id, "token-meter-codex-parent-v1",
+    )
+
+
+def _session_model_identity_revision(source):
+    signature = file_signature(str((source or {}).get("path") or ""))
+    if not signature:
+        return None
+    return tuple(str(value) for value in signature)
+
+
+def _verified_identity_matches_source(verified, source):
+    if not verified:
+        return False
+    return (
+        tuple(verified.get("revision") or ())
+        == _session_model_identity_revision(source)
+    )
+
+
+def _apply_verified_session_identity(source, verified):
+    source["model"] = verified["model"]
+    source["model_provider"] = verified["model_provider"]
+    source["_verified_inherited_prefix"] = verified["inherited_prefix"]
+    source["_verified_inherited_prefix_revision"] = list(verified["revision"])
+
+
+_settings_file_locks = {}
+
+
+_goal_evidence_cache = {"key": None, "value": None}
+
+
+_goal_cache = {"signature": None, "built_at": 0.0,
+               "native": {"ready": False, "items": [], "additional_count": 0}}
+
+
+GOAL_NATIVE_REFRESH_S = 60.0
+
+
+NOTIFICATIONS_SCHEMA_VERSION = 1
+
+
+NOTIFICATION_EVALUATE_INTERVAL_S = 2.0
+
+
+_notification_runtime = {"evaluated_at": None, "quota_established": False, "hints_reseed": True}
+
+
+_PUBLIC_EVENT_FIELDS = ("id", "kind", "severity", "title", "body", "link", "created_at", "claimed", "claimed_by")
+
+
+WORK_PAUSE_CHOICES = ("1h", "tomorrow", "indefinite", "resume")
+
+
+WORK_INSIGHTS_UNSUPPORTED_ERROR = "Work insights are available on macOS only."
+
+
+def _pause_until(choice, now=None):
+    now = time.time() if now is None else now
+    if choice == "resume":
+        return None
+    if choice == "indefinite":
+        return "indefinite"
+    if choice == "1h":
+        return now + 3600
+    local = datetime.datetime.fromtimestamp(now)
+    tomorrow = (local + datetime.timedelta(days=1)).replace(hour=6, minute=0, second=0, microsecond=0)
+    return tomorrow.timestamp()
+
+
+def _safe_update_revision(value):
+    value = str(value or "").strip().lower()
+    return value if re.fullmatch(r"[0-9a-f]{7,40}", value) else ""
+
+
+def _safe_update_int(value):
+    try:
+        return max(0, int(value or 0))
+    except (TypeError, ValueError):
+        return 0
+
+
+def file_signature(path):
+    """Return a cheap cache key that changes when a trace is replaced or appended."""
+    try:
+        stat = os.stat(path)
+    except OSError:
+        return None
+    return stat.st_mtime_ns, stat.st_size
+
+
+def home_shorten(path):
+    home = os.path.expanduser("~")
+    return path.replace(home, "~", 1) if path and path.startswith(home) else path
+
+
+def metric_availability(provider, **overrides):
+    """Describe which normalized metrics are backed by the provider trace.
+
+    Missing availability remains backward compatible elsewhere, but every new
+    state carries this object so unavailable Cursor billing values cannot look
+    like measured zeroes.
+    """
+    if provider == "cursor":
+        result = {
+            "cost": False,
+            "tokens": False,
+            "input_tokens": False,
+            "output_tokens": False,
+            "cache": False,
+            "throughput": False,
+            "context": False,
+            "timing": False,
+            "tool_results": False,
+        }
+    else:
+        result = {
+            "cost": True,
+            "tokens": True,
+            "input_tokens": True,
+            "output_tokens": True,
+            "cache": True,
+            "throughput": True,
+            "context": True,
+            "timing": True,
+            "tool_results": True,
+        }
+    result.update({key: bool(value) for key, value in overrides.items() if key in result})
+    return result
+
+
+def metric_available(row, metric):
+    """Treat absent availability as available for legacy states and fixtures."""
+    return _domain_metric_available(row, metric)
+
+
+def make_usage_provenance(session_ids, estimated_ids=(), available_ids=None,
+                          estimated_cost=0.0, estimated_tokens=0):
+    """Describe evidence quality separately from metric coverage."""
+    return _domain_make_usage_provenance(
+        session_ids,
+        estimated_ids,
+        available_ids,
+        estimated_cost,
+        estimated_tokens,
+    )
+
+
+def usage_provenance(rows):
+    """Roll up reported versus local-estimate sessions without changing coverage."""
+    return _domain_usage_provenance(rows)
+
+
+def decode_claude_project(name):
+    user = os.environ.get("USER", "")
+    prefix = "-Users-" + user
+    if user and name.startswith(prefix):
+        name = "~" + name[len(prefix):]
+    return name.strip("-").replace("-", "/").replace("~/", "~/")
+
+
+def decode_cursor_project(name):
+    """Best-effort fallback for Cursor's lossy project directory encoding."""
+    user = os.environ.get("USER", "")
+    prefix = f"Users-{user}-" if user else ""
+    if prefix and name.startswith(prefix):
+        return home_shorten("/Users/" + user + "/" + name[len(prefix):].replace("-", "/"))
+    return name.replace("-", "/") if name else ""
+
+
+def catalog_counts(catalog):
+    advertised = len(catalog or [])
+    deferred = sum(1 for row in catalog or [] if row.get("defer_loading"))
+    return {"advertised": advertised, "eager": max(0, advertised - deferred), "deferred": deferred}
+
+
+_claude_native_adapters = {}
+
+
+_cursor_native_adapters = {}
+
+
+_kiro_native_adapters = {}
+
+
+_agy_native_adapters = {}
+
+
+_opencode_adapter_key = {"configured": None, "key": None}
+
+
+def _opencode_json(value, default=None):
+    """Decode one OpenCode SQLite JSON text value without failing the session."""
+    return _native_opencode_json(value, default)
+
+
+def reset_cursor_metadata_cache():
+    for adapter in _cursor_native_adapters.values():
+        adapter.reset_metadata_cache()
+
+
+def git_delivery_project_roots(sources):
+    """Return ordered unique normalized roots relevant to Git candidate selection."""
+    roots = []
+    seen = set()
+    for source in sources or ():
+        raw_project = source.get("project") if isinstance(source, dict) else ""
+        if not isinstance(raw_project, str):
+            continue
+        if project_filter_key(raw_project) == OTHER_LOCAL_SESSIONS_PROJECT:
+            continue
+        root = os.path.abspath(os.path.expanduser(raw_project))
+        if root not in seen:
+            roots.append(root)
+            seen.add(root)
+    return tuple(roots)
+
+
+def git_delivery_source_signature(roots):
+    """Return a private ordered-root membership signature for Git candidates."""
+    return hashlib.sha256(
+        "\0".join(roots).encode("utf-8", "replace"),
+    ).hexdigest()
+
+
+def _matching_price(model, table):
+    _rule, price = _catalog_matching_price(model, table)
+    return price
+
+
+@functools.lru_cache(maxsize=2048)
+def _cached_price_query(model_provider, model_id, variant, timestamp):
+    observed_at = (
+        None if timestamp is None else
+        datetime.datetime.fromtimestamp(timestamp, datetime.timezone.utc)
+    )
+    return PriceQuery(
+        ModelRef(model_provider, model_id, variant),
+        observed_at,
+    )
+
+
+# OpenCode message rows carry the upstream provider that served the model.
+# Only direct vendor identities may reuse that vendor's public catalog; the
+# OpenCode and OpenCode Go aggregators keep their own (possibly negotiated)
+# rates and never borrow a vendor price.
+OPENCODE_UPSTREAM_MODEL_PROVIDERS = {
+    "anthropic": "anthropic",
+    "openai": "openai",
+    "cursor": "cursor",
+}
+
+
+_CLAUDE_FAST_PREMIUM_RULES = frozenset((
+    "claude-opus-5-5", "claude-opus-5", "claude-opus-4-8",
+))
+
+
+@functools.lru_cache(maxsize=1024)
+def _compat_price_quote(provider_id, model_id, variant, input_price, output_price,
+                        cache_read_price, cache_write_price):
+    return PriceQuote(
+        model=ModelRef(provider_id, model_id, variant or None),
+        input_per_million=input_price,
+        output_per_million=output_price,
+        cache_read_per_million=cache_read_price,
+        cache_write_per_million=cache_write_price,
+        basis=EvidenceBasis.ESTIMATED,
+        matched_rule=None,
+    )
+
+
+def usage_tokens(u):
+    return _domain_usage_token_total_counts(
+        u.get("input_tokens", 0),
+        u.get("output_tokens", 0),
+        u.get("cache_read_input_tokens", 0),
+        u.get("cache_creation_input_tokens", 0),
+    )
+
+
+def usage_io_tokens(u):
+    """Return total trace-reported input, including cache, and output."""
+    return _domain_usage_io_token_counts(
+        u.get("input_tokens", 0),
+        u.get("output_tokens", 0),
+        u.get("cache_read_input_tokens", 0),
+        u.get("cache_creation_input_tokens", 0),
+    )
+
+
+def add_model_summary(stats, model, usage, cost, cost_available=None, discount=None):
+    """Accumulate one request; ``discount`` defaults to the one ``cost`` carries."""
+    return _domain_add_model_summary(
+        stats, model, usage, cost, cost_available=cost_available,
+        discount=discount_of(cost) if discount is None else discount,
+    )
+
+
+def add_model_daily(stats, model, usage, cost, ts, cost_available=None, discount=None):
+    """Accumulate exact trace-reported model I/O into local calendar days."""
+    return _domain_add_model_daily(
+        stats, model, usage, cost, ts, cost_available=cost_available,
+        discount=discount_of(cost) if discount is None else discount,
+    )
+
+
+def _wait_sample(group, end_ts, duration_s, timing_basis, provider,
+                 wall_duration_s=None, user_pause_s=0.0):
+    """Return one completed prompt-to-response wall-clock sample."""
+    if not group or duration_s <= 0:
+        return None
+    models = sorted(name for name in (group.get("models") or set()) if name)
+    model = models[0] if len(models) == 1 else ("mixed" if models else "unknown")
+    return {
+        "provider": provider,
+        "model": model,
+        "day": time.strftime("%Y-%m-%d", time.localtime(end_ts)) if end_ts else "",
+        "ts": end_ts or 0,
+        "start_ts": float(group.get("start_ts") or 0),
+        "duration_s": float(duration_s),
+        "tool_calls": int(group.get("tool_calls") or 0),
+        "output_tokens": int(group.get("output_tokens") or 0),
+        "timing_basis": timing_basis,
+        "wall_duration_s": float(wall_duration_s if wall_duration_s is not None else duration_s),
+        "user_pause_s": float(user_pause_s or 0),
+    }
+
+
+def wait_time_summary(samples):
+    return _domain_wait_time_summary(samples)
+
+
+def performance_summary(samples, total_output_tokens=0):
+    return _domain_performance_summary(samples, total_output_tokens)
+
+
+def tool_identity(name):
+    return _domain_tool_identity(name)
+
+
+def trace_event(ts, kind, label, detail="", execution=None, tool=None, tokens=0, cost=0.0, severity="neutral", **meta):
+    event = {
+        "ts": ts or 0,
+        "time": local_tm(ts),
+        "local": local_dt(ts),
+        "kind": kind,
+        "label": label,
+        "detail": detail,
+        "execution": execution,
+        "tool": tool,
+        "tokens": int(tokens or 0),
+        "cost": round(cost or 0.0, 6),
+        "severity": severity,
+    }
+    for key, value in meta.items():
+        if value is not None:
+            event[key] = value
+    return event
+
+
+def trim_trace(trace):
+    return trace[-TRACE_LIMIT:]
+
+
+def compact_text(s, limit=72):
+    s = " ".join((s or "").split())
+    return s[:limit - 1] + "…" if len(s) > limit else s
+
+
+def text_from_content(content):
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        pieces = []
+        for block in content:
+            if isinstance(block, dict):
+                pieces.append(block.get("text") or block.get("content") or "")
+        return " ".join(p for p in pieces if isinstance(p, str))
+    return ""
+
+
+USER_TURN_CONTEXT_CHARS = 600
+
+
+def _dedupe_user_turns(turns, window_seconds=2.0):
+    result = []
+    for turn in turns:
+        fingerprint = " ".join(str(turn.get("text") or "").lower().split())
+        previous = result[-1] if result else None
+        if previous:
+            previous_fingerprint = " ".join(str(previous.get("text") or "").lower().split())
+            delta = abs(float(turn.get("ts") or 0) - float(previous.get("ts") or 0))
+            if fingerprint == previous_fingerprint and delta <= window_seconds:
+                continue
+        result.append(turn)
+    return result
+
+
+_WORK_TURNS_HANDOFF_KEY = "_work_turns_handoff"
+
+
+def pi_work_actions(turns):
+    """Tool calls in a Pi session as Work evidence, kept content-free.
+
+    Pi's adapter keeps only a normalized tool name and kind, never the call's
+    arguments, so each action carries the kind and its turn's timestamp and no
+    edited paths or command kinds.
+    """
+    actions = []
+    for turn in turns or ():
+        ts = float(turn.get("end") or turn.get("start") or 0)
+        for tool in turn.get("tools") or ():
+            actions.append(_work_evidence.tool_action(tool.get("name"), None, ts))
+    return actions
+
+
+def user_prompt_preview(texts, limit=220):
+    seen = set()
+    unique = []
+    for text in texts:
+        key = " ".join((text or "").split())
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        unique.append(text)
+    return compact_text(" / ".join(unique), limit)
+
+
+def execution_low_yield(execution):
+    return _domain_execution_low_yield(execution)
+
+
+def low_yield_should_warn(executions, context_pct=0):
+    return _domain_low_yield_should_warn(executions, context_pct)
+
+
+def is_operational_warning(insight):
+    return _domain_is_operational_warning(insight)
+
+
+INSIGHT_CATEGORY_ORDER = {
+    "Context": 0,
+    "Yield": 1,
+    "Spend": 2,
+    "Tools": 3,
+    "Cache": 4,
+    "Reasoning": 5,
+    "Flow": 6,
+    "Pricing": 7,
+}
+
+
+INSIGHT_KIND_SCORE = {"warn": 0, "good": 1, "neutral": 2}
+
+
+def insight(key, kind, category, title, text, detail="", action="", priority=50):
+    return _domain_insight(key, kind, category, title, text, detail, action, priority)
+
+
+def insight_sort_key(row):
+    return _domain_insight_sort_key(row)
+
+
+def tool_summary(executions):
+    return _domain_tool_summary(executions)
+
+
+def tool_result_is_error(value, explicit=False):
+    if explicit:
+        return True
+    if isinstance(value, dict):
+        if value.get("is_error") is True or value.get("success") is False:
+            return True
+        status = str(value.get("status") or "").lower()
+        if status in ("error", "failed", "failure"):
+            return True
+        exit_code = value.get("exit_code", value.get("exitCode"))
+        if exit_code not in (None, 0, "0"):
+            return True
+        if value.get("error") not in (None, "", False):
+            return True
+        return any(tool_result_is_error(v) for v in value.values() if isinstance(v, (dict, list)))
+    if isinstance(value, list):
+        return any(tool_result_is_error(v) for v in value)
+    text = str(value or "").strip().lower()
+    return text.startswith(("error:", "failed:", "tool error", "process exited with code"))
+
+
+def observable_output_chars(value):
+    """Count trace-visible text while excluding embedded image/base64 bytes."""
+    try:
+        text = json.dumps(value, ensure_ascii=False, sort_keys=True)
+    except (TypeError, ValueError):
+        text = str(value or "")
+    text = DATA_URL_RE.sub("<image-data>", text)
+    text = BASE64_FIELD_RE.sub(r'\1<binary-data>\3', text)
+    return len(text)
+
+
+def argument_fingerprint(value):
+    try:
+        text = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    except (TypeError, ValueError):
+        text = str(value or "")
+    return hashlib.sha256(text.encode("utf-8", "replace")).hexdigest()[:16] if text else ""
+
+
+_SKILL_MEASURABLE_KEYS = frozenset({
+    "allowed-tools", "tools", "tool-schemas", "mcp-servers", "mcpservers",
+    "mcp", "requires-mcp", "requiresmcp",
+})
+
+
+def _opencode_int(value, default=0):
+    return _native_opencode_int(value, default)
+
+
+def _opencode_usage(data):
+    """Return OpenCode's five independent token components."""
+    return _native_opencode_usage(data)
+
+
+def _opencode_context_tokens(usage):
+    return _native_opencode_context_tokens(usage)
+
+
+def _opencode_reported_cost(data):
+    """Return (cost, available); a reported numeric zero remains available."""
+    return _native_opencode_reported_cost(data)
+
+
+# OpenCode records an authoritative total cost per message from its own
+# provider. No public rate table can cover arbitrary OpenCode backends, so
+# Token Meter distributes that exact total across the input / cache-write /
+# cache-read / output buckets using a documented token-weighted proxy that
+# preserves the authoritative total. The proxy does not invent cost.
+def _opencode_distribute(msg_cost, usage):
+    """Split one authoritative OpenCode-reported cost into five proxy buckets.
+
+    OpenCode records an authoritative total cost per message from its own
+    provider. No bundled rate table can cover arbitrary OpenCode backends, so
+    Token Meter distributes that exact total across the five independent token
+    components with a documented token-weighted proxy. The total is never
+    invented; only its category split is estimated.
+    """
+    return _native_opencode_distribute(msg_cost, usage)
+
+
+def _opencode_display_cost(breakdown):
+    """Fold reasoning into output for Token Meter's four-bucket UI contract."""
+    return _native_opencode_display_cost(breakdown)
+
+
+def enable_mcp_parallel_index():
+    """Let the MCP fill cold summaries and stat rows on the load-aware worker pool."""
+    global _parallel_index_enabled
+    _parallel_index_enabled = True
+
+
+def analysis_block(tot, total_cost, think_out, think_turns, think_cost, model_tok, model_cost,
+                   tool_data, side_cost, side_turns, completed):
+    tool_bloat = [{
+        "name": row["name"],
+        "calls": row["calls"],
+        "tokens": row["output_tokens"],
+        "chars": row["output_chars"],
+        "namespace": row["namespace"],
+        "kind": row["kind"],
+    } for row in tool_data["by_name"][:8]]
+    return {
+        "reasoning": {
+            "share": (think_out / tot["output"]) if tot["output"] else 0.0,
+            "think_turns": think_turns,
+            "tokens": think_out,
+            "cost": think_cost,
+        },
+        "model_mix": sorted(
+            [{"model": k, "tokens": model_tok[k], "cost": model_cost[k]} for k in model_tok],
+            key=lambda x: -x["cost"]),
+        "tool_bloat": tool_bloat,
+        "coordination": {
+            "share": (side_cost / total_cost) if total_cost else 0.0,
+            "turns": side_turns,
+            "cost": side_cost,
+        },
+        "cost_per_task": {
+            "completed": completed,
+            "per_task": (total_cost / completed) if completed else 0.0,
+        },
+    }
+
+
+def new_codex_pending():
+    return {"trace": [], "calls": {}, "has_reasoning": False, "start_ts": None,
+            "context_window": None, "user_inputs": [], "fallback_user_inputs": []}
+
+
+def enrich_insights(insights, executions, tool_data, context_window, context_latest,
+                    context_peak, provider):
+    return _domain_enrich_insights(
+        insights,
+        executions,
+        tool_data,
+        context_window,
+        context_latest,
+        context_peak,
+        provider,
+    )
+
+
+def summarize_tool_evidence(calls, catalog=None):
+    return _domain_summarize_tool_evidence(calls, catalog)
+
+
+def _cache_pricing_provider(facts):
+    provider = facts.get("pricing_provider")
+    if provider in ("claude", "codex", "cursor"):
+        return provider
+    model = str(facts.get("model") or "").lower()
+    if "claude" in model:
+        return "claude"
+    if re.match(r"(?:openai/)?(?:gpt-(?!oss)|o\d)", model):
+        return "codex"
+    return None
+
+
+def _is_child_agent_row(row):
+    """A row is a child run only when every agent record names a parent."""
+    records = [r for r in row.get("_agent_records") or () if isinstance(r, dict)]
+    return bool(records) and all(r.get("parent_id") for r in records)
+
+
+_index_worker_pressure = {"event": None, "yielding": False}
+
+
+def _system_load_average():
+    try:
+        return os.getloadavg()[0]
+    except (AttributeError, OSError):
+        return None
+
+
+def _source_size(source):
+    try:
+        return os.path.getsize(source.get("path") or "")
+    except (OSError, TypeError, ValueError):
+        return 0
+
+
+_shared_index_pool = {"owner": None, "pools": {}}
+
+
+def current_session_summaries(rows, now=None, max_age_s=CURRENT_SESSION_MAX_AGE_S,
+                              limit=CURRENT_SESSION_LIMIT):
+    return _domain_current_session_summaries(
+        rows,
+        now=now,
+        max_age_s=max_age_s,
+        limit=limit,
+        working_age_s=CURRENT_SESSION_WORKING_S,
+        context_sample_limit=CURRENT_SESSION_CONTEXT_SAMPLES,
+    )
+
+
+def folded_child_root_id(source):
+    """Return the root session id an additive child source folds into, if any.
+
+    Only OpenCode child sessions with a resolved root carry `agent_root_id`;
+    every other source returns an empty string and keeps its own identity.
+    """
+    if not isinstance(source, dict) or source.get("provider") != "opencode":
+        return ""
+    return str(source.get("agent_root_id") or "")
+
+
+def fold_child_source(selected, sources):
+    """Map a folded child source to its discovered root source, else keep it."""
+    root_id = folded_child_root_id(selected)
+    if not root_id:
+        return selected
+    for source in sources or ():
+        if (
+            source.get("provider") == selected.get("provider")
+            and str(source.get("id") or "") == root_id
+        ):
+            return source
+    return selected
+
+
+def newest_current_source(sources):
+    """Pick the live source, keeping a child run under its root session."""
+    rows = list(sources or ())
+    if not rows:
+        return None
+    newest = max(rows, key=lambda source: source.get("mtime") or 0)
+    return fold_child_source(newest, rows)
+
+
+_CONFIGURED_CAPABILITY_TTL_S = 60.0
+
+
+_configured_capability_cache = {}
+
+
+def optional_capability_summary(control_groups):
+    return _domain_optional_capability_summary(control_groups)
+
+
+@functools.lru_cache(maxsize=16384)
+def _trace_path_key(path):
+    return _compare_trace_key({"path": path})
+
+
+def _browser_session_row(row):
+    """Swap a trace path for the opaque compare key the dashboard selects by."""
+    if not isinstance(row, dict) or not row.get("path"):
+        return row
+    public = {key: value for key, value in row.items() if key != "path"}
+    public["key"] = _trace_path_key(str(row["path"]))
+    return public
+
+
+# Cross-session snapshots are replaced wholesale, never mutated, so one
+# encoding per snapshot object serves every poll until the next rebuild.
+# /state serves the published snapshot and /session the latest rebuild; they
+# differ while idle, so both stay encoded. The nonce keeps a page that
+# outlived a server restart from matching a fresh revision.
+_dashboard_cross_cache = {"serial": 0, "entries": []}
+
+
+_dashboard_cross_nonce = os.urandom(4).hex()
+
+
+_DASHBOARD_CROSS_SLOTS = 2
+
+
+_ABSENT = object()
+
+
+CLAUDE_DESKTOP_CLIENT = "claude_desktop"
+
+
+AGENT_ACCESS_CLIENTS = ("codex", "claude")
+
+
+def _same_path(left, right):
+    try:
+        resolve = lambda value: os.path.normcase(os.path.realpath(os.path.expanduser(str(value or ""))))
+        return resolve(left) == resolve(right)
+    except (OSError, ValueError):
+        return False
+
+
+def _config_stamp(path):
+    try:
+        stat = os.stat(path)
+    except FileNotFoundError:
+        return None
+    return stat.st_mtime_ns, stat.st_size
+
+
+CLAUDE_APP_RUNNING_ERROR = "Quit the Claude app first. It rewrites its config while open and would drop the change."
+
+
+CLAUDE_APP_UNREADABLE_ERROR = "Token Meter could not read the Claude app's MCP config, so it left the file unchanged."
+
+
+AGENT_SKILL_LABELS = {"codex": "Codex", "claude": "Claude Code"}
+
+
+def _verified_agent_access_change(client, enabled, repairing, status_getter, restart_hint):
+    after = status_getter(client)
+    verified = bool(after.get("connected")) if enabled else not bool(after.get("configured"))
+    if not verified:
+        return {"ok": False, "error": "The connection command completed, but the saved configuration could not be verified."}
+    label = after.get("label") or client
+    return {
+        "ok": True, "changed": True, "repaired": repairing, "client": after,
+        "restart_required": True,
+        "message": (f"{label} connection repaired. {restart_hint}"
+                    if repairing else
+                    f"{label} {'connected' if enabled else 'disconnected'}. {restart_hint}"),
+    }
+
+
+def daily_summaries(session_rows, limit=30):
+    return _domain_daily_summaries(
+        session_rows, limit=limit, availability_resolver=metric_availability,
+    )
+
+
+def spend_projection(daily_rows):
+    return _domain_spend_projection(daily_rows)
+
+
+def spend_log_summaries(session_rows, start_day, end_day):
+    return _domain_spend_log_summaries(
+        session_rows, start_day, end_day,
+        availability_resolver=metric_availability,
+    )
+
+
+def monthly_summaries(session_rows, limit=12):
+    return _domain_monthly_summaries(session_rows, limit=limit)
+
+
+MATCHED_PACE_MIN_PAIRS = 20
+
+
+MATCHED_PACE_MIN_COVERAGE = 0.30
+
+
+def _percentile(values, quantile):
+    if not values:
+        return 0.0
+    ordered = sorted(float(value) for value in values)
+    return ordered[min(len(ordered) - 1, max(0, int(round((len(ordered) - 1) * quantile))))]
+
+
+def _bootstrap_median_interval(values, seed_key, repetitions=400):
+    if not values:
+        return 0.0, 0.0
+    if len(values) == 1:
+        return float(values[0]), float(values[0])
+    seed = int(hashlib.sha256(str(seed_key).encode("utf-8")).hexdigest()[:16], 16)
+    rng = random.Random(seed)
+    # Bit-for-bit the draws of ``statistics.median(rng.choice(values) ...)``:
+    # ``choice`` is rejection sampling over ``getrandbits(n.bit_length())``,
+    # inlined here because the call layers dominated the build time.
+    getrandbits = rng.getrandbits
+    count = len(values)
+    bits = count.bit_length()
+    middle = count // 2
+    odd = count % 2
+    medians = []
+    for _ in range(repetitions):
+        drawn = []
+        for _ in range(count):
+            index = getrandbits(bits)
+            while index >= count:
+                index = getrandbits(bits)
+            drawn.append(values[index])
+        drawn.sort()
+        medians.append(drawn[middle] if odd else (drawn[middle - 1] + drawn[middle]) / 2)
+    return _percentile(medians, 0.025), _percentile(medians, 0.975)
+
+
+MATCHED_PACE_WINDOW_KEYS = (
+    "today", "yesterday", "7", "30", "90", "month", "last_month", "all",
+)
+
+
+_MATCHED_PACE_INT_FIELDS = ("a_samples", "b_samples", "matched_pairs")
+
+
+_MATCHED_PACE_FLOAT_FIELDS = ("coverage", "pace_ratio", "ci_low", "ci_high")
+
+
+_MATCHED_PACE_COMPARISON_KEYS = frozenset(
+    ("a_id", "b_id", "available", "reason")
+    + _MATCHED_PACE_INT_FIELDS + _MATCHED_PACE_FLOAT_FIELDS
+)
+
+
+# Stored numbers outside these bounds are corrupt; the pair is recomputed.
+_MATCHED_PACE_MAX_COUNT = 10 ** 9
+
+
+_MATCHED_PACE_MAX_RATIO = 1e15
+
+
+_MATCHED_PACE_MAX_REASON = 200
+
+
+# Every reason string matched_pace_comparison can produce.
+_MATCHED_PACE_REASON_RE = re.compile(
+    r"|needs \d{1,9} timed turns per runtime"
+    r"|only \d{1,9} comparable turns; needs \d{1,9}"
+    r"|only \d{1,9}% of the smaller history overlaps"
+)
+
+
+def _valid_matched_pace_comparison(value, a_id, b_id):
+    """Return a rebuilt comparison with exactly the builder keys, else None.
+
+    Never raises: magnitude checks run before any float conversion, so a huge
+    JSON integer cannot overflow. Unknown keys reject the comparison so stored
+    content can never reach API output beyond the builder's own fields.
+    """
+    if not isinstance(value, dict) or set(value) != _MATCHED_PACE_COMPARISON_KEYS:
+        return None
+    if value["a_id"] != a_id or value["b_id"] != b_id:
+        return None
+    for field in _MATCHED_PACE_INT_FIELDS:
+        number = value[field]
+        if (isinstance(number, bool) or not isinstance(number, int)
+                or not 0 <= number <= _MATCHED_PACE_MAX_COUNT):
+            return None
+    for field in _MATCHED_PACE_FLOAT_FIELDS:
+        number = value[field]
+        if isinstance(number, bool) or not isinstance(number, (int, float)):
+            return None
+        # Chained comparison is exact for ints of any size and rejects NaN.
+        if not 0 <= number <= _MATCHED_PACE_MAX_RATIO:
+            return None
+        if isinstance(number, float) and not math.isfinite(number):
+            return None
+    if not 0 <= value["coverage"] <= 1:
+        return None
+    if not isinstance(value["available"], bool):
+        return None
+    reason = value["reason"]
+    if (not isinstance(reason, str) or len(reason) > _MATCHED_PACE_MAX_REASON
+            or not _MATCHED_PACE_REASON_RE.fullmatch(reason)):
+        return None
+    return {key: value[key] for key in (
+        "a_id", "b_id", "a_samples", "b_samples", "matched_pairs", "coverage",
+        "pace_ratio", "ci_low", "ci_high", "available", "reason",
+    )}
+
+
+def _valid_matched_pace_entry(entry):
+    """Return the (key, cached) pair for a usable stored entry, else None."""
+    if not isinstance(entry, dict):
+        return None
+    a_id, b_id = entry.get("a_id"), entry.get("b_id")
+    signature, windows = entry.get("signature"), entry.get("windows")
+    if not (isinstance(a_id, str) and isinstance(b_id, str)
+            and isinstance(signature, str) and isinstance(windows, dict)):
+        return None
+    if set(windows) != set(MATCHED_PACE_WINDOW_KEYS):
+        return None
+    rebuilt = {}
+    for window in MATCHED_PACE_WINDOW_KEYS:
+        comparison = _valid_matched_pace_comparison(windows[window], a_id, b_id)
+        if comparison is None:
+            return None
+        rebuilt[window] = comparison
+    return (a_id, b_id), {"signature": signature, "windows": rebuilt}
+
+
+def _finalize_throughput_fields(row):
+    """Add weighted speed and coverage fields to a model or model/day row."""
+    tool_free_samples = int(row.get("tool_free_samples") or 0)
+    timed_samples = int(row.get("timed_samples") or 0)
+    if tool_free_samples and row.get("tool_free_seconds", 0) > 0:
+        speed_output = int(row.get("tool_free_output_tokens") or 0)
+        speed_seconds = float(row.get("tool_free_seconds") or 0)
+        basis = "tool_free"
+        sample_count = tool_free_samples
+    elif timed_samples and row.get("timed_seconds", 0) > 0:
+        speed_output = int(row.get("timed_output_tokens") or 0)
+        speed_seconds = float(row.get("timed_seconds") or 0)
+        basis = "end_to_end"
+        sample_count = timed_samples
+    else:
+        speed_output = 0
+        speed_seconds = 0.0
+        basis = "unavailable"
+        sample_count = 0
+    total_output = int(row.get("output_tokens") or 0)
+    row["output_tps"] = (speed_output / speed_seconds) if speed_seconds > 0 else 0
+    row["throughput_basis"] = basis
+    row["throughput_samples"] = sample_count
+    row["timing_coverage"] = (speed_output / total_output) if total_output > 0 else 0
+    ttft_samples = int(row.get("ttft_samples") or 0)
+    row["avg_ttft_ms"] = (float(row.get("ttft_total_s") or 0) * 1000 / ttft_samples) if ttft_samples else 0
+    wait_samples = int(row.get("wait_samples") or 0)
+    row["avg_wait_s"] = (float(row.get("wait_seconds") or 0) / wait_samples) if wait_samples else 0
+    durations = sorted(
+        float(value) for value in (row.get("wait_durations_s") or [])
+        if float(value or 0) > 0
+    )
+    p95_index = min(len(durations) - 1, max(0, math.ceil(len(durations) * 0.95) - 1)) if durations else 0
+    row["median_wait_s"] = statistics.median(durations) if durations else 0
+    row["p95_wait_s"] = durations[p95_index] if durations else 0
+    workload_fields = {
+        "workload_peak_inputs": "median_peak_input_tokens",
+        "workload_outputs": "median_workload_output_tokens",
+        "workload_tool_calls": "median_tool_calls",
+        "workload_model_calls": "median_model_calls",
+        "workload_cache_ratios": "median_cache_ratio",
+    }
+    for source_key, target_key in workload_fields.items():
+        values = [float(value) for value in (row.get(source_key) or []) if float(value or 0) >= 0]
+        row[target_key] = statistics.median(values) if values else 0
+    return row
+
+
+def project_filter_key(value):
+    """Keep project controls to folder-like paths; retain all other sessions together."""
+    project = str(value or "").strip().replace("\\", "/")
+    if (project.startswith("/") and not project.startswith("/private/")
+            or project.startswith("~/") and not project.startswith((
+                "~/.codex/", "~/Library/", "~/Documents/Codex/",
+            ))
+            or re.match(r"^[A-Za-z]:/", project)):
+        return project
+    return OTHER_LOCAL_SESSIONS_PROJECT
+
+
+_work_source_keys = {"sources": None, "salt": None, "keys": {}}
+
+
+WORK_DRILL_ENUMS = {
+    "work_type": set(_work.WORK_TYPES) | {"unclear"},
+    "complexity": {"routine", "everyday", "complex"},
+    "tier": {"light", "standard", "premium"},
+    "effort": {"default", "low", "medium", "high", "xhigh", "max", "ultra"},
+    "outcome": {"single_shot", "accepted", "recovered", "ended_on_pushback", "unclear", "pending"},
+    "tag": set(_domain_work_tags),
+}
+
+
+def _work_bucket_valid(value, grain):
+    if grain == "day":
+        if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
+            return False
+        try:
+            datetime.date.fromisoformat(value)
+        except ValueError:
+            return False
+        return True
+    return bool(re.fullmatch(r"\d{4}-(0[1-9]|1[0-2])", value))
+
+
+def _work_label_since(settings):
+    """First day the classifier labels, from the history setting; empty when it labels all history."""
+    days = settings.get("backfill_days") or 0
+    return (datetime.date.today() - datetime.timedelta(days=days)).isoformat() if days else ""
+
+
+def metric_coverage(rows, metric):
+    return _domain_metric_coverage(rows, metric)
+
+
+def _builder_recap_line_count(value, maximum=(1 << 53) - 1):
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int):
+        return value if 0 <= value <= maximum else None
+    if isinstance(value, float):
+        if (math.isfinite(value) and value.is_integer()
+                and 0 <= value <= maximum):
+            return int(value)
+    return None
+
+
+def enqueue_latest(q_, data):
+    """Keep a slow SSE client subscribed by replacing queued stale snapshots."""
+    try:
+        q_.put_nowait(data)
+        return True
+    except queue.Full:
+        try:
+            while True:
+                q_.get_nowait()
+        except queue.Empty:
+            pass
+        try:
+            q_.put_nowait(data)
+        except queue.Full:
+            pass
+        return True
+    except Exception:
+        return False
+
+
+def source_identity_signature(sources):
+    """Track session membership independently from ordinary log updates."""
+    return tuple(sorted(
+        (str(source.get("provider") or ""),
+         str(source.get("id") or ""),
+         str(source.get("path") or ""))
+        for source in (sources or [])
+        if source.get("id") or source.get("path")
+    ))
+
+
+def source_membership_probe_due(now, last_probe):
+    """Check cheap filesystem revisions every two seconds."""
+    return now - last_probe >= _SOURCE_MEMBERSHIP_PROBE_S
+
+
+def source_membership_fallback_due(now, last_fallback):
+    """Bound path-only session discovery to a four-second worst case."""
+    return now - last_fallback >= _SOURCE_MEMBERSHIP_FALLBACK_S
+
+
+def source_discovery_refresh_due(inventory_ready, now, last_refresh):
+    """Bound adapter-wide enumeration while keeping known-file checks fast."""
+    return bool(
+        not inventory_ready
+        or now - last_refresh >= _SOURCE_DISCOVERY_REFRESH_S
+    )
+
+
+def _physical_source_path(value):
+    value = str(value or "")
+    if not value or not os.path.isabs(os.path.expanduser(value)):
+        return ""
+    return os.path.abspath(os.path.expanduser(value))
+
+
+def source_inventory_probe_signature(targets, current_path=""):
+    """Stat probe targets while ignoring ordinary growth of the active trace."""
+    current_path = _physical_source_path(current_path)
+    current_is_dir = bool(current_path and os.path.isdir(current_path))
+    signature = []
+    for value in targets or ():
+        path = _physical_source_path(value)
+        if not path:
+            continue
+        is_current = path == current_path or bool(
+            current_is_dir and path.startswith(current_path + os.sep)
+        )
+        if is_current:
+            signature.append((path, "active", 0, 0))
+            continue
+        try:
+            row = os.stat(path)
+        except OSError:
+            signature.append((path, "missing", 0, 0))
+            continue
+        is_directory = stat.S_ISDIR(row.st_mode)
+        signature.append((
+            path,
+            "directory" if is_directory else "file",
+            int(row.st_mtime_ns),
+            0 if is_directory else int(row.st_size),
+        ))
+    return tuple(signature)
+
+
+def cross_session_refresh_due(dirty, membership_changed, now, last_refresh):
+    """Refresh membership immediately while throttling ordinary log updates."""
+    return bool(
+        dirty and (
+            membership_changed
+            or now - last_refresh >= _XSESS_LIVE_REFRESH_S
+        )
+    )
+
+
+def current_session_refresh_due(signature, last_signature, now, last_refresh):
+    """Observe revisions every watcher tick but coalesce whole-trace rebuilds."""
+    if signature == last_signature:
+        return False
+    return bool(
+        last_signature is None
+        or now - last_refresh >= _CURRENT_SESSION_REBUILD_S
+    )
+
+
+AGENT_RESULT_MAX_CHARS = 8000
+
+
+AGENT_CHECK_FOCUS = {"continue", "cost", "context", "tools", "next_phase"}
+
+
+AGENT_USAGE_FOCUS = {"spend", "models", "tools", "changes"}
+
+
+def compact_agent_value(value, depth=0):
+    if depth > 5:
+        return None
+    if isinstance(value, str):
+        return compact_text(value, 500)
+    if isinstance(value, list):
+        return [compact_agent_value(item, depth + 1) for item in value[:10]]
+    if isinstance(value, dict):
+        return {str(key): compact_agent_value(item, depth + 1)
+                for key, item in list(value.items())[:50]}
+    return value
+
+
+def bounded_agent_result(result):
+    """Keep a model-facing result useful even if an upstream label grows unexpectedly."""
+    result = dict(result or {})
+    result["evidence"] = list(result.get("evidence") or [])[:3]
+    if isinstance(result.get("candidates"), list):
+        result["candidates"] = result["candidates"][:5]
+    result.setdefault("truncated", False)
+    encoded = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
+    if len(encoded) <= AGENT_RESULT_MAX_CHARS:
+        return result
+    result = compact_agent_value(result)
+    result["truncated"] = True
+    result["evidence"] = list(result.get("evidence") or [])[:2]
+    if isinstance(result.get("candidates"), list):
+        result["candidates"] = result["candidates"][:3]
+    if isinstance(result.get("categories"), list):
+        result["categories"] = result["categories"][:3]
+    for key in ("answer", "caveat", "recommended_action"):
+        if isinstance(result.get(key), str):
+            result[key] = compact_text(result[key], 240)
+    encoded = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
+    if len(encoded) > AGENT_RESULT_MAX_CHARS:
+        result.pop("categories", None)
+        result.pop("candidates", None)
+        result.pop("execution", None)
+    encoded = json.dumps(result, ensure_ascii=False, separators=(",", ":"))
+    if len(encoded) > AGENT_RESULT_MAX_CHARS:
+        result["evidence"] = []
+    return result
+
+
+def safe_execution_trace(state, execution_idx, limit=5):
+    allowed = {"tool_call", "tool_result", "usage", "complete", "context", "reasoning", "coordination", "start"}
+    out = []
+    for event in state.get("trace") or []:
+        if event.get("execution") != execution_idx or event.get("kind") not in allowed:
+            continue
+        item = {"kind": event.get("kind"), "label": compact_text(event.get("label") or "Activity", 64)}
+        if event.get("kind") == "tool_result" and event.get("tokens") is not None:
+            item["returned_tokens"] = int(event.get("tokens") or 0)
+        if event.get("cost"):
+            item["cost"] = round(float(event.get("cost") or 0), 4)
+        out.append(item)
+    return out[:limit]
+
+
+# Runtimes whose every priced record is timestamped no later than the newest
+# file mtime the source revision tracks, so an older source cannot reach a window.
+_ACTIVITY_BOUNDED_PROVIDERS = frozenset(("claude", "codex"))
+
+
+def _window_start_ts(day_keys):
+    earliest = datetime.date.fromisoformat(min(day_keys))
+    # One spare day covers DST and local/UTC day-boundary differences.
+    return datetime.datetime.combine(earliest, datetime.time()).timestamp() - 86400.0
+
+
+def _source_order_mtime(source):
+    try:
+        return float(source.get("mtime") or 0)
+    except (TypeError, ValueError, OverflowError):
+        return 0.0
+
+
+# Older discovered sources may miss the caller's run, so scope=current reuses only this fresh a scan.
+HISTORY_SOURCE_REUSE_S = 60.0
+
+
+_history_scan = {"progress": None, "last_complete": None}
+
+
+def _history_scan_failed():
+    return RuntimeError("Token Meter could not scan session history.")
+
+
+def compact_duration_ms(ms):
+    try:
+        seconds = max(0, int(ms) / 1000.0)
+    except Exception:
+        return ""
+    if seconds < 1:
+        return f"{int(seconds * 1000)}ms"
+    if seconds < 10:
+        return f"{seconds:.1f}s"
+    if seconds < 60:
+        return f"{int(round(seconds))}s"
+    minutes, sec = divmod(int(round(seconds)), 60)
+    if minutes < 60:
+        return f"{minutes}m {sec:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes:02d}m"
+
+
+def parse_codex_quota(payload, source="Codex app-server", now=None):
+    return openai_quotas.parse_quota(payload, source=source, now=now)
+
+
+def parse_claude_quota(payload, credentials=None, now=None):
+    return anthropic_quotas.parse_quota(
+        payload, credentials=credentials, now=now
+    )
+
+
+def parse_cursor_quota(payload, now=None):
+    return cursor_quotas.parse_quota(payload, now=now)
+
+
+def _quota_loading_row(provider):
+    labels = {"claude": "Claude", "codex": "Codex", "cursor": "Cursor"}
+    return quota_provider(
+        provider, labels[provider], "loading", "Provider account", error="Loading provider quotas.",
+    )
+
+
+def page_root(path):
+    """Directory that holds the dashboard and its bundled assets."""
+    if dashboard_page.is_manifest(path):
+        return dashboard_page.dashboard_root(path)
+    return os.path.dirname(path)
+
+
+def page_bytes(path):
+    """Assembled dashboard bytes, or None when a part is missing or unreadable."""
+    try:
+        return dashboard_page.read_page(path).encode("utf-8")
+    except (OSError, UnicodeDecodeError, ValueError):
+        return None
+
+
+def is_dashboard_page_path(req_path):
+    return req_path == "/" or bool(re.fullmatch(r"/sessions/[^/]{1,240}/?", req_path or ""))
+
+
+_DASHBOARD_ASSETS = {
+    "/assets/fonts/Tektur-Variable.ttf": ("assets/fonts/Tektur-Variable.ttf", "font/ttf"),
+    "/assets/brand/logo-splunk-by-cisco-rgb-w.png": (
+        "assets/brand/logo-splunk-by-cisco-rgb-w.png",
+        "image/png",
+    ),
+    **{
+        f"/{asset}": (asset, "text/javascript; charset=utf-8")
+        for asset in (
+            "assets/session-effects.js",
+            "assets/vendor/paper-shaders/get-shader-color-from-string.js",
+            "assets/vendor/paper-shaders/get-shader-noise-texture.js",
+            "assets/vendor/paper-shaders/shader-mount.js",
+            "assets/vendor/paper-shaders/shader-sizing.js",
+            "assets/vendor/paper-shaders/shader-utils.js",
+            "assets/vendor/paper-shaders/vertex-shader.js",
+            "assets/vendor/paper-shaders/shaders/pulsing-border.js",
+        )
+    },
+}
+
+
+def dashboard_asset_content_type(req_path):
+    spec = _DASHBOARD_ASSETS.get(req_path)
+    return spec[1] if spec else None
+
+
+def missing_performance_html():
+    return """<!doctype html>
+<html>
+<head><meta charset="utf-8"><title>Token Meter setup error</title></head>
+<body><h1>performance.html is missing</h1>
+<p>Reinstall Token Meter from a complete source checkout.</p></body>
+</html>"""
+
+
+def _page_within_runtime(page, runtime):
+    """True when the served page lives under ``runtime``; installers ask this instead of reading a path."""
+    if not page or not isinstance(runtime, str) or not runtime or len(runtime) > 4096:
+        return False
+    if not os.path.isabs(runtime):
+        return False
+    try:
+        root = os.path.normcase(os.path.realpath(runtime))
+        served = os.path.normcase(os.path.realpath(page))
+        return os.path.commonpath([root, served]) == root
+    except (OSError, ValueError):
+        return False
+
+
+class TokenMeterHTTPServer(ThreadingHTTPServer):
+    allow_reuse_address = True
+    daemon_threads = True
+    request_queue_size = 64
+
+    def server_bind(self):
+        # http.server stores socket.getfqdn(host) as server_name, a blocking
+        # reverse lookup. The bind address is loopback and no code reads the
+        # FQDN, so keep the host as-is and let listen() start without DNS.
+        socketserver.TCPServer.server_bind(self)
+        host, port = self.server_address[:2]
+        self.server_name = host
+        self.server_port = port
diff --git a/token_meter/app_helpers/config_files.py b/token_meter/app_helpers/config_files.py
new file mode 100644
index 00000000..59f0f3c5
--- /dev/null
+++ b/token_meter/app_helpers/config_files.py
@@ -0,0 +1,164 @@
+"""Read-only agent configuration file parsing (TOML and similar)."""
+
+import json
+import re
+
+
+def toml_named_sections(path, table):
+    """Read simple enabled state from named TOML sections without a TOML dependency."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            text = fh.read()
+    except OSError:
+        return {}
+    header = re.compile(rf'^\[{re.escape(table)}\.(?:"([^"]+)"|([^\.\]]+))\]\s*$', re.MULTILINE)
+    matches = list(header.finditer(text))
+    result = {}
+    for index, match in enumerate(matches):
+        name = (match.group(1) or match.group(2) or "").strip()
+        end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
+        body = text[match.end():end]
+        enabled_match = re.search(r'^\s*enabled\s*=\s*(true|false)\s*$', body, re.MULTILINE | re.IGNORECASE)
+        result[name] = {
+            "enabled": enabled_match is None or enabled_match.group(1).lower() == "true",
+            "start": match.start(), "body_start": match.end(), "end": end,
+        }
+    return result
+
+
+def _toml_line_structure(line, state="normal", array_depth=0):
+    """Track TOML string state so root-table scanning never enters a literal."""
+    index = 0
+    while index < len(line):
+        char = line[index]
+        if state == "triple-basic":
+            if line.startswith('\"\"\"', index):
+                state, index = "normal", index + 3
+            else:
+                index += 1
+        elif state == "triple-literal":
+            if line.startswith("'''", index):
+                state, index = "normal", index + 3
+            else:
+                index += 1
+        elif state == "basic":
+            if char == "\\":
+                index += 2
+            elif char == '"':
+                state, index = "normal", index + 1
+            else:
+                index += 1
+        elif state == "literal":
+            if char == "'":
+                state = "normal"
+            index += 1
+        else:
+            if char == "#":
+                break
+            if line.startswith('\"\"\"', index):
+                state, index = "triple-basic", index + 3
+            elif line.startswith("'''", index):
+                state, index = "triple-literal", index + 3
+            elif char == '"':
+                state, index = "basic", index + 1
+            elif char == "'":
+                state, index = "literal", index + 1
+            elif char == "[":
+                array_depth, index = array_depth + 1, index + 1
+            elif char == "]":
+                array_depth, index = max(0, array_depth - 1), index + 1
+            else:
+                index += 1
+    return state, array_depth
+
+
+def _toml_line_state(line, state="normal"):
+    return _toml_line_structure(line, state)[0]
+
+
+def _toml_is_table_header(line, state, array_depth):
+    if state != "normal" or array_depth:
+        return False
+    return bool(re.match(r"^[ \t]*(?:\[\[.*\]\]|\[.*\])[ \t]*(?:#.*)?(?:\r?\n)?$", line))
+
+
+def _toml_root_prefix(text):
+    offset, state, array_depth = 0, "normal", 0
+    for line in text.splitlines(keepends=True):
+        if _toml_is_table_header(line, state, array_depth):
+            return text[:offset], text[offset:]
+        state, array_depth = _toml_line_structure(line, state, array_depth)
+        offset += len(line)
+    return text, ""
+
+
+def _toml_comment_index(value):
+    index, state = 0, "normal"
+    while index < len(value):
+        char = value[index]
+        if state == "basic":
+            if char == "\\":
+                index += 2
+                continue
+            if char == '"':
+                state = "normal"
+        elif state == "literal":
+            if char == "'":
+                state = "normal"
+        elif char == "#":
+            return index
+        elif char == '"':
+            state = "basic"
+        elif char == "'":
+            state = "literal"
+        index += 1
+    return len(value)
+
+
+def _toml_root_assignment(prefix, key):
+    pattern = re.compile(rf"^(?P<before>[ \t]*(?:{re.escape(key)}|\"{re.escape(key)}\")[ \t]*=[ \t]*)(?P<after>.*)$")
+    offset, state = 0, "normal"
+    for line in prefix.splitlines(keepends=True):
+        line_body = line.rstrip("\r\n")
+        line_end = line[len(line_body):]
+        match = pattern.match(line_body) if state == "normal" else None
+        if match:
+            after = match.group("after")
+            comment_at = _toml_comment_index(after)
+            value = after[:comment_at].rstrip()
+            suffix = after[len(value):] + line_end
+            return {
+                "start": offset,
+                "end": offset + len(line),
+                "before": match.group("before"),
+                "value": value,
+                "suffix": suffix,
+            }
+        state = _toml_line_state(line, state)
+        offset += len(line)
+    return None
+
+
+def _toml_root_scalar(text, key):
+    prefix, _ = _toml_root_prefix(text)
+    assignment = _toml_root_assignment(prefix, key)
+    if not assignment:
+        return None
+    value = assignment["value"]
+    if value.startswith(('\"\"\"', "'''")):
+        return None
+    if len(value) >= 2 and value[0] == '"' and value[-1] == '"':
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return None
+    if len(value) >= 2 and value[0] == "'" and value[-1] == "'":
+        return value[1:-1]
+    try:
+        return int(value)
+    except ValueError:
+        return None
+
+
+def _toml_root_scalar_text(value):
+    return str(int(value)) if isinstance(value, int) else json.dumps(value, ensure_ascii=False)
diff --git a/token_meter/app_helpers/cursor_traces.py b/token_meter/app_helpers/cursor_traces.py
new file mode 100644
index 00000000..69ed5571
--- /dev/null
+++ b/token_meter/app_helpers/cursor_traces.py
@@ -0,0 +1,354 @@
+"""Cursor trace helpers used by the composition module."""
+
+import datetime
+import math
+import re
+
+from token_meter.models.catalog import CURSOR_VARIANT_MODEL_IDS
+from token_meter.models.pricing import model_alias_matches as _catalog_model_alias_matches
+from token_meter.runtimes.cursor import cursor_model_name
+from token_meter.app_helpers.common import (
+    CHARS_PER_TOKEN,
+    _merge_execution_intervals,
+    parse_iso,
+    text_from_content,
+)
+
+
+def cursor_model(composer, header=None):
+    return cursor_model_name(composer, header)
+
+
+def cursor_model_parameters(composer, model=None):
+    """Return persisted parameters for the selected Cursor model."""
+    config = composer.get("modelConfig") if isinstance(composer, dict) else {}
+    selected = config.get("selectedModels") if isinstance(config, dict) else []
+    for row in selected or []:
+        if not isinstance(row, dict):
+            continue
+        params = {
+            str(item.get("id")): item.get("value")
+            for item in (row.get("parameters") or []) if isinstance(item, dict) and item.get("id")
+        }
+        if not model or str(row.get("modelId") or "") == str(model):
+            return params
+    return {}
+
+
+def cursor_price_variant(composer, model, spawn_model=""):
+    config = composer.get("modelConfig") if isinstance(composer, dict) else {}
+    if isinstance(config, dict) and config.get("maxMode") is True:
+        for row in config.get("selectedModels") or []:
+            model_id = str(row.get("modelId") or "") if isinstance(row, dict) else ""
+            if model_id and _catalog_model_alias_matches(model, "cursor", model_id):
+                if str(cursor_model_parameters(composer, model_id).get("fast")).lower() == "true":
+                    return "max-fast"
+                break
+        return "max"
+    for cursor_model_id in CURSOR_VARIANT_MODEL_IDS:
+        if not _catalog_model_alias_matches(model, "cursor", cursor_model_id):
+            continue
+        params = cursor_model_parameters(composer, cursor_model_id)
+        fast = str(params.get("fast")).lower()
+        if fast not in ("true", "false"):
+            # A subagent's own config may omit speed; its parent's spawn call names the exact variant.
+            fast = {cursor_model_id + "-fast": "true", cursor_model_id + "-standard": "false"}.get(
+                str(spawn_model or "").lower(), fast)
+        context = str(params.get("context") or "").lower()
+        prefix = (
+            "500k-" if cursor_model_id == "grok-4.7" and context in ("500k", "500000")
+            else ""
+        )
+        if fast == "true":
+            return prefix + "fast"
+        if fast == "false":
+            return prefix + "standard"
+        return ""
+    selected = config.get("selectedModels") if isinstance(config, dict) else []
+    for row in selected or []:
+        model_id = str(row.get("modelId") or "") if isinstance(row, dict) else ""
+        if model_id and _catalog_model_alias_matches(model, "cursor", model_id):
+            if str(cursor_model_parameters(composer, model_id).get("fast")).lower() == "true":
+                return "fast"
+            break
+    return ""
+
+
+def cursor_user_turns(objs, default_model=None):
+    """Extract human turns from Cursor's durable transcript without wrappers."""
+    turns = []
+    for row in objs or []:
+        if not isinstance(row, dict) or row.get("role") != "user":
+            continue
+        text = text_from_content(cursor_message_content(row))
+        match = re.search(r"<user_query>\s*(.*?)\s*</user_query>", text, flags=re.DOTALL)
+        turns.append({"ts": 0, "text": match.group(1) if match else text,
+                      "model": default_model or "unknown"})
+    return turns
+
+
+def cursor_timestamp(value):
+    if isinstance(value, (int, float)):
+        return float(value) / 1000.0 if float(value) > 10_000_000_000 else float(value)
+    if isinstance(value, str):
+        try:
+            return datetime.datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
+        except (TypeError, ValueError):
+            return float(parse_iso(value) or 0)
+    return 0.0
+
+
+def cursor_message_content(row):
+    message = row.get("message") if isinstance(row, dict) else {}
+    content = message.get("content") if isinstance(message, dict) else []
+    return content if isinstance(content, list) else []
+
+
+def cursor_transcript_groups(rows, source):
+    """Reconstruct coarse turns when Cursor SQLite enrichment is unavailable."""
+    groups = []
+    current = None
+    for row in rows or []:
+        role = row.get("role") if isinstance(row, dict) else None
+        if role == "user":
+            if current:
+                groups.append(current)
+            user_text = text_from_content(cursor_message_content(row))
+            query = re.search(r"<user_query>\s*(.*?)\s*</user_query>", user_text, flags=re.DOTALL)
+            current = {
+                "user_text": query.group(1) if query else user_text,
+                "model": source.get("model") or "unknown", "bubbles": [],
+                "completed": False,
+            }
+            continue
+        if role == "assistant":
+            if current is None:
+                current = {"user_text": "", "model": source.get("model") or "unknown",
+                           "bubbles": [], "completed": False}
+            current["bubbles"].append({"type": 2, "content": cursor_message_content(row)})
+            continue
+        if row.get("type") == "turn_ended" and current:
+            current["completed"] = row.get("status") in (None, "success", "completed")
+            groups.append(current)
+            current = None
+    if current:
+        groups.append(current)
+    return groups
+
+
+def cursor_enriched_groups(snapshot):
+    groups = []
+    current = None
+    for bubble in snapshot.get("bubbles") or []:
+        if bubble.get("type") == 1:
+            if current:
+                groups.append(current)
+            model_info = bubble.get("modelInfo") if isinstance(bubble.get("modelInfo"), dict) else {}
+            current = {
+                "user_text": str(bubble.get("text") or ""),
+                "model": model_info.get("modelName") or
+                         cursor_model(snapshot.get("composer") or {}, snapshot.get("header") or {}),
+                "request_id": bubble.get("requestId") or "",
+                "start_ts": cursor_timestamp(bubble.get("createdAt")),
+                "context": bubble.get("contextWindowStatusAtCreation")
+                           if isinstance(bubble.get("contextWindowStatusAtCreation"), dict) else {},
+                "bubbles": [], "completed": False,
+            }
+            continue
+        if bubble.get("type") != 2:
+            continue
+        if current is None:
+            current = {
+                "user_text": "", "model": cursor_model(
+                    snapshot.get("composer") or {}, snapshot.get("header") or {}
+                ), "request_id": "", "start_ts": 0, "context": {}, "bubbles": [],
+                "completed": False,
+            }
+        current["bubbles"].append(bubble)
+        if bubble.get("turnDurationMs") is not None:
+            current["completed"] = True
+            current["turn_duration_ms"] = bubble.get("turnDurationMs")
+    if current:
+        groups.append(current)
+    return groups
+
+
+CURSOR_SPAN_LEAD_S = 5.0
+
+
+def cursor_turn_timing(spans, start_ts, next_start_ts=0, terminal_ts=0, turn_duration_ms=0,
+                       request_id="", claimed_request_ids=frozenset()):
+    # Spans carrying a known turn requestId belong to that turn. Others are
+    # attributed by start: Cursor opens spans a few seconds before the user
+    # bubble's createdAt, and a turn's spans can outlive the next queued turn.
+    lower = float(start_ts or 0) - CURSOR_SPAN_LEAD_S
+    if next_start_ts:
+        upper = max(lower, float(next_start_ts) - CURSOR_SPAN_LEAD_S)
+    else:
+        upper = float((terminal_ts + 24 * 60 * 60) if terminal_ts else float("inf"))
+
+    def owned(row):
+        row_request = row.get("request_id") or ""
+        if row_request and row_request in claimed_request_ids:
+            return row_request == request_id
+        return lower <= row.get("start_ts", 0) < upper
+
+    matches = [row for row in spans or [] if owned(row)]
+    submits = [row for row in matches if row.get("name") == "ComposerChatService.submitChatMaybeAbortCurrent"]
+    attempts = [row for row in matches if row.get("name") == "agent.request.attempt"]
+    rpc_errors = {
+        row.get("request_id") for row in matches
+        if row.get("name") == "rpc.run" and row.get("error") and row.get("request_id")
+    }
+    ttfts = [row for row in matches if row.get("name") == "client.ttft" and row.get("duration_s", 0) > 0]
+    final_ts = max((row["end_ts"] for row in submits + attempts), default=float(terminal_ts or 0))
+    intervals = [(row["start_ts"], row["end_ts"]) for row in attempts]
+    try:
+        fallback_s = max(0.0, float(turn_duration_ms or 0) / 1000.0)
+    except (TypeError, ValueError):
+        fallback_s = 0.0
+    if not intervals and fallback_s and terminal_ts:
+        intervals = [(max(0.0, float(terminal_ts) - fallback_s), float(terminal_ts))]
+    active_s = _merge_execution_intervals(intervals)
+    if final_ts and start_ts and final_ts >= start_ts:
+        wait_s = final_ts - start_ts
+    else:
+        wait_s = fallback_s
+        final_ts = float(terminal_ts or (start_ts + fallback_s if start_ts else 0))
+    failed = sum(bool(row.get("error") or row.get("request_id") in rpc_errors) for row in attempts)
+    return {
+        "end_ts": final_ts,
+        "wait_s": max(0.0, wait_s),
+        "active_s": max(0.0, active_s),
+        "active_intervals": intervals,
+        "timing_basis": "request_trace" if (submits or attempts) else
+                        ("turn_duration" if fallback_s else "unavailable"),
+        "ttft_s": min((row["duration_s"] for row in ttfts), default=0.0),
+        "attempts": len(attempts),
+        "failed_attempts": failed,
+        "retries": max(0, len(attempts) - 1),
+    }
+
+
+def cursor_prompt_breakdown(composer):
+    raw = composer.get("promptTokenBreakdown") if isinstance(composer, dict) else {}
+    categories = raw.get("categories") if isinstance(raw, dict) else []
+    return [
+        {
+            "id": str(row.get("id") or "unknown"),
+            "label": str(row.get("label") or row.get("id") or "Unknown"),
+            "estimated_tokens": int(row.get("estimatedTokens") or 0),
+        }
+        for row in (categories or []) if isinstance(row, dict)
+    ]
+
+
+def cursor_context_estimates(groups, latest_tokens=0, latest_window=0):
+    """Fill sparse Cursor context checkpoints without calling them billable input."""
+    rows = []
+    for group in groups or []:
+        context = group.get("context") if isinstance(group.get("context"), dict) else {}
+        rows.append({
+            "tokens": max(0, int(context.get("tokensUsed") or 0)),
+            "window": max(0, int(context.get("tokenLimit") or 0)),
+            "interpolated": False,
+        })
+    if not rows:
+        return rows
+    if latest_tokens:
+        rows[-1]["tokens"] = max(0, int(latest_tokens))
+    if latest_window:
+        rows[-1]["window"] = max(0, int(latest_window))
+
+    known_tokens = [index for index, row in enumerate(rows) if row["tokens"] > 0]
+    for index, row in enumerate(rows):
+        if row["tokens"] > 0:
+            continue
+        previous = max((known for known in known_tokens if known < index), default=None)
+        following = min((known for known in known_tokens if known > index), default=None)
+        if following is not None and previous is not None:
+            span = following - previous
+            share = (index - previous) / span
+            start = rows[previous]["tokens"]
+            row["tokens"] = max(1, round(start + (rows[following]["tokens"] - start) * share))
+        elif following is not None:
+            row["tokens"] = max(1, round(rows[following]["tokens"] * (index + 1) / (following + 1)))
+        elif previous is not None:
+            row["tokens"] = rows[previous]["tokens"]
+        row["interpolated"] = bool(row["tokens"])
+
+    known_windows = [index for index, row in enumerate(rows) if row["window"] > 0]
+    for index, row in enumerate(rows):
+        if row["window"] > 0:
+            continue
+        nearest = min(known_windows, key=lambda known: abs(known - index)) if known_windows else None
+        if nearest is not None:
+            row["window"] = rows[nearest]["window"]
+    return rows
+
+
+def cursor_visible_output(bubbles):
+    """Estimate only model-authored text that Cursor persisted in its bubbles."""
+    assistant_chars = 0
+    reasoning_chars = 0
+    for bubble in bubbles or []:
+        if not isinstance(bubble, dict):
+            continue
+        seen = set()
+        text = bubble.get("text")
+        if isinstance(text, str) and text.strip():
+            seen.add(text)
+            assistant_chars += len(text)
+        for block in bubble.get("content") or []:
+            if not isinstance(block, dict) or block.get("type") != "text":
+                continue
+            value = block.get("text")
+            if isinstance(value, str) and value.strip() and value not in seen:
+                seen.add(value)
+                assistant_chars += len(value)
+        thinking = bubble.get("thinking")
+        if isinstance(thinking, str) and thinking.strip() and thinking not in seen:
+            reasoning_chars += len(thinking)
+    return {
+        "assistant_chars": assistant_chars,
+        "reasoning_chars": reasoning_chars,
+        "assistant_tokens": math.ceil(assistant_chars / CHARS_PER_TOKEN) if assistant_chars else 0,
+        "reasoning_tokens": math.ceil(reasoning_chars / CHARS_PER_TOKEN) if reasoning_chars else 0,
+    }
+
+
+def cursor_model_call_count(bubbles):
+    call_ids = set()
+    has_model_activity = False
+    for bubble in bubbles or []:
+        if not isinstance(bubble, dict):
+            continue
+        tool_data = bubble.get("toolFormerData")
+        if isinstance(tool_data, dict):
+            call_id = tool_data.get("modelCallId")
+            if call_id:
+                call_ids.add(str(call_id))
+            has_model_activity = has_model_activity or bool(tool_data.get("name"))
+        has_model_activity = has_model_activity or bool(str(bubble.get("text") or "").strip())
+        has_model_activity = has_model_activity or any(
+            isinstance(block, dict) and block.get("type") in ("text", "tool_use")
+            for block in (bubble.get("content") or [])
+        )
+    return max(len(call_ids), int(has_model_activity))
+
+
+def cursor_pricing_note(model, variant, supported):
+    basis = "one context snapshot per execution plus trace-visible model text"
+    if not supported:
+        return f"Local Cursor token estimate ({basis}); no configured public rate for {model}."
+    rate = "selected-model public API rates"
+    if variant == "max":
+        rate += " plus Cursor's 20% Max Mode markup"
+    elif variant == "max-fast":
+        rate = "selected-model public fast-mode API rates plus Cursor's 20% Max Mode markup"
+    for cursor_model_id in CURSOR_VARIANT_MODEL_IDS:
+        if _catalog_model_alias_matches(model, "cursor", cursor_model_id):
+            rate = (f"{cursor_model_id.replace('-', ' ').title()} "
+                    f"{variant.replace('-', ' ').title()} public rates")
+            break
+    return f"Local Cursor estimate ({basis}), priced with {rate}; cache and hidden model work are excluded."
diff --git a/token_meter/app_helpers/menubar_payload.py b/token_meter/app_helpers/menubar_payload.py
new file mode 100644
index 00000000..9c347914
--- /dev/null
+++ b/token_meter/app_helpers/menubar_payload.py
@@ -0,0 +1,354 @@
+"""Compact native menu-bar payload helpers."""
+
+import datetime
+import math
+
+from token_meter.domain.usage import format_usd
+from token_meter.domain.cache_window import cache_window_projection as _domain_cache_window_projection
+from token_meter.app_helpers.common import (
+    compact_duration_ms,
+    compact_text,
+    folded_child_root_id,
+    is_operational_warning,
+    low_yield_should_warn,
+    metric_available,
+)
+
+
+MENUBAR_CONTEXT_SOFT_PCT = 0.65
+
+
+MENUBAR_CONTEXT_WATCH_PCT = 0.70
+
+
+MENUBAR_CONTEXT_INTERVENE_PCT = 0.85
+
+
+MENUBAR_COST_SPIKE = 0.50
+
+
+def menubar_activity(st):
+    trace = st.get("trace") or []
+    preferred = {
+        "tool_call", "tool_result", "message", "reasoning", "complete",
+        "context", "goal", "start", "user",
+    }
+    event = None
+    for ev in reversed(trace[-24:]):
+        if ev.get("kind") in preferred:
+            event = ev
+            break
+    if event is None and trace:
+        event = trace[-1]
+    if not event:
+        return {
+            "kind": "idle",
+            "title": "Waiting for activity",
+            "detail": "No trace events yet.",
+            "time": "",
+            "execution": None,
+        }
+
+    kind = event.get("kind") or "activity"
+    label = event.get("label") or kind.replace("_", " ").title()
+    detail = event.get("detail") or ""
+    tool = event.get("tool")
+    execution = event.get("execution")
+    duration_ms = event.get("duration_ms")
+
+    if kind == "tool_call":
+        title = f"Running {label}"
+    elif kind == "tool_result":
+        title = f"Received {label}"
+    elif kind == "reasoning":
+        title = "Reasoning"
+    elif kind == "message":
+        title = label if label != "Agent update" else "Agent update"
+    elif kind == "complete":
+        title = f"Completed #{execution}" if execution else "Execution complete"
+    elif kind == "context":
+        title = label
+    elif kind == "user":
+        title = "User message"
+    else:
+        title = label
+
+    bits = []
+    duration = compact_duration_ms(duration_ms)
+    if not duration and isinstance(detail, str) and detail.endswith("ms") and detail[:-2].isdigit():
+        duration = compact_duration_ms(detail[:-2])
+    if duration:
+        bits.append(f"in {duration}" if kind == "complete" else duration)
+    elif detail:
+        bits.append(detail)
+    if execution:
+        if kind == "complete":
+            pass
+        else:
+            bits.append(f"#{execution}")
+    if tool and tool not in title:
+        bits.append(tool)
+    if event.get("cost"):
+        bits.append(format_usd(event["cost"]))
+    detail = " · ".join(bits)
+    return {
+        "kind": kind,
+        "title": compact_text(title, 64),
+        "detail": compact_text(detail, 120),
+        "time": event.get("time") or "",
+        "execution": execution,
+        "tool": tool,
+    }
+
+
+def menubar_recommendation(st):
+    context = st.get("context") or {}
+    pct = context.get("latest_pct") or 0
+    insights = st.get("insights") or []
+    warn = next((i for i in insights if i.get("kind") == "warn"), None)
+    last_cost = st.get("last_turn_cost") or 0
+    cost_available = metric_available(st, "cost") and not st.get("token_estimate")
+    low_yield_actionable = (not st.get("token_estimate") and
+                            low_yield_should_warn(st.get("executions") or [], pct))
+
+    if st.get("ended"):
+        return {
+            "label": "Pinned log",
+            "detail": "This is a frozen log view; return to live to follow newest activity.",
+            "severity": "idle",
+            "target": "summary",
+        }
+    if pct >= MENUBAR_CONTEXT_INTERVENE_PCT:
+        return {
+            "label": "Compact now",
+            "detail": f"Context is {pct * 100:.0f}% of the model window.",
+            "severity": "bad",
+            "target": "summary",
+        }
+    if cost_available and last_cost >= MENUBAR_COST_SPIKE:
+        return {
+            "label": "Review spike",
+            "detail": f"Last execution cost {format_usd(last_cost)}.",
+            "severity": "bad",
+            "target": "summary",
+        }
+    if low_yield_actionable:
+        return {
+            "label": "Summarize soon",
+            "detail": "Latest execution replayed large context for low output.",
+            "severity": "warn",
+            "target": "summary",
+        }
+    if pct >= MENUBAR_CONTEXT_WATCH_PCT:
+        return {
+            "label": "Summarize soon",
+            "detail": f"Context is {pct * 100:.0f}%; prepare before 85%.",
+            "severity": "warn",
+            "target": "summary",
+        }
+    if pct >= MENUBAR_CONTEXT_SOFT_PCT:
+        return {
+            "label": "Watch context",
+            "detail": f"Context is {pct * 100:.0f}% of the model window.",
+            "severity": "idle",
+            "target": "summary",
+        }
+    if warn:
+        return {
+            "label": "Check signal",
+            "detail": warn.get("text") or "A warning signal is active.",
+            "severity": "warn",
+            "target": "summary",
+        }
+    return {
+        "label": "Let it run",
+        "detail": "No immediate intervention needed.",
+        "severity": "good",
+        "target": "summary",
+    }
+
+
+def menubar_verdict(st, recommendation):
+    context = st.get("context") or {}
+    reported_pct = context.get("latest_pct")
+    pct = reported_pct or 0
+    last_cost = st.get("last_turn_cost") or 0
+    cost_available = metric_available(st, "cost") and not st.get("token_estimate")
+    insights = st.get("insights") or []
+    operational_warn = next((i for i in insights if i.get("kind") == "warn" and is_operational_warning(i)), None)
+
+    def payload(key, detail):
+        labels = {
+            "healthy": ("Healthy", "TM", "good"),
+            "watch": ("Watch closely", "TM !", "warn"),
+            "intervene": ("Intervene now", "TM !!", "bad"),
+            "idle": ("Idle", "TM idle", "idle"),
+        }
+        label, prefix, severity = labels[key]
+        return {"key": key, "label": label, "prefix": prefix, "severity": severity, "detail": detail}
+
+    if st.get("ended"):
+        return payload("idle", "This is a frozen log view; return to live to follow newest activity.")
+    if pct >= MENUBAR_CONTEXT_INTERVENE_PCT:
+        return payload(
+            "intervene",
+            f"Context is {pct * 100:.0f}% of the model window; compact now.",
+        )
+    if cost_available and last_cost >= MENUBAR_COST_SPIKE:
+        return payload(
+            "intervene",
+            f"Last execution cost {format_usd(last_cost)}; review the spike before continuing.",
+        )
+    if pct >= MENUBAR_CONTEXT_WATCH_PCT:
+        return payload(
+            "watch",
+            f"Context is {pct * 100:.0f}% of the model window; prepare to summarize before 85%.",
+        )
+    if operational_warn:
+        detail = operational_warn.get("text") or recommendation.get("detail") or "An operational warning is active."
+        return payload("watch", detail)
+
+    detail = (f"Context is {pct * 100:.0f}% and no operational warning needs intervention."
+              if reported_pct is not None else
+              "Context percentage is not reported; no operational warning needs intervention.")
+    return payload("healthy", detail)
+
+
+def menubar_project_name(value):
+    """Return only a display-safe project leaf for the native payload."""
+    project = str(value or "").rstrip("/\\")
+    if not project or project == "No project":
+        return ""
+    return compact_text(project.replace("\\", "/").rsplit("/", 1)[-1], 52)
+
+
+def menubar_session_name(source):
+    session_name = compact_text(source.get("session_name") or "", 52).strip()
+    if session_name and session_name.lower() not in ("untitled", "untitled session"):
+        return session_name
+    title = compact_text(source.get("title") or "", 52).strip()
+    if title and title.lower() not in ("untitled", "untitled session"):
+        return title
+    project = menubar_project_name(source.get("project"))
+    if project:
+        return project
+    return str(source.get("id") or "session")[:12]
+
+
+def menubar_recent_sessions(sources, selected_id=None, limit=5, summaries=None):
+    summary_names = {}
+    for summary in summaries or ():
+        key = (str(summary.get("provider") or ""), str(summary.get("id") or ""))
+        name = compact_text(summary.get("session_name") or "", 52).strip()
+        if key[1] and name and key not in summary_names:
+            summary_names[key] = name
+
+    # A child run is listed through its root session, which inherits the
+    # child's newer activity, so the menu never offers a child as its own run.
+    source_list = list(sources or [])
+    root_keys = {
+        (str(row.get("provider") or ""), str(row.get("id") or ""))
+        for row in source_list
+    }
+    child_activity = {}
+    for row in source_list:
+        root_id = folded_child_root_id(row)
+        key = (str(row.get("provider") or ""), root_id)
+        if root_id and key in root_keys:
+            child_activity[key] = max(
+                child_activity.get(key, 0), float(row.get("mtime") or 0),
+            )
+    listed = []
+    for row in source_list:
+        key = (str(row.get("provider") or ""), folded_child_root_id(row))
+        if key[1] and key in root_keys:
+            continue
+        own_key = (str(row.get("provider") or ""), str(row.get("id") or ""))
+        if own_key in child_activity and child_activity[own_key] > float(row.get("mtime") or 0):
+            row = dict(row, mtime=child_activity[own_key])
+        listed.append(row)
+
+    ordered, seen = [], set()
+    for source in sorted(listed, key=lambda row: -(row.get("mtime") or 0)):
+        sid = str(source.get("id") or "")
+        if not sid or sid in seen:
+            continue
+        seen.add(sid)
+        ordered.append(source)
+
+    selected = next((row for row in ordered if row.get("id") == selected_id), None)
+    choices = ordered[:max(0, limit)]
+    if selected and selected not in choices and limit > 0:
+        choices = [selected] + [row for row in ordered if row is not selected][:limit - 1]
+
+    result = []
+    for row in choices:
+        display_row = dict(row)
+        key = (str(row.get("provider") or ""), str(row.get("id") or ""))
+        if summary_names.get(key):
+            display_row["session_name"] = summary_names[key]
+        result.append({
+            "id": row.get("id"),
+            "provider": row.get("provider"),
+            "client": row.get("client") or row.get("provider"),
+            "label": row.get("label"),
+            "name": menubar_session_name(display_row),
+            "mtime": row.get("mtime") or 0,
+        })
+    return result
+
+
+def menubar_cache_window(current_sessions, selected_id, root_id=None):
+    """Return the selected session's cache window; a folded child run resolves to its root."""
+    for wanted in (str(selected_id or ""), str(root_id or "")):
+        if not wanted:
+            continue
+        for summary in current_sessions or ():
+            if isinstance(summary, dict) and str(summary.get("id") or "") == wanted:
+                return _domain_cache_window_projection(summary.get("cache_window"))
+    return None
+
+
+def menubar_context_pulse(st, limit=18):
+    """Return a short numeric context history for the native Run Pulse.
+
+    The native companion needs a visual indication of whether measured context
+    is rising or settling, but it must never receive trace text, paths, tool
+    inputs, or other session contents. Keep only finite context percentages
+    from the most recent completed executions.
+    """
+    values = []
+    for execution in (st.get("executions") or []):
+        value = execution.get("context_pct")
+        if isinstance(value, bool):
+            continue
+        try:
+            value = float(value)
+        except (TypeError, ValueError):
+            continue
+        if math.isfinite(value):
+            values.append(round(max(0.0, min(1.0, value)), 4))
+    return values[-max(1, limit):]
+
+
+def menubar_today_spend(cross, today=None):
+    """Return a bounded current-day spend projection for the native title."""
+    day = (today or datetime.date.today()).isoformat()
+    daily = cross.get("daily") if isinstance(cross, dict) else []
+    row = next(
+        (item for item in (daily or [])
+         if isinstance(item, dict) and item.get("day") == day),
+        None,
+    )
+    availability = row.get("availability") if isinstance(row, dict) else {}
+    available = bool(isinstance(availability, dict) and availability.get("cost") is True)
+    provenance = row.get("provenance") if isinstance(row, dict) else {}
+    estimated_cost = (
+        float(provenance.get("estimated_cost") or 0)
+        if isinstance(provenance, dict) else 0.0
+    )
+    return {
+        "available": available,
+        "total_cost": float(row.get("cost") or 0) if available else None,
+        "estimated": estimated_cost > 0,
+    }
diff --git a/token_meter/app_helpers/normalize.py b/token_meter/app_helpers/normalize.py
new file mode 100644
index 00000000..eaef0b09
--- /dev/null
+++ b/token_meter/app_helpers/normalize.py
@@ -0,0 +1,449 @@
+"""Value normalization helpers used by the composition module."""
+
+import json
+import math
+import re
+
+from token_meter.domain.insights import normalize_insights as _domain_normalize_insights
+from token_meter.domain import notifications as _notifications
+from token_meter.models.catalog import MODEL_PRICE_FIELDS, normalize_model_id
+from token_meter.runtimes.codex import AUTO_REVIEW_MODEL, CODEX_BUILTIN_NAMESPACES
+from token_meter.app_helpers.common import (
+    BUDGET_PROVIDERS,
+    CHARS_PER_TOKEN,
+    MAX_MODEL_PRICE_PERIODS,
+    tool_identity,
+)
+
+
+MODEL_PRICE_PROVIDERS = ("claude", "codex", "cursor", "opencode", "google")
+
+
+MAX_MODEL_PRICE = 1_000_000.0
+
+
+SESSION_MODEL_IDENTITY_KEY_RE = re.compile(r"^[a-f0-9]{64}$")
+
+
+SESSION_CLAUDE_MODEL_ID_RE = re.compile(
+    r"^claude-(?:haiku|sonnet|opus)-[a-z0-9][a-z0-9._:-]{0,139}$",
+    re.IGNORECASE,
+)
+
+
+DEFAULT_RUNTIME_BUDGET = 0.0
+
+
+DEFAULT_BUDGET_THRESHOLDS = (80, 90, 100)
+
+
+DEFAULT_SESSION_BUDGET = 10.0
+
+
+MIN_SESSION_BUDGET = 0.5
+
+
+MAX_MONTHLY_BUDGET = 100_000_000.0
+
+
+MAX_SESSION_BUDGETS = 500
+
+
+UPDATE_CHECK_INTERVAL_S = 10 * 60
+
+
+def normalize_model_price_provider(provider):
+    provider = str(provider or "").strip().lower()
+    if provider == "openai":
+        provider = "codex"
+    if provider not in MODEL_PRICE_PROVIDERS:
+        raise ValueError("Provider must be Claude, Codex / OpenAI, Cursor, OpenCode, or Google Gemini.")
+    return provider
+
+
+def normalize_model_price_id(model):
+    return normalize_model_id(model)
+
+
+def normalize_model_price(prices):
+    if not isinstance(prices, dict):
+        raise ValueError("Model prices must be an object.")
+    normalized = {}
+    for field in MODEL_PRICE_FIELDS:
+        value = prices.get(field)
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise ValueError(f"{field.replace('_', ' ').title()} price must be a number.")
+        value = float(value)
+        if not math.isfinite(value) or value < 0 or value > MAX_MODEL_PRICE:
+            raise ValueError(
+                f"{field.replace('_', ' ').title()} price must be between 0 and "
+                f"{MAX_MODEL_PRICE:,.0f}."
+            )
+        normalized[field] = value
+    return normalized
+
+
+def _normalize_model_price_revision(raw, builtin):
+    if not isinstance(raw, dict):
+        raise ValueError("Model price period must be an object.")
+    effective_from = raw.get("effective_from")
+    if effective_from is not None:
+        if isinstance(effective_from, bool) or not isinstance(effective_from, (int, float)):
+            raise ValueError("Model price effective time must be a Unix timestamp.")
+        effective_from = float(effective_from)
+        if not math.isfinite(effective_from) or effective_from < 0:
+            raise ValueError("Model price effective time must be a Unix timestamp.")
+    actions = sum(("prices" in raw, raw.get("use_builtin") is True,
+                   raw.get("inactive") is True))
+    if actions != 1:
+        raise ValueError("Model price period must contain exactly one action.")
+    revision = {"effective_from": effective_from}
+    if "prices" in raw:
+        revision["prices"] = normalize_model_price(raw["prices"])
+    elif raw.get("use_builtin") is True:
+        if not builtin:
+            raise ValueError("Only bundled models can resume built-in pricing.")
+        revision["use_builtin"] = True
+    else:
+        if builtin:
+            raise ValueError("Bundled models cannot be retired.")
+        revision["inactive"] = True
+    return revision
+
+
+def _normalize_model_price_history(raw, builtin):
+    """Normalize a legacy timeless price or a bounded revision timeline."""
+    if isinstance(raw, dict) and all(field in raw for field in MODEL_PRICE_FIELDS):
+        return [{"effective_from": None, "prices": normalize_model_price(raw)}]
+    if not isinstance(raw, list) or len(raw) > MAX_MODEL_PRICE_PERIODS:
+        raise ValueError("Model price history is invalid or too long.")
+    by_effective = {}
+    for item in raw:
+        revision = _normalize_model_price_revision(item, builtin)
+        by_effective[revision["effective_from"]] = revision
+    return sorted(
+        by_effective.values(),
+        key=lambda revision: (-1 if revision["effective_from"] is None
+                              else revision["effective_from"]),
+    )
+
+
+def _normalize_model_price_scope(apply_to_all_history, effective_from, now):
+    if not isinstance(apply_to_all_history, bool):
+        raise ValueError("Apply to all history must be true or false.")
+    if effective_from is not None:
+        if isinstance(effective_from, bool) or not isinstance(effective_from, (int, float)):
+            raise ValueError("Model price effective time must be a Unix timestamp.")
+        effective_from = float(effective_from)
+        if not math.isfinite(effective_from) or effective_from < 0:
+            raise ValueError("Model price effective time must be a Unix timestamp.")
+        if effective_from > now + 300:
+            raise ValueError("Model price effective time cannot be in the future.")
+    if apply_to_all_history and effective_from is not None:
+        raise ValueError("Choose either an effective time or all history, not both.")
+    return (
+        None if apply_to_all_history else (
+            effective_from if effective_from is not None else now
+        ),
+        "all_history" if apply_to_all_history else (
+            "selected_time" if effective_from is not None else "now"
+        ),
+    )
+
+
+def _normalize_model_price_change(change):
+    if not isinstance(change, dict):
+        raise ValueError("Each model price change must be an object.")
+    provider = normalize_model_price_provider(change.get("provider"))
+    model = normalize_model_price_id(change.get("model"))
+    remove = change.get("remove", False)
+    if not isinstance(remove, bool):
+        raise ValueError("Remove must be true or false.")
+    if remove and "prices" in change:
+        raise ValueError("A model price change cannot set and remove prices together.")
+    prices = None if remove else normalize_model_price(change.get("prices"))
+    return {
+        "provider": provider,
+        "model": model,
+        "prices": prices,
+        "remove": remove,
+    }
+
+
+def _normalize_session_model_identity_revision(value):
+    if not isinstance(value, (list, tuple)) or len(value) != 2:
+        return None
+    normalized = tuple(str(item) for item in value)
+    if any(not re.fullmatch(r"[0-9]{1,24}", item) for item in normalized):
+        return None
+    return normalized
+
+
+def _normalize_session_model_identity_model(provider, model):
+    raw_provider = str(provider or "").strip().lower()
+    if raw_provider in ("hermes", "anthropic", "claude"):
+        model = normalize_model_price_id(model)
+        if (
+            model == "unknown-model"
+            or not SESSION_CLAUDE_MODEL_ID_RE.fullmatch(model)
+        ):
+            raise ValueError(
+                "Choose an exact public Claude model ID, such as claude-sonnet-5."
+            )
+        return "anthropic", model
+    provider = normalize_model_price_provider(raw_provider)
+    if provider != "codex":
+        raise ValueError("Codex session assignments require Codex / OpenAI models.")
+    model = normalize_model_price_id(model)
+    if model in ("unknown-model", AUTO_REVIEW_MODEL):
+        raise ValueError("Choose an actual Codex / OpenAI model ID.")
+    return "openai", model
+
+
+def _normalize_session_model_identity_verified(value):
+    if not isinstance(value, dict):
+        return None
+    try:
+        provider, model = _normalize_session_model_identity_model(
+            value.get("model_provider"), value.get("model"),
+        )
+    except ValueError:
+        return None
+    if provider != "openai":
+        return None
+    revision = _normalize_session_model_identity_revision(value.get("revision"))
+    parent_key = str(value.get("parent_key") or "")
+    inherited_prefix = value.get("inherited_prefix")
+    if (
+        not revision
+        or not SESSION_MODEL_IDENTITY_KEY_RE.fullmatch(parent_key)
+        or isinstance(inherited_prefix, bool)
+        or not isinstance(inherited_prefix, int)
+        or inherited_prefix < 0
+        or inherited_prefix > 1_000_000
+    ):
+        return None
+    return {
+        "model_provider": provider,
+        "model": model,
+        "revision": list(revision),
+        "parent_key": parent_key,
+        "inherited_prefix": inherited_prefix,
+    }
+
+
+def _normalize_session_model_identity_user(value):
+    if not isinstance(value, dict):
+        return None
+    try:
+        provider, model = _normalize_session_model_identity_model(
+            value.get("model_provider"), value.get("model"),
+        )
+    except ValueError:
+        return None
+    return {"model_provider": provider, "model": model}
+
+
+def normalize_session_budget_value(value, label="Session budget"):
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{label} must be a number.")
+    value = float(value)
+    if (not math.isfinite(value)
+            or value < MIN_SESSION_BUDGET
+            or value > MAX_MONTHLY_BUDGET):
+        raise ValueError(
+            f"{label} must be between "
+            f"{MIN_SESSION_BUDGET:g} and {MAX_MONTHLY_BUDGET:,.0f}."
+        )
+    return value
+
+
+def normalize_budget_settings(values):
+    """Validate one machine-wide monthly budget configuration."""
+    if values is None:
+        values = {}
+    if not isinstance(values, dict):
+        raise ValueError("Budget settings must be an object.")
+    currency = str(values.get("currency") or "USD").strip().upper()
+    if currency != "USD":
+        raise ValueError("Token Meter budgets currently support USD only.")
+
+    default_session_budget = values.get(
+        "default_session_budget", DEFAULT_SESSION_BUDGET,
+    )
+    default_session_budget = normalize_session_budget_value(
+        default_session_budget, "Default session budget",
+    )
+
+    raw_session_budgets = values.get("session_budgets") or {}
+    if not isinstance(raw_session_budgets, dict):
+        raise ValueError("Session budgets must be an object.")
+    if len(raw_session_budgets) > MAX_SESSION_BUDGETS:
+        raise ValueError(f"Token Meter supports at most {MAX_SESSION_BUDGETS} saved session budgets.")
+    session_budgets = {}
+    for raw_session_id, raw_budget in raw_session_budgets.items():
+        if not isinstance(raw_session_id, str):
+            raise ValueError("Session budget IDs must be strings.")
+        session_id = raw_session_id.strip()
+        if not session_id or len(session_id) > 240:
+            raise ValueError("Session budget IDs must be 1 to 240 characters.")
+        session_budgets[session_id] = normalize_session_budget_value(raw_budget)
+
+    raw_allocations = values.get("allocations") or {}
+    if not isinstance(raw_allocations, dict):
+        raise ValueError("Runtime allocations must be an object.")
+    unknown = sorted(set(raw_allocations) - set(BUDGET_PROVIDERS))
+    if unknown:
+        raise ValueError("Runtime allocations must use registered runtime IDs.")
+    allocations = {}
+    for provider in BUDGET_PROVIDERS:
+        value = raw_allocations.get(provider, DEFAULT_RUNTIME_BUDGET)
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise ValueError(f"{provider.title()} allocation must be a number.")
+        value = float(value)
+        if not math.isfinite(value) or value < 0 or value > MAX_MONTHLY_BUDGET:
+            raise ValueError(
+                f"{provider.title()} allocation must be between 0 and "
+                f"{MAX_MONTHLY_BUDGET:,.0f}."
+            )
+        allocations[provider] = value
+    derived_total = sum(allocations.values())
+    if derived_total > MAX_MONTHLY_BUDGET:
+        raise ValueError(
+            f"Combined runtime budget must not exceed {MAX_MONTHLY_BUDGET:,.0f}."
+        )
+    total = derived_total
+
+    raw_thresholds = values.get("thresholds", DEFAULT_BUDGET_THRESHOLDS)
+    if not isinstance(raw_thresholds, list) and not isinstance(raw_thresholds, tuple):
+        raise ValueError("Budget thresholds must be a list.")
+    thresholds = []
+    for raw in raw_thresholds:
+        if isinstance(raw, bool) or not isinstance(raw, (int, float)):
+            raise ValueError("Budget thresholds must be whole percentages.")
+        value = int(raw)
+        if value != raw or value < 1 or value > 100:
+            raise ValueError("Budget thresholds must be whole percentages from 1 to 100.")
+        thresholds.append(value)
+    if not thresholds or len(thresholds) > 10 or thresholds != sorted(set(thresholds)):
+        raise ValueError("Use 1 to 10 unique budget thresholds in increasing order.")
+
+    native_notifications = values.get("native_notifications", True)
+    if not isinstance(native_notifications, bool):
+        raise ValueError("Budget notifications must be on or off.")
+    return {
+        "currency": "USD",
+        "default_session_budget": default_session_budget,
+        "session_budgets": session_budgets,
+        "monthly_total": total,
+        "allocations": allocations,
+        "thresholds": thresholds,
+        "native_notifications": native_notifications,
+    }
+
+
+def normalize_update_settings(values):
+    """Validate the machine-wide software-update preferences."""
+    if values is None:
+        values = {}
+    if not isinstance(values, dict):
+        raise ValueError("Update settings must be an object.")
+    enabled = values.get("enabled", True)
+    auto_install = values.get("auto_install", True)
+    if not isinstance(enabled, bool) or not isinstance(auto_install, bool):
+        raise ValueError("Update preferences must be on or off.")
+    if not enabled:
+        auto_install = False
+    return {
+        "enabled": enabled,
+        "auto_install": auto_install,
+        "interval_seconds": UPDATE_CHECK_INTERVAL_S,
+    }
+
+
+MENUBAR_CACHE_TIMER_MODES = ("always", "final2", "off")
+
+
+DEFAULT_MENUBAR_CACHE_TIMER = "always"
+
+
+def normalize_menubar_settings(values):
+    """Validate the machine-wide menu-bar preferences shared by both surfaces."""
+    if values is None:
+        values = {}
+    if not isinstance(values, dict):
+        raise ValueError("Menu bar settings must be an object.")
+    mode = values.get("cache_timer", DEFAULT_MENUBAR_CACHE_TIMER)
+    if mode not in MENUBAR_CACHE_TIMER_MODES:
+        raise ValueError("Cache timer must be Always, Last 2 min, or Off.")
+    return {"cache_timer": mode}
+
+
+def normalize_notification_settings(values):
+    """Validate the machine-wide quota alert preferences shared by every companion."""
+    if not isinstance(values, dict):
+        raise ValueError("Notification settings must be an object.")
+    quota_alerts = values.get("quota_alerts")
+    if not isinstance(quota_alerts, bool):
+        raise ValueError("Quota notifications must be on or off.")
+    threshold = values.get("quota_threshold")
+    if isinstance(threshold, bool) or threshold not in _notifications.USER_QUOTA_THRESHOLDS:
+        raise ValueError("Quota alert threshold must be 80, 90, or 95 percent.")
+    return {"quota_alerts": quota_alerts, "quota_threshold": int(threshold)}
+
+
+def normalize_dynamic_tools(dynamic_tools):
+    """Flatten old function arrays and newer namespace-grouped tool catalogs."""
+    out = []
+    for item in dynamic_tools or []:
+        if not isinstance(item, dict):
+            out.append({
+                "namespace": "unknown", "name": str(item) or "?", "kind": "tool",
+                "defer_loading": False, "definition_tokens": 0,
+            })
+            continue
+        children = item.get("tools")
+        rows = children if isinstance(children, list) else [item]
+        parent_namespace = item.get("namespace") or item.get("name") or "unknown"
+        parent_deferred = bool(item.get("deferLoading"))
+        for child in rows:
+            if not isinstance(child, dict):
+                child = {"name": str(child)}
+            name = child.get("name") or "?"
+            namespace = child.get("namespace") or parent_namespace or "unknown"
+            raw_identity = name
+            host_provided = False
+            if name.startswith("mcp__"):
+                ident = tool_identity(name)
+                namespace = ident["namespace"]
+                kind = "mcp"
+            elif str(namespace).startswith("mcp__"):
+                parts = str(namespace).split("__")
+                namespace = parts[1] if len(parts) > 1 and parts[1] else "mcp"
+                raw_identity = f"mcp__{namespace}__{name}"
+                kind = "mcp"
+            elif isinstance(children, list) and namespace not in CODEX_BUILTIN_NAMESPACES:
+                raw_identity = f"mcp__{namespace}__{name}"
+                kind = "mcp"
+                host_provided = True
+            else:
+                kind = "tool"
+            definition = {
+                "description": child.get("description") or "",
+                "inputSchema": child.get("inputSchema") or child.get("input_schema") or {},
+            }
+            entry = {
+                "namespace": namespace,
+                "name": raw_identity,
+                "kind": kind,
+                "defer_loading": bool(child.get("deferLoading", parent_deferred)),
+                "definition_tokens": len(json.dumps(definition, sort_keys=True)) // CHARS_PER_TOKEN,
+            }
+            if host_provided:
+                entry["host_provided"] = True
+            out.append(entry)
+    return out[:240]
+
+
+def normalize_insights(rows, limit=12):
+    return _domain_normalize_insights(rows, limit)
diff --git a/token_meter/app_helpers/pacing.py b/token_meter/app_helpers/pacing.py
new file mode 100644
index 00000000..8053d9a4
--- /dev/null
+++ b/token_meter/app_helpers/pacing.py
@@ -0,0 +1,54 @@
+"""Pace and timing helpers."""
+
+import hashlib
+import math
+
+
+# Features are precomputed once per sample with exactly the conversions the
+# per-pair arithmetic used, so every distance is bit-identical to computing it
+# from the sample dictionaries directly.
+_PACE_TOOLS, _PACE_OUTPUT, _PACE_PEAK, _PACE_INPUT, _PACE_MODEL = range(5)
+
+
+_PACE_LOG_PEAK, _PACE_LOG_INPUT, _PACE_LOG_MODEL = range(9, 12)
+
+
+# Prefilter slack: |log2(a) - log2(b)| and |log(a / b, 2)| differ only by
+# rounding, so a pair this far outside the output gate can never pass it.
+_PACE_PREFILTER_SLACK = 1e-9
+
+
+def _pace_features(sample):
+    tools = int(sample.get("tool_calls") or 0)
+    output = max(1.0, float(sample.get("output_tokens") or 0))
+    peak = max(1.0, float(sample.get("peak_input_tokens") or sample.get("input_tokens") or 0))
+    input_value = max(1.0, float(sample.get("input_tokens") or 0))
+    model = max(1.0, float(sample.get("model_calls") or 1))
+    input_tokens = max(1, int(sample.get("input_tokens") or 0))
+    return (
+        tools,
+        output,
+        peak,
+        input_value,
+        model,
+        min(1.0, float(sample.get("cache_read_tokens") or 0) / input_tokens),
+        float(sample.get("ts") or 0),
+        max(1.0, float(tools or 0)),
+        math.log2(output),
+        math.log2(peak),
+        math.log2(input_value),
+        math.log2(model),
+    )
+
+
+def _pace_samples_signature(samples, fields):
+    """Return a stable digest of the fields that affect a pace comparison."""
+    digest = hashlib.sha256()
+    for sample in samples or ():
+        digest.update(b"\0sample\0")
+        digest.update(
+            repr(tuple(sample.get(field) for field in fields)).encode(
+                "utf-8", errors="replace",
+            )
+        )
+    return digest.hexdigest()
diff --git a/token_meter/app_helpers/pricing_values.py b/token_meter/app_helpers/pricing_values.py
new file mode 100644
index 00000000..9d87bdc3
--- /dev/null
+++ b/token_meter/app_helpers/pricing_values.py
@@ -0,0 +1,101 @@
+"""Pricing value helpers."""
+
+import datetime
+import math
+
+from token_meter.models.catalog import GPT_56_LONG_CONTEXT_TOKENS, GPT_56_PRICE_UPDATE_AT
+from token_meter.models import discounts as _discounts
+from token_meter.app_helpers.common import _cached_price_query, parse_iso
+
+
+def _price_timestamp(value):
+    """Normalize an event timestamp; ``None`` intentionally means current pricing."""
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        value = float(value)
+        return value if math.isfinite(value) else None
+    if isinstance(value, datetime.datetime):
+        if value.tzinfo is None:
+            value = value.replace(tzinfo=datetime.timezone.utc)
+        return value.timestamp()
+    if isinstance(value, str):
+        return parse_iso(value.strip())
+    return None
+
+
+def _price_datetime(value):
+    timestamp = _price_timestamp(value)
+    if timestamp is None:
+        return None
+    return datetime.datetime.fromtimestamp(timestamp, datetime.timezone.utc)
+
+
+COST_DISCOUNTS_VERSION = 1
+
+
+def _cost_discount_state_from_raw(raw):
+    """Validate a stored ``cost_discounts`` value, keeping every valid rule."""
+    malformed = []
+    if isinstance(raw, dict):
+        rules, invalid = _discounts.normalize_rules_lenient(raw.get("rules"), malformed)
+        channels = _discounts.normalize_runtime_channels(raw.get("runtime_channels"))
+    else:
+        rules, invalid = [], (0 if raw is None else 1)
+        channels = _discounts.normalize_runtime_channels(None)
+    # Only this build's exact format (version 1, or no version, with a list of rules)
+    # is ever rewritten; anything else is read for what this build understands.
+    shape_ok = raw is None or (
+        isinstance(raw, dict)
+        and ("version" not in raw
+             or (type(raw["version"]) is int and raw["version"] == COST_DISCOUNTS_VERSION))
+        and isinstance(raw.get("rules", []), list)
+    )
+    version = raw.get("version") if isinstance(raw, dict) else None
+    newer = (isinstance(version, (int, float)) and not isinstance(version, bool)
+             and version > COST_DISCOUNTS_VERSION)
+    return {
+        "read_only": not shape_ok,
+        "read_only_reason": None if shape_ok else ("newer_version" if newer else "unsupported_format"),
+        # Entries invalid on their own are kept verbatim on the next write, still ignored for pricing.
+        "dropped": tuple(malformed),
+        "rules": tuple(rules),
+        "runtime_channels": channels,
+        "invalid": invalid,
+        "index": _discounts.build_index(rules),
+        "revision": _discounts.revision(rules, channels),
+    }
+
+
+def _price_query_from_compat(model_provider, model, variant=None, at=None):
+    """Construct a bounded cached request for the compatibility facade."""
+    model_id = str(model or "").strip() or "unknown-model"
+    if len(model_id) > 160:
+        model_id = "unknown-model"
+    variant = str(variant).strip() if variant is not None else None
+    return _cached_price_query(
+        model_provider, model_id, variant or None, _price_timestamp(at)
+    )
+
+
+def _price_multipliers(u, model, provider, at=None):
+    """Return current published long-context multipliers without repricing history."""
+    timestamp = _price_timestamp(at)
+    if timestamp is not None and timestamp < GPT_56_PRICE_UPDATE_AT:
+        return 1.0, 1.0
+    compact = str(model or "").replace(" ", "-").lower()
+    # Codex bills credits and subscriptions, which OpenAI documents without the API's
+    # long-context surcharge; Cursor passes API pricing through.
+    if (provider != "cursor" or
+            not compact.startswith(("gpt-5.6", "gpt-6-", "gpt-6.1-"))):
+        return 1.0, 1.0
+    input_tokens = (
+        int(u.get("input_tokens", 0) or 0)
+        + int(u.get("cache_creation_input_tokens", 0) or 0)
+        + int(u.get("cache_read_input_tokens", 0) or 0)
+    )
+    if input_tokens > GPT_56_LONG_CONTEXT_TOKENS:
+        return 2.0, 1.5
+    return 1.0, 1.0
diff --git a/token_meter/app_helpers/settings_values.py b/token_meter/app_helpers/settings_values.py
new file mode 100644
index 00000000..a9c87934
--- /dev/null
+++ b/token_meter/app_helpers/settings_values.py
@@ -0,0 +1,41 @@
+"""Settings value validation helpers."""
+
+
+
+
+def _update_message(state, error_code="", latest_revision=""):
+    if state == "disabled":
+        return "Automatic update checks are off."
+    if state == "checking":
+        return "Checking the configured Git upstream."
+    if state == "updating":
+        return "Pulling and reinstalling Token Meter."
+    if state == "updated":
+        return "Token Meter was updated successfully."
+    if state == "available":
+        return (
+            f"Version {latest_revision} is ready to install."
+            if latest_revision else "A new version is ready to install."
+        )
+    if state == "current":
+        return "This installation matches its configured upstream."
+    if state == "waiting":
+        return "Waiting for the first update check."
+    messages = {
+        "source_unavailable": "The installed source checkout is unavailable.",
+        "git_unavailable": "Git is unavailable, so Token Meter cannot check for updates.",
+        "upstream_unavailable": "The source checkout has no usable tracking upstream.",
+        "unsupported_update_branch": "Automatic updates require a main checkout tracking a remote main branch.",
+        "fetch_failed": "Token Meter could not fetch the configured Git upstream.",
+        "inspect_failed": "Token Meter could not compare the installed and upstream revisions.",
+        "dirty_checkout": "An update exists, but the source checkout has local changes.",
+        "diverged_checkout": "An update exists, but the source checkout has diverged.",
+        "launch_failed": "Token Meter could not start the updater.",
+        "linux_helper_unavailable": (
+            "The installed Linux update helper is unavailable. "
+            "Reinstall Token Meter to repair automatic updates."
+        ),
+        "install_failed": "The update did not install. The existing checkout needs attention.",
+        "update_interrupted": "The last update stopped before it finished. Try installing it again.",
+    }
+    return messages.get(error_code, "Update status is unavailable.")

From 316d689eece3bcc0f518a8f497d952b9b61c847c Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 09:00:41 +0530
Subject: [PATCH 6/9] chore(agents): add bounded lookup helpers and condense
 delivery-flow rules

- scripts/show [FILE] NAME prints one Python or dashboard JS definition
  with line numbers, replacing wide grep and sed -n probes (about 46% of
  carried tool output in October's sessions).
- specs/AGENTS.md is loaded on every turn of every session and subagent.
  The reporter, PR-status, and contributor-acknowledgment procedures,
  which the intake, github-ops, and communication skills already spell out,
  shrink to a pointer that keeps their authority limits.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 AGENTS.md                   |  54 +++++-------------
 scripts/show                | 108 ++++++++++++++++++++++++++++++++++++
 specs/AGENTS.md             |  54 +++++-------------
 tests/test_agent_helpers.py |  44 +++++++++++++++
 4 files changed, 182 insertions(+), 78 deletions(-)
 create mode 100755 scripts/show
 create mode 100644 tests/test_agent_helpers.py

diff --git a/AGENTS.md b/AGENTS.md
index a31a0b60..dcecae5a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -59,7 +59,8 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `python3 -m unittest tests.contracts.test_design_system -v` | Check dashboard styling against the design-system contract |
 | `PYTHONPYCACHEPREFIX=/private/tmp/token-meter-pycache python3 -m py_compile meter.py token_meter_mcp.py $(find token_meter -type f -name '*.py' -print)` | Compile Python without polluting the repo |
 | `scripts/check-page` | Assemble the dashboard and parse its JavaScript |
-| `bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux scripts/setup-work-classifier` | Check shell syntax |
+| `scripts/show [FILE] NAME` | Print one Python or dashboard JS definition with line numbers; use it instead of a wide grep or `sed -n` range |
+| `bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux scripts/setup-work-classifier scripts/check-page` | Check shell syntax |
 | `swiftc menubar/TokenMeterMenuBar.swift -o /private/tmp/token-meter-menubar` | Compile the native companion |
 | `TOKEN_METER_MENUBAR_SMOKE=1 /private/tmp/token-meter-menubar` | Run deterministic native smoke output |
 | `powershell -NoProfile -Command "[void] [scriptblock]::Create((Get-Content -Raw scripts/install-windows.ps1))"` | Parse a Windows script on a Windows host |
@@ -200,44 +201,19 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 - Before final handoff, report files changed, exact validation results,
   installed-runtime checks when applicable, review findings and disposition,
   and anything not verified.
-- When Pratik explicitly asks to start the Token Meter team flow or manage a
-  linked reporter request end to end, use the `reporter-end-to-end` route. That
-  request is standing approval to commit only the scoped files so independent
-  gates can bind to that exact commit. After all required gates pass, push its
-  dedicated `codex/` branch, open the linked pull request, post detailed testing
-  instructions on the linked GitHub issue, and post one concise follow-up in the
-  existing Slack thread. Recheck and read back every write; do not pause for
-  another approval between these bounded delivery steps.
-- For `reporter-end-to-end`, GitHub owns clone, checkout, install, health-check,
-  restoration, measurement, and procedural next steps. The communication
-  manager first drafts the pull request from the gated commit. After the GitHub
-  operator creates and reads back the pull request, the communication manager
-  uses its real URL to draft the detailed linked-issue handoff and a separate
-  Slack reply. The Slack reply is one short paragraph that thanks the reporter,
-  links the pull request, briefly asks them to try it, and identifies the reply
-  as from Pratik's agent. Do not put code, commands, clone/install steps,
-  procedural next steps, a test matrix, or a long technical summary in Slack.
-- `reporter-end-to-end` standing approval does not include merge, release,
-  close, label changes, or hosted review requests. It applies only to the linked
-  issue/thread and only when the exact head has current required evidence with
-  no open finding.
-- When the user authorizes checking out, reviewing, or managing pull requests,
-  post one contributor-facing status reply on each inspected PR after checking
-  its current head and discussion. Thank the contributor, state the
-  evidence-backed merge status or next step, and identify the reply as from
-  Pratik's agent. Mention a follow-up only when the team owns an actual next
-  action; when the work is complete, do not promise one. Do not duplicate an
-  equivalent same-head status reply. The PR-management request is standing
-  approval for these replies only; merges, closes, pushes, review requests,
-  and unrelated actions remain separately gated unless that request explicitly
-  authorizes them.
-- When a contributor later reports results after Pratik's agent asked them to
-  check out or test a pull request, acknowledge every existing discussion
-  thread containing those results. Thank them, state any actual next action
-  without inventing a diagnosis or deadline, and identify the reply as from
-  Pratik's agent. Omit a follow-up promise when the work is complete. Keep Slack
-  to the same short follow-up contract with no code or procedural next steps.
-  This is standing approval for that narrow acknowledgment.
+- Delivery flows and their standing approvals live in skills; load the skill
+  before acting:
+  - `reporter-end-to-end` (Pratik explicitly asks to start the Token Meter team
+    flow or manage a linked reporter request): `token-meter-intake` and
+    `token-meter-github-ops`. It authorizes commit, push of a dedicated
+    `codex/` branch, the linked pull request, the issue testing handoff, and
+    one short Slack reply signed as Pratik's agent. GitHub owns clone, install,
+    and procedural next steps; Slack gets no code or procedural next steps. It
+    never includes merge, release, close, label changes, or hosted review
+    requests.
+  - Pull-request status replies and contributor result acknowledgments, also
+    signed as Pratik's agent: `token-meter-github-ops` and
+    `token-meter-communication`.
 - Commits, pushes, pull requests, reviews posted to GitHub, Slack messages,
   releases, and other external side effects require explicit user approval.
 
diff --git a/scripts/show b/scripts/show
new file mode 100755
index 00000000..3a3d85e9
--- /dev/null
+++ b/scripts/show
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Print one definition with its line numbers, instead of a wide grep or sed range.
+
+    scripts/show NAME            find NAME in token_meter/, dashboard/js/, and tests/
+    scripts/show FILE NAME       look only in FILE
+
+Python: a top-level or class-level def/class (or NAME = ...). JavaScript:
+`function NAME(`, `async function NAME(`, or `const|let NAME=`; the block ends
+at its matching brace. Prints `path:line` headers so an edit can target them.
+"""
+
+import ast
+import os
+import re
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+SEARCH = ("token_meter", "dashboard/js", "tests", "meter.py", "token_meter_mcp.py")
+MAX_LINES = 400
+
+
+def python_spans(path, name):
+    with open(path, encoding="utf-8") as handle:
+        source = handle.read()
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+    spans = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)) and node.name == name:
+            start = node.decorator_list[0].lineno if node.decorator_list else node.lineno
+            spans.append((start, node.end_lineno))
+        elif isinstance(node, ast.Assign) and any(
+            isinstance(target, ast.Name) and target.id == name for target in node.targets
+        ) and node.col_offset == 0:
+            spans.append((node.lineno, node.end_lineno))
+    return spans
+
+
+def js_spans(path, name):
+    with open(path, encoding="utf-8") as handle:
+        lines = handle.read().split("\n")
+    pattern = re.compile(
+        r"^\s*(?:async\s+)?function\s+" + re.escape(name) + r"\s*\(|^\s*(?:const|let|var)\s+" + re.escape(name) + r"\s*="
+    )
+    spans = []
+    for index, line in enumerate(lines):
+        if not pattern.search(line):
+            continue
+        depth, opened, end = 0, False, index
+        for offset in range(index, min(len(lines), index + MAX_LINES)):
+            text = re.sub(r"(['\"`])(?:\\.|(?!\1).)*\1", "", lines[offset])
+            depth += text.count("{") - text.count("}")
+            opened = opened or "{" in text
+            end = offset
+            if (opened and depth <= 0) or (not opened and text.rstrip().endswith(";")):
+                break
+        spans.append((index + 1, end + 1))
+    return spans
+
+
+def candidates(scope):
+    for entry in scope:
+        path = os.path.join(ROOT, entry)
+        if os.path.isfile(path):
+            yield path
+        for folder, _, files in os.walk(path):
+            for filename in sorted(files):
+                if filename.endswith((".py", ".js")):
+                    yield os.path.join(folder, filename)
+
+
+def show(name, scope):
+    found = 0
+    for path in candidates(scope):
+        spans = python_spans(path, name) if path.endswith(".py") else js_spans(path, name)
+        if not spans:
+            continue
+        with open(path, encoding="utf-8") as handle:
+            lines = handle.read().split("\n")
+        for start, end in spans:
+            found += 1
+            shown_end = min(end, start + MAX_LINES - 1)
+            print(f"{os.path.relpath(path, ROOT)}:{start}-{end}")
+            for number in range(start, shown_end + 1):
+                print(f"{number:>6}  {lines[number - 1]}")
+            if shown_end < end:
+                print(f"  ... {end - shown_end} more lines")
+    return found
+
+
+def main(argv):
+    if len(argv) == 2:
+        name, scope = argv[1], SEARCH
+    elif len(argv) == 3:
+        name, scope = argv[2], (argv[1],)
+    else:
+        print(__doc__.strip(), file=sys.stderr)
+        return 2
+    if not show(name, scope):
+        print(f"{name}: not found", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))
diff --git a/specs/AGENTS.md b/specs/AGENTS.md
index 107efee6..9b03f506 100644
--- a/specs/AGENTS.md
+++ b/specs/AGENTS.md
@@ -57,7 +57,8 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 | `python3 -m unittest tests.contracts.test_design_system -v` | Check dashboard styling against the design-system contract |
 | `PYTHONPYCACHEPREFIX=/private/tmp/token-meter-pycache python3 -m py_compile meter.py token_meter_mcp.py $(find token_meter -type f -name '*.py' -print)` | Compile Python without polluting the repo |
 | `scripts/check-page` | Assemble the dashboard and parse its JavaScript |
-| `bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux scripts/setup-work-classifier` | Check shell syntax |
+| `scripts/show [FILE] NAME` | Print one Python or dashboard JS definition with line numbers; use it instead of a wide grep or `sed -n` range |
+| `bash -n scripts/install scripts/install-linux scripts/install-launch-agent scripts/install-systemd-user scripts/run-menubar scripts/run-token-meter-mcp scripts/start-token-meter scripts/uninstall-launch-agent scripts/uninstall-systemd-user scripts/update scripts/update-linux scripts/setup-work-classifier scripts/check-page` | Check shell syntax |
 | `swiftc menubar/TokenMeterMenuBar.swift -o /private/tmp/token-meter-menubar` | Compile the native companion |
 | `TOKEN_METER_MENUBAR_SMOKE=1 /private/tmp/token-meter-menubar` | Run deterministic native smoke output |
 | `powershell -NoProfile -Command "[void] [scriptblock]::Create((Get-Content -Raw scripts/install-windows.ps1))"` | Parse a Windows script on a Windows host |
@@ -198,44 +199,19 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
 - Before final handoff, report files changed, exact validation results,
   installed-runtime checks when applicable, review findings and disposition,
   and anything not verified.
-- When Pratik explicitly asks to start the Token Meter team flow or manage a
-  linked reporter request end to end, use the `reporter-end-to-end` route. That
-  request is standing approval to commit only the scoped files so independent
-  gates can bind to that exact commit. After all required gates pass, push its
-  dedicated `codex/` branch, open the linked pull request, post detailed testing
-  instructions on the linked GitHub issue, and post one concise follow-up in the
-  existing Slack thread. Recheck and read back every write; do not pause for
-  another approval between these bounded delivery steps.
-- For `reporter-end-to-end`, GitHub owns clone, checkout, install, health-check,
-  restoration, measurement, and procedural next steps. The communication
-  manager first drafts the pull request from the gated commit. After the GitHub
-  operator creates and reads back the pull request, the communication manager
-  uses its real URL to draft the detailed linked-issue handoff and a separate
-  Slack reply. The Slack reply is one short paragraph that thanks the reporter,
-  links the pull request, briefly asks them to try it, and identifies the reply
-  as from Pratik's agent. Do not put code, commands, clone/install steps,
-  procedural next steps, a test matrix, or a long technical summary in Slack.
-- `reporter-end-to-end` standing approval does not include merge, release,
-  close, label changes, or hosted review requests. It applies only to the linked
-  issue/thread and only when the exact head has current required evidence with
-  no open finding.
-- When the user authorizes checking out, reviewing, or managing pull requests,
-  post one contributor-facing status reply on each inspected PR after checking
-  its current head and discussion. Thank the contributor, state the
-  evidence-backed merge status or next step, and identify the reply as from
-  Pratik's agent. Mention a follow-up only when the team owns an actual next
-  action; when the work is complete, do not promise one. Do not duplicate an
-  equivalent same-head status reply. The PR-management request is standing
-  approval for these replies only; merges, closes, pushes, review requests,
-  and unrelated actions remain separately gated unless that request explicitly
-  authorizes them.
-- When a contributor later reports results after Pratik's agent asked them to
-  check out or test a pull request, acknowledge every existing discussion
-  thread containing those results. Thank them, state any actual next action
-  without inventing a diagnosis or deadline, and identify the reply as from
-  Pratik's agent. Omit a follow-up promise when the work is complete. Keep Slack
-  to the same short follow-up contract with no code or procedural next steps.
-  This is standing approval for that narrow acknowledgment.
+- Delivery flows and their standing approvals live in skills; load the skill
+  before acting:
+  - `reporter-end-to-end` (Pratik explicitly asks to start the Token Meter team
+    flow or manage a linked reporter request): `token-meter-intake` and
+    `token-meter-github-ops`. It authorizes commit, push of a dedicated
+    `codex/` branch, the linked pull request, the issue testing handoff, and
+    one short Slack reply signed as Pratik's agent. GitHub owns clone, install,
+    and procedural next steps; Slack gets no code or procedural next steps. It
+    never includes merge, release, close, label changes, or hosted review
+    requests.
+  - Pull-request status replies and contributor result acknowledgments, also
+    signed as Pratik's agent: `token-meter-github-ops` and
+    `token-meter-communication`.
 - Commits, pushes, pull requests, reviews posted to GitHub, Slack messages,
   releases, and other external side effects require explicit user approval.
 
diff --git a/tests/test_agent_helpers.py b/tests/test_agent_helpers.py
new file mode 100644
index 00000000..f08ebbc7
--- /dev/null
+++ b/tests/test_agent_helpers.py
@@ -0,0 +1,44 @@
+import shutil
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def run(*args):
+    return subprocess.run(args, cwd=ROOT, capture_output=True, text=True, timeout=60)
+
+
+class ShowHelperTests(unittest.TestCase):
+    def test_prints_a_dashboard_function_with_its_location(self):
+        result = run(sys.executable, "scripts/show", "renderTrendDelta")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        first, *body = result.stdout.splitlines()
+        self.assertRegex(first, r"^dashboard/js/[\w-]+\.js:\d+-\d+$")
+        self.assertIn("function renderTrendDelta(", body[0])
+        self.assertTrue(body[-1].strip().endswith("}"))
+
+    def test_prints_a_python_definition_from_one_file(self):
+        result = run(sys.executable, "scripts/show", "token_meter/dashboard_page.py", "part_names")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(result.stdout.startswith("token_meter/dashboard_page.py:"))
+        self.assertIn("def part_names(manifest):", result.stdout)
+
+    def test_missing_name_fails_without_output(self):
+        result = run(sys.executable, "scripts/show", "noSuchDashboardFunctionAnywhere")
+        self.assertEqual(result.returncode, 1)
+        self.assertEqual(result.stdout, "")
+
+
+@unittest.skipUnless(shutil.which("node"), "Node.js is required to parse dashboard JavaScript")
+class CheckPageTests(unittest.TestCase):
+    def test_assembles_and_parses_the_dashboard(self):
+        result = run("bash", "scripts/check-page")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), "js ok")
+
+
+if __name__ == "__main__":
+    unittest.main()

From bf6085306e4bb8fd16545049f40e7dceabc488b9 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 09:15:18 +0530
Subject: [PATCH 7/9] fix: address review findings on the session-cost split

- Dashboard parts no longer end in a blank line (git diff --check was red):
  the splitter now moves leading blank lines with each anchor. Re-split
  from the old page.html; the assembled page is still byte-identical.
- /health reports page_ready and ok only when every manifest part exists,
  so a partial runtime no longer reads as ready while / returns 503.
- specs/CONTRIBUTING.md documents a rehearsed three-way port for branches
  that still edit page.html or tests/test_meter.py; split-dashboard refuses
  a folder that already holds parts.
- A contract test rejects patching names that moved into app_helpers
  through meter.
- dashboard/ counts as frontend only as a folder (dashboards?/), with a
  negative test case.
- specs/AGENTS.md delivery bullets restate their gating and scope limits.
- Stale page.html references updated; plan header notes implementation.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 .impeccable/surfaces/page-html.md             |  4 +-
 AGENTS.md                                     | 12 ++++--
 dashboard/js/all-sessions.js                  |  1 -
 dashboard/js/capabilities.js                  |  2 +-
 dashboard/js/charts.js                        |  1 +
 dashboard/js/core.js                          |  1 -
 dashboard/js/current-sessions.js              |  2 +-
 dashboard/js/deck.js                          |  2 +-
 dashboard/js/efficiency.js                    |  1 +
 dashboard/js/git.js                           |  2 +
 dashboard/js/goals.js                         |  1 +
 dashboard/js/live.js                          |  1 +
 dashboard/js/models.js                        |  1 -
 dashboard/js/motion-readouts.js               |  2 -
 dashboard/js/notifications-settings.js        |  1 +
 dashboard/js/router.js                        |  1 -
 dashboard/js/session-budgets-filters.js       |  1 -
 dashboard/js/session-detail.js                |  1 -
 dashboard/js/session-logs-compare.js          |  1 +
 dashboard/js/spend.js                         |  1 +
 dashboard/js/theme-navigation.js              |  2 +-
 dashboard/js/work-insights.js                 |  1 -
 dashboard/markup/efficiency-work.html         |  1 +
 dashboard/markup/git-learn-tools.html         |  1 -
 dashboard/markup/settings.html                |  1 +
 dashboard/markup/shell.html                   |  1 -
 dashboard/markup/spend.html                   |  2 +-
 dashboard/markup/subagents-models.html        |  2 +-
 performance.html                              |  2 +-
 scripts/split-dashboard                       | 19 ++++++---
 specs/AGENTS.md                               | 12 ++++--
 specs/CONTRIBUTING.md                         | 32 ++++++++++++++
 .../plans/2026-11-06-session-cost-refactor.md |  4 +-
 tests/contracts/test_architecture_guards.py   | 23 ++++++++++
 tests/test_dashboard_page.py                  | 42 +++++++++++++++++++
 tests/test_work_requests.py                   |  2 +-
 token_meter/app.py                            |  8 ++--
 token_meter/app_helpers/common.py             | 11 +++++
 token_meter/dashboard_page.py                 |  8 ++++
 token_meter/domain/work_evidence.py           |  2 +-
 40 files changed, 176 insertions(+), 39 deletions(-)

diff --git a/.impeccable/surfaces/page-html.md b/.impeccable/surfaces/page-html.md
index 3c7afb23..986e998e 100644
--- a/.impeccable/surfaces/page-html.md
+++ b/.impeccable/surfaces/page-html.md
@@ -1,14 +1,14 @@
 ---
 version: 1
 slug: "page-html"
-primary_target: "page.html"
+primary_target: "dashboard/"
 related_targets: []
 ---
 
 # Shared dashboard spectrum system
 
 - Mode: Operate.
-- Scope: all seven top-level routes in `page.html`, including Sessions overview/detail and its Run/Activity/Tools/Insights/Alerts panels.
+- Scope: all seven top-level routes in the dashboard (`dashboard/` parts), including Sessions overview/detail and its Run/Activity/Tools/Insights/Alerts panels.
 - Audience: a developer monitoring and reviewing local Claude, Codex, and Cursor evidence.
 - Primary job: move from live Sessions through Logs, Spend, Models, Tools, Learn, and Settings without relearning the visual language.
 - Required interactions: top-level navigation, route controls, filters, tables, cards, Sessions selection and reordering, deep links, settings anchors, tooltips, and narrow-width navigation.
diff --git a/AGENTS.md b/AGENTS.md
index dcecae5a..6ad06aa3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -205,15 +205,19 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
   before acting:
   - `reporter-end-to-end` (Pratik explicitly asks to start the Token Meter team
     flow or manage a linked reporter request): `token-meter-intake` and
-    `token-meter-github-ops`. It authorizes commit, push of a dedicated
-    `codex/` branch, the linked pull request, the issue testing handoff, and
-    one short Slack reply signed as Pratik's agent. GitHub owns clone, install,
+    `token-meter-github-ops`. Only after every required gate passes on the
+    exact head with no open finding, it authorizes committing only the scoped
+    files, pushing a dedicated `codex/` branch, the linked pull request, the
+    issue testing handoff, and one short Slack reply in the existing thread
+    signed as Pratik's agent, for that linked issue and thread only. GitHub owns clone, install,
     and procedural next steps; Slack gets no code or procedural next steps. It
     never includes merge, release, close, label changes, or hosted review
     requests.
   - Pull-request status replies and contributor result acknowledgments, also
     signed as Pratik's agent: `token-meter-github-ops` and
-    `token-meter-communication`.
+    `token-meter-communication`. Those approvals cover only one non-duplicate
+    reply per inspected head or result thread; merges, closes, pushes, review
+    requests, and every other action stay separately gated.
 - Commits, pushes, pull requests, reviews posted to GitHub, Slack messages,
   releases, and other external side effects require explicit user approval.
 
diff --git a/dashboard/js/all-sessions.js b/dashboard/js/all-sessions.js
index 19fc021b..32c4ac5e 100644
--- a/dashboard/js/all-sessions.js
+++ b/dashboard/js/all-sessions.js
@@ -189,4 +189,3 @@ function renderAllSessionStats(sessions){
  setLogText($('lf-model-count'),`${f(ranked.length)} ${countWord(ranked.length,'model')}`);
  setLogHtml($('lf-models'),ranked.length?ranked.slice(0,4).map(row=>`<div class=logModelRow><div><div class=logModelName title="${esc(row.model)} · ${esc(row.runtime)}">${esc(row.model)} · ${esc(row.runtime)}</div><div class=logModelMeta>${f(row.sessions)} ${countWord(row.sessions,'session')} · ${f(row.executions)} execs · ${row.tokenCovered?compactNumber(row.input)+' in · '+compactNumber(row.output)+' out'+(row.estimated?' · includes local estimates':''):'token evidence unavailable'}</div></div><div class=logModelValue><b class=mono>${costValueHtml(money(row.cost),Boolean(row.costCovered))}</b><span>${row.costCovered?pct(totals.cost?row.cost/totals.cost:0)+' of covered cost'+(row.estimated?' · API-rate estimate':''):'billing unavailable'}</span></div></div>`).join('')+(ranked.length>4?`<div class=logModelEmpty>+${f(ranked.length-4)} more ${countWord(ranked.length-4,'model runtime')}</div>`:''):'<div class=logModelEmpty>No model data for these filters</div>');
 }
-
diff --git a/dashboard/js/capabilities.js b/dashboard/js/capabilities.js
index caf5fafb..b26582e5 100644
--- a/dashboard/js/capabilities.js
+++ b/dashboard/js/capabilities.js
@@ -1,3 +1,4 @@
+
 const CAPABILITY_SORT_KEYS=new Set(['name','type','runtime','state','use','last','control']);
 const CAPABILITY_TYPES=new Set(['all','tool','mcp','skill']);
 const CAPABILITY_PAGE_SIZE=100;
@@ -495,4 +496,3 @@ $('c-mobile-sort').onchange=e=>{
 };
 paintCapabilityFilters();
 paintCapabilitySort();
-
diff --git a/dashboard/js/charts.js b/dashboard/js/charts.js
index d0f135f4..05654990 100644
--- a/dashboard/js/charts.js
+++ b/dashboard/js/charts.js
@@ -1,3 +1,4 @@
+
 const cssVar=name=>getComputedStyle(document.documentElement).getPropertyValue(name).trim();
 // viewBox font size that renders at least `px` CSS pixels in a scaled SVG; never shrinks text.
 const svgTextPx=(svg,VW,VH,px=11)=>{const box=svg.getBoundingClientRect(),scale=Math.min(box.width/VW||1,box.height/VH||1);return +(px/Math.min(1,scale)).toFixed(1);};
diff --git a/dashboard/js/core.js b/dashboard/js/core.js
index 636880d9..c85e2dfc 100644
--- a/dashboard/js/core.js
+++ b/dashboard/js/core.js
@@ -393,4 +393,3 @@ function openSessionScope(scope,{replace=false}={}){
  applyHashRoute();
  return sessionScope==='all'?allSessionInventory||[]:sessionScope==='compare'?compareData?.sessions||[]:sessionScope==='subagents'?LATEST?.xsession?.agent_usage?.inventory||[]:LATEST?.xsession?.current_sessions||[];
 }
-
diff --git a/dashboard/js/current-sessions.js b/dashboard/js/current-sessions.js
index 4765f423..21a3a258 100644
--- a/dashboard/js/current-sessions.js
+++ b/dashboard/js/current-sessions.js
@@ -1,3 +1,4 @@
+
 const CACHE_RING_TICKS=30,CACHE_RING_SIZE=40;
 function cacheRingState(win,now=Date.now()/1000){
  const anchor=Number(win?.anchor_ts),windowS=Number(win?.window_s);
@@ -632,4 +633,3 @@ currentSessionGrid.addEventListener('keydown',event=>{
  renderCurrentSessions();
  requestAnimationFrame(()=>focusCurrentSessionCard(id));
 });
-
diff --git a/dashboard/js/deck.js b/dashboard/js/deck.js
index 533df69b..8e581729 100644
--- a/dashboard/js/deck.js
+++ b/dashboard/js/deck.js
@@ -1,3 +1,4 @@
+
 // deck-pure-start: tour storage, slide copy, and frame markup. Nothing here touches the DOM, so tests run it in Node.
 const WELCOME_KEY='tm_welcome_v1';
 const LEGACY_ONBOARDING_KEY='tm_onboarding_v1';
@@ -376,4 +377,3 @@ $('tour-return').onclick=returnToTour;
 restoreTourReturn();
 window.addEventListener('popstate',()=>{if(tourReturn&&location.hash===tourReturn.hash)returnToTour();});
 $('learn-play').onclick=()=>openWelcome(deckHosts.learn.index,{fromLearn:true});
-
diff --git a/dashboard/js/efficiency.js b/dashboard/js/efficiency.js
index eadd7ba3..7a499ca3 100644
--- a/dashboard/js/efficiency.js
+++ b/dashboard/js/efficiency.js
@@ -1,3 +1,4 @@
+
 const MODEL_COUNTER_KEYS=['input_tokens','output_tokens','io_covered_input_tokens','io_covered_output_tokens','cost_covered_output_tokens','cost_covered_cost','executions','token_covered_executions','io_covered_executions','cost_covered_executions','cost','cache_read_tokens','cache_write_tokens','cache_covered_input_tokens','reasoning_tokens','reasoning_output_tokens','reasoning_executions','reasoning_unavailable_executions','thinking_executions','thinking_covered_executions','attempts','retries','failed_attempts','attempt_samples','timed_output_tokens','timed_seconds','timed_samples','tool_free_output_tokens','tool_free_seconds','tool_free_samples','ttft_total_s','ttft_samples','wait_seconds','wait_samples','user_pause_seconds'];
 const MODEL_ARRAY_KEYS=['wait_durations_s','workload_peak_inputs','workload_outputs','workload_tool_calls','workload_model_calls','workload_cache_ratios'];
 const EFFICIENCY_RANGES=['today','yesterday','7','30','90','month','last_month','all'];
diff --git a/dashboard/js/git.js b/dashboard/js/git.js
index ad97f41f..35ff57b5 100644
--- a/dashboard/js/git.js
+++ b/dashboard/js/git.js
@@ -1,3 +1,5 @@
+
+
 function deliveryProjectName(value){return String(value||'').split(' · ')[0]||'Local project';}
 function deliveryPercent(value){
  const number=Number(value);
diff --git a/dashboard/js/goals.js b/dashboard/js/goals.js
index f40837d5..5b80f18a 100644
--- a/dashboard/js/goals.js
+++ b/dashboard/js/goals.js
@@ -1,3 +1,4 @@
+
 let GOALS=null,goalsLoading=null,goalsLoadedAt=0,goalDraft=null,goalPreviewRequest=0,goalsListModes={},goalModelRequest=0,goalModelTimer=0;
 const GOAL_STATUS_LABELS={on_track:'On track',at_risk:'At risk',met:'Met',missed:'Missed',no_result:'No result',ended:'Ended'};
 const GOAL_CONFIDENCE={complete:'Complete data',partial:'Partial data',estimated:'Estimated'};
diff --git a/dashboard/js/live.js b/dashboard/js/live.js
index eb4c3b85..32b5c542 100644
--- a/dashboard/js/live.js
+++ b/dashboard/js/live.js
@@ -1,3 +1,4 @@
+
 function selectSession(id,{updateUrl=true,replace=false,show=true,returnScope=sessionScope}={}){
  id=String(id||'').trim();
  if(!id)return Promise.resolve();
diff --git a/dashboard/js/models.js b/dashboard/js/models.js
index 37a771c3..ce52302f 100644
--- a/dashboard/js/models.js
+++ b/dashboard/js/models.js
@@ -358,4 +358,3 @@ function renderModelStats(stats){
 	 drawModelTrend(chart);
 	 restoreModelFocus(focus);
 }
-
diff --git a/dashboard/js/motion-readouts.js b/dashboard/js/motion-readouts.js
index b40f7eed..92f3ed0b 100644
--- a/dashboard/js/motion-readouts.js
+++ b/dashboard/js/motion-readouts.js
@@ -99,5 +99,3 @@ window.addEventListener('resize',()=>{
   if(spendInsightPayload)drawSpendScatter(spendInsightPayload.sessions||[]);
  },100);
 });
-
-
diff --git a/dashboard/js/notifications-settings.js b/dashboard/js/notifications-settings.js
index f68ad889..546a6c8d 100644
--- a/dashboard/js/notifications-settings.js
+++ b/dashboard/js/notifications-settings.js
@@ -1,3 +1,4 @@
+
 const canNotify=('Notification' in window);
 const notifySecure=window.isSecureContext||['localhost','127.0.0.1','::1'].includes(location.hostname);
 const notifyWanted=localStorage.getItem('tm_notify')==='1';
diff --git a/dashboard/js/router.js b/dashboard/js/router.js
index f2c0df61..fad76c69 100644
--- a/dashboard/js/router.js
+++ b/dashboard/js/router.js
@@ -184,4 +184,3 @@ function mountSubagentExplorer(destination){
 applyLocationRoute();
 window.addEventListener('hashchange',applyHashRoute);
 window.addEventListener('popstate',applyLocationRoute);
-
diff --git a/dashboard/js/session-budgets-filters.js b/dashboard/js/session-budgets-filters.js
index a3ca37bf..05c970c1 100644
--- a/dashboard/js/session-budgets-filters.js
+++ b/dashboard/js/session-budgets-filters.js
@@ -456,4 +456,3 @@ $('g-active-filters').onclick=event=>{
 $('g-sort').onclick=e=>{ if(e.target.dataset.gsort){ globalSort=e.target.dataset.gsort; localStorage.setItem('tm_global_sort',globalSort); paintGlobalSort(); if(LATEST) renderAllSessions(LATEST.xsession); } };
 paintGlobalSort();
 paintGlobalFilters();
-
diff --git a/dashboard/js/session-detail.js b/dashboard/js/session-detail.js
index 23dc15ba..0e33273f 100644
--- a/dashboard/js/session-detail.js
+++ b/dashboard/js/session-detail.js
@@ -439,4 +439,3 @@ $('session-model-identity-remove').onclick=async()=>{
   showAppToast({title:'Session model could not be cleared',body:error.message||String(error),kind:'warn',sticky:true});
  }
 };
-
diff --git a/dashboard/js/session-logs-compare.js b/dashboard/js/session-logs-compare.js
index 6de680ab..2053b117 100644
--- a/dashboard/js/session-logs-compare.js
+++ b/dashboard/js/session-logs-compare.js
@@ -1,3 +1,4 @@
+
 function capabilityCounts(capabilities,key){
  const counts=capabilities?.[key]||{},loaded=Number.isInteger(counts.loaded)?counts.loaded:null;
  return {loaded,used:Math.max(0,Number(counts.used)||0),basis:loaded==null?'unavailable':counts.basis==='configured'?'configured':'session'};
diff --git a/dashboard/js/spend.js b/dashboard/js/spend.js
index 53f2f89b..9dde0865 100644
--- a/dashboard/js/spend.js
+++ b/dashboard/js/spend.js
@@ -1,3 +1,4 @@
+
 function localDayKey(date=new Date()){
  const y=date.getFullYear(),m=String(date.getMonth()+1).padStart(2,'0'),d=String(date.getDate()).padStart(2,'0');
  return `${y}-${m}-${d}`;
diff --git a/dashboard/js/theme-navigation.js b/dashboard/js/theme-navigation.js
index 05bd0720..16535d9e 100644
--- a/dashboard/js/theme-navigation.js
+++ b/dashboard/js/theme-navigation.js
@@ -1,3 +1,4 @@
+
 const THEMES=[
  {id:'classic',label:'Classic',tagline:'The original cyan instrument field'},
  {id:'nebula',label:'Nebula',tagline:'Ultraviolet glass with ion-cyan and mint highlights'},
@@ -285,4 +286,3 @@ $('view-settings').onclick=event=>{
 };
 
 showCurrentPanel(currentPanel);
-
diff --git a/dashboard/js/work-insights.js b/dashboard/js/work-insights.js
index 1046e78c..4cc62957 100644
--- a/dashboard/js/work-insights.js
+++ b/dashboard/js/work-insights.js
@@ -404,4 +404,3 @@ $('delivery-clear').addEventListener('click',async()=>{
   deliveryPayload=null;deliverySelectedDay='';deliveryLastLoadedAt=0;status.textContent='Git evidence cleared. New pushes start a fresh baseline.';loadDelivery();
  }catch(error){status.textContent='Git evidence could not be cleared.';}
 });
-
diff --git a/dashboard/markup/efficiency-work.html b/dashboard/markup/efficiency-work.html
index a4f916dc..0d2d68d5 100644
--- a/dashboard/markup/efficiency-work.html
+++ b/dashboard/markup/efficiency-work.html
@@ -1,3 +1,4 @@
+
 	 <div class=view id=view-efficiency>
 	  <div class="spectrumPageHeadFrame hasPageActions">
 	   <div class="efficiencyHead spectrumPageHead" data-page-signal=efficiency>
diff --git a/dashboard/markup/git-learn-tools.html b/dashboard/markup/git-learn-tools.html
index 9cfe195f..b0514167 100644
--- a/dashboard/markup/git-learn-tools.html
+++ b/dashboard/markup/git-learn-tools.html
@@ -105,4 +105,3 @@
    </div>
   </section>
 	 </div>
-
diff --git a/dashboard/markup/settings.html b/dashboard/markup/settings.html
index 8977c221..dd4d24a3 100644
--- a/dashboard/markup/settings.html
+++ b/dashboard/markup/settings.html
@@ -1,3 +1,4 @@
+
 	 <div class=view id=view-settings>
   <div class=spectrumPageHeadFrame><div class="learnHead settingsPageHead spectrumPageHead" data-page-signal=settings><div class=spectrumPageHeadCopy><h1>Settings</h1><p class=spectrumPageSubtitle>Connections, pricing, and updates.</p></div></div></div>
   <div class=settingsPageLayout>
diff --git a/dashboard/markup/shell.html b/dashboard/markup/shell.html
index e79d65ff..c993d22e 100644
--- a/dashboard/markup/shell.html
+++ b/dashboard/markup/shell.html
@@ -366,4 +366,3 @@ <h2 class=workSrOnly>All sessions</h2>
   <div class=foot>Local-only</div>
   </div>
  </div>
-
diff --git a/dashboard/markup/spend.html b/dashboard/markup/spend.html
index cf6c3b41..462f3677 100644
--- a/dashboard/markup/spend.html
+++ b/dashboard/markup/spend.html
@@ -1,3 +1,4 @@
+
 	 <div class=view id=view-daily>
 	  <div class="spectrumPageHeadFrame hasPageActions">
 	   <div class="dailyHead spectrumPageHead" data-page-signal=spend>
@@ -141,4 +142,3 @@
 	   <section class="card spendScatterCard" id=s-scatter><div class=spendInsightCardHead><div><h3>Cost and input by active time</h3></div><div class=spendScatterControls><span class=spendScatterCoverage id=s-scatter-coverage></span><div class=seg id=s-scatter-metric aria-label="Outlier map metric"><button data-scatter-metric=cost>Spend</button><button data-scatter-metric=input>Processed input</button></div></div></div><div class=spendScatterWrap><svg class=spendScatterSvg id=s-scatter-svg viewBox="0 0 1040 340" preserveAspectRatio=none role=img aria-label="Session spend by active time"></svg><div class="spendScatterTip chartTip" id=s-scatter-tip hidden></div></div><div class=spendScatterLegend><span><i></i>Session</span><span><i class=spendScatterTopDot></i>Top-decile spend</span><span id=s-scatter-missing hidden>Requires active-time and selected-metric evidence.</span></div></section>
 	  </section>
 	 </div>
-
diff --git a/dashboard/markup/subagents-models.html b/dashboard/markup/subagents-models.html
index 97932e84..9e51e400 100644
--- a/dashboard/markup/subagents-models.html
+++ b/dashboard/markup/subagents-models.html
@@ -1,3 +1,4 @@
+
 	 <div class=view id=view-subagents>
 	  <div class="spectrumPageHeadFrame hasPageActions">
 	   <div class="spectrumPageHead subagentPageHead" data-page-signal=subagents>
@@ -49,4 +50,3 @@
 	  </div>
   </details>
 	 </div>
-
diff --git a/performance.html b/performance.html
index a78fa14d..a9dbab6d 100644
--- a/performance.html
+++ b/performance.html
@@ -10,7 +10,7 @@
 <style>
 @font-face{font-family:"Tektur Local";src:url("/assets/fonts/Tektur-Variable.ttf") format("truetype");font-style:normal;font-weight:400 900;font-stretch:75% 100%;font-display:swap}
 :root{color-scheme:dark;--warn:#ffb457;--paper:#f1eee4;--ink:#10191d;--line:rgb(var(--line-rgb)/.09);--line2:rgb(var(--line-rgb)/.17);--rail-border:rgb(var(--signal-rgb)/.2);--edge:rgb(var(--signal-hi-rgb)/.38);--active:linear-gradient(132deg,var(--signal),var(--signal-mid) 48%,var(--signal-hi));--foil:linear-gradient(90deg,transparent,var(--signal) 18%,var(--signal-hi) 40%,var(--flare) 60%,var(--aura) 80%,transparent);--card:radial-gradient(ellipse 82% 90% at 102% -8%,rgb(var(--signal-hi-rgb)/calc(.1*var(--glow))),transparent 58%),radial-gradient(ellipse 74% 74% at -8% 108%,rgb(var(--aura-rgb)/calc(.08*var(--glow))),transparent 62%),linear-gradient(145deg,rgb(var(--panel2-rgb)/.97),rgb(var(--panel-rgb)/.97) 55%,rgb(var(--bg2-rgb)/.98));--shadow:0 1px 0 rgb(var(--signal-pale-rgb)/.22),0 20px 46px rgb(0 0 0/.36),0 8px 24px rgb(var(--signal-rgb)/calc(.12*var(--glow)));--glow-ring:0 0 0 1px rgb(var(--signal-hi-rgb)/.34),0 8px 26px rgb(var(--signal-rgb)/calc(.34*var(--glow))),inset 0 1px 0 rgb(255 255 255/.38)}
-/* Theme tokens mirror page.html; tests keep the shared values identical. */
+/* Theme tokens mirror the dashboard stylesheet; tests keep the shared values identical. */
 :root,[data-theme=classic]{--signal:#00bceb;--signal-rgb:0 188 235;--signal-mid:#1ba0e1;--signal-mid-rgb:27 160 225;--signal-hi:#7fdbf2;--signal-hi-rgb:127 219 242;--signal-pale-rgb:223 248 255;--aura:#c7a7ff;--aura-rgb:199 167 255;--flare:#6d7bff;--flare-rgb:109 123 255;--bg-deep:#05070a;--bg:#07090c;--bg-rgb:7 9 12;--bg-lift-rgb:7 24 36;--bg2:#0d1117;--bg2-rgb:13 17 23;--panel-rgb:17 24 32;--panel2-rgb:23 33 43;--line-rgb:177 228 241;--fg:#f6f8fb;--dim:#a8b3c1;--faint:#8693a6;--on-accent:#062430;--glow:.8;--ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);--ring-speed:60s;--title-glow:0 0 18px rgb(var(--signal-rgb)/.28);--bg-deep-rgb:5 7 10;--signal-deep-rgb:14 54 67;--card-a-rgb:0 188 235;--card-b-rgb:64 84 214;--card-c-rgb:143 108 230;--card-hi-rgb:142 233 242;--card-glow-rgb:96 84 224;--card-paper-a-rgb:0 188 235;--card-paper-b-rgb:64 84 214;--card-idle-rgb:159 180 189;--card-hero:13 44 61,8 26 39,4 13 20;--card-foot:12 36 52,7 23 31,5 14 21;}
 [data-theme=nebula]{--signal:#9d8bff;--signal-rgb:157 139 255;--signal-mid:#c77dff;--signal-mid-rgb:199 125 255;--signal-hi:#7ef3ff;--signal-hi-rgb:126 243 255;--signal-pale-rgb:230 224 255;--aura:#ff7ad9;--aura-rgb:255 122 217;--flare:#64ffda;--flare-rgb:100 255 218;--bg-deep:#040310;--bg:#07061a;--bg-rgb:7 6 26;--bg-lift-rgb:17 12 46;--bg2:#0c0a22;--bg2-rgb:12 10 34;--panel-rgb:19 16 44;--panel2-rgb:27 23 57;--line-rgb:190 180 255;--fg:#f4f2ff;--dim:#afa9d4;--faint:#9089bd;--on-accent:#0d0726;--glow:1;--ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);--ring-speed:48s;--title-glow:0 0 22px rgb(var(--signal-mid-rgb)/.42);--bg-deep-rgb:4 3 16;--signal-deep-rgb:38 26 92;--card-a-rgb:157 139 255;--card-b-rgb:199 125 255;--card-c-rgb:255 122 217;--card-hi-rgb:126 243 255;--card-glow-rgb:255 122 217;--card-paper-a-rgb:124 92 255;--card-paper-b-rgb:190 60 170;--card-idle-rgb:150 140 200;--card-hero:38 26 92,17 12 46,4 3 16;--card-foot:38 26 92,17 12 46,4 3 16;}
 [data-theme=monolith]{--signal:#e4e7ee;--signal-rgb:228 231 238;--signal-mid:#a7aebd;--signal-mid-rgb:167 174 189;--signal-hi:#ffffff;--signal-hi-rgb:255 255 255;--signal-pale-rgb:244 245 248;--aura:#a9b8ff;--aura-rgb:169 184 255;--flare:#ff6a3d;--flare-rgb:255 106 61;--bg-deep:#050506;--bg:#09090a;--bg-rgb:9 9 10;--bg-lift-rgb:18 18 20;--bg2:#0f0f11;--bg2-rgb:15 15 17;--panel-rgb:21 21 23;--panel2-rgb:28 28 31;--line-rgb:232 234 240;--fg:#f5f5f7;--dim:#abadb5;--faint:#909299;--on-accent:#0a0a0c;--glow:.3;--ring:var(--signal),rgb(var(--signal-rgb)/.4) 25%,var(--signal-hi) 50%,rgb(var(--signal-rgb)/.4) 75%,var(--signal);--ring-speed:24s;--title-glow:0 0 0 transparent;--bg-deep-rgb:5 5 6;--signal-deep-rgb:44 46 54;--card-a-rgb:228 231 238;--card-b-rgb:140 150 172;--card-c-rgb:169 184 255;--card-hi-rgb:255 255 255;--card-glow-rgb:120 130 170;--card-paper-a-rgb:60 66 80;--card-paper-b-rgb:110 120 160;--card-idle-rgb:150 152 160;--card-hero:44 46 54,18 18 20,5 5 6;--card-foot:44 46 54,18 18 20,5 5 6;}
diff --git a/scripts/split-dashboard b/scripts/split-dashboard
index a8edc45b..d1d40b12 100755
--- a/scripts/split-dashboard
+++ b/scripts/split-dashboard
@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 """Split a single-file page.html into dashboard/ parts.
 
-One-off migration tool. Branches that still edit the old single-file
-page.html can run it on their own copy, then port their change into the
-matching part:
+One-off migration tool for branches that still edit the old single-file
+page.html. It writes into an empty folder only; see specs/CONTRIBUTING.md,
+"Porting a page.html change", for the three-way port recipe:
 
-    python3 scripts/split-dashboard path/to/page.html path/to/dashboard
+    python3 scripts/split-dashboard path/to/page.html /tmp/empty-folder
 
 Each part starts at a unique anchor line. Comment lines directly above an
 anchor move with it. The tool writes dashboard/page.manifest and refuses to
@@ -80,7 +80,11 @@ def cut_points(lines):
             raise SystemExit(f"{name}: anchor {prefix!r} matched {len(matches)} lines; expected 1")
         start = matches[0] + offset
         if offset == 0:
-            while start > 0 and lines[start - 1].lstrip().startswith("//"):
+            # Leading comments and blank lines move with the anchor, so no part
+            # ends in a blank line (git diff --check rejects that).
+            while start > 0 and (
+                lines[start - 1].lstrip().startswith("//") or not lines[start - 1].strip()
+            ):
                 start -= 1
         if start <= starts[-1]:
             raise SystemExit(f"{name}: anchor is not after the previous part")
@@ -115,6 +119,11 @@ def split(page_path, out_dir):
 def main(argv):
     if len(argv) != 3:
         raise SystemExit(__doc__)
+    if os.path.exists(os.path.join(argv[2], "page.manifest")):
+        raise SystemExit(
+            f"{argv[2]} already holds dashboard parts; split into an empty folder "
+            "and compare (see specs/CONTRIBUTING.md, Porting a page.html change)"
+        )
     split(argv[1], argv[2])
 
 
diff --git a/specs/AGENTS.md b/specs/AGENTS.md
index 9b03f506..17879bbd 100644
--- a/specs/AGENTS.md
+++ b/specs/AGENTS.md
@@ -203,15 +203,19 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
   before acting:
   - `reporter-end-to-end` (Pratik explicitly asks to start the Token Meter team
     flow or manage a linked reporter request): `token-meter-intake` and
-    `token-meter-github-ops`. It authorizes commit, push of a dedicated
-    `codex/` branch, the linked pull request, the issue testing handoff, and
-    one short Slack reply signed as Pratik's agent. GitHub owns clone, install,
+    `token-meter-github-ops`. Only after every required gate passes on the
+    exact head with no open finding, it authorizes committing only the scoped
+    files, pushing a dedicated `codex/` branch, the linked pull request, the
+    issue testing handoff, and one short Slack reply in the existing thread
+    signed as Pratik's agent, for that linked issue and thread only. GitHub owns clone, install,
     and procedural next steps; Slack gets no code or procedural next steps. It
     never includes merge, release, close, label changes, or hosted review
     requests.
   - Pull-request status replies and contributor result acknowledgments, also
     signed as Pratik's agent: `token-meter-github-ops` and
-    `token-meter-communication`.
+    `token-meter-communication`. Those approvals cover only one non-duplicate
+    reply per inspected head or result thread; merges, closes, pushes, review
+    requests, and every other action stay separately gated.
 - Commits, pushes, pull requests, reviews posted to GitHub, Slack messages,
   releases, and other external side effects require explicit user approval.
 
diff --git a/specs/CONTRIBUTING.md b/specs/CONTRIBUTING.md
index 734864a6..7871ed67 100644
--- a/specs/CONTRIBUTING.md
+++ b/specs/CONTRIBUTING.md
@@ -265,6 +265,38 @@ contract test reports the exact declaration that breaks a rule.
 python3 -m unittest tests.contracts.test_design_system -v
 ```
 
+### Porting a page.html or test_meter.py change
+
+`page.html` became `dashboard/` parts, `tests/test_meter.py` became per-surface
+`tests/test_*.py` modules, and leaf helpers moved from `token_meter/app.py`
+to `token_meter/app_helpers/`. A branch started before that change gets a
+modify/delete conflict when it merges `main`. To port it:
+
+1. Find the last commit before the split, `P` (the parent of the commit that
+   deleted `page.html`), and merge `P` into your branch first, so only your own
+   edits differ.
+2. Split both versions into empty folders and diff them:
+
+   ```bash
+   mkdir /tmp/port && git show P:page.html > /tmp/port/base.html && cp page.html /tmp/port/branch.html
+   python3 scripts/split-dashboard /tmp/port/base.html /tmp/port/base-parts
+   python3 scripts/split-dashboard /tmp/port/branch.html /tmp/port/branch-parts
+   (cd /tmp/port && git diff --no-index base-parts branch-parts > dashboard.patch)
+   ```
+
+3. Merge `main`, take its side of the `page.html` deletion (`git rm page.html`),
+   then apply the patch inside `dashboard/`:
+   `git apply --3way --directory=dashboard -p2 /tmp/port/dashboard.patch`.
+   Resolve any conflicts by hand.
+4. For a test added to `tests/test_meter.py`, move the method into the module
+   that now holds its class (`scripts/show ClassName`), and patch moved helpers
+   through their `token_meter.app_helpers` module, never through `meter`.
+5. Run `scripts/check-page` and the touched test modules.
+
+The splitter refuses a folder that already holds parts, so it never overwrites
+`dashboard/`. Branches older than its anchors fail with a "matched 0 lines"
+message; port those changes by hand.
+
 ## Validation
 
 Run these checks from the repository root before opening a pull request:
diff --git a/specs/plans/2026-11-06-session-cost-refactor.md b/specs/plans/2026-11-06-session-cost-refactor.md
index 84f800be..43a0000a 100644
--- a/specs/plans/2026-11-06-session-cost-refactor.md
+++ b/specs/plans/2026-11-06-session-cost-refactor.md
@@ -1,6 +1,8 @@
 # Session-cost refactor: analysis and plan
 
-Historical point-in-time analysis (2026-11-06). Plan only; nothing implemented.
+Historical point-in-time analysis and plan (2026-11-06). Implemented on branch
+`refactor/session-cost-split`; the commits record where the shipped layout differs
+(for example, split tests live in `tests/test_*.py`, not `tests/<surface>/`).
 
 ## Method
 
diff --git a/tests/contracts/test_architecture_guards.py b/tests/contracts/test_architecture_guards.py
index 12809f93..76b43e8d 100644
--- a/tests/contracts/test_architecture_guards.py
+++ b/tests/contracts/test_architecture_guards.py
@@ -20,6 +20,29 @@ def test_composition_contains_no_superseded_legacy_function_bodies(self):
         ]
         self.assertEqual(names, [])
 
+    def test_tests_never_patch_moved_helpers_through_meter(self):
+        # Patching meter.NAME rebinds the name in app.py only; helpers that call
+        # NAME inside app_helpers would keep the real one. Patch the owning
+        # module (token_meter.app_helpers.<module>) instead.
+        moved = set()
+        for path in (ROOT / "token_meter" / "app_helpers").glob("*.py"):
+            for node in ast.parse(path.read_text(encoding="utf-8")).body:
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                    moved.add(node.name)
+                elif isinstance(node, ast.Assign):
+                    moved.update(t.id for t in node.targets if isinstance(t, ast.Name))
+        pattern = re.compile(
+            r"patch\.object\(\s*(?:meter|app)\s*,\s*[\"'](\w+)"
+            r"|patch\(\s*[\"'](?:meter|token_meter\.app)\.(\w+)"
+        )
+        offenders = []
+        for path in (ROOT / "tests").rglob("*.py"):
+            for match in pattern.finditer(path.read_text(encoding="utf-8")):
+                name = match.group(1) or match.group(2)
+                if name in moved:
+                    offenders.append(f"{path.relative_to(ROOT)}: {name}")
+        self.assertEqual(offenders, [])
+
     def test_app_helpers_never_import_the_composition_module(self):
         # app.py re-exports every helper name; an import back would be circular
         # and would let helpers depend on names tests patch on ``meter``.
diff --git a/tests/test_dashboard_page.py b/tests/test_dashboard_page.py
index 33a99bd5..f7c63c61 100644
--- a/tests/test_dashboard_page.py
+++ b/tests/test_dashboard_page.py
@@ -68,6 +68,31 @@ def test_assembled_page_is_one_document_with_one_inline_script(self):
         self.assertEqual(page.count("<style>\n"), 1)
 
 
+class SplitToolTests(unittest.TestCase):
+    def test_split_refuses_a_folder_that_already_holds_parts(self):
+        import subprocess
+        import sys
+
+        with tempfile.TemporaryDirectory() as tmp:
+            page = Path(tmp, "page.html")
+            page.write_text("x", encoding="utf-8")
+            Path(tmp, "out").mkdir()
+            Path(tmp, "out", "page.manifest").write_text("a.html\n", encoding="utf-8")
+            result = subprocess.run(
+                [sys.executable, str(Path(ROOT, "scripts", "split-dashboard")), str(page), str(Path(tmp, "out"))],
+                capture_output=True, text=True,
+            )
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("already holds dashboard parts", result.stderr)
+            self.assertEqual(Path(tmp, "out", "page.manifest").read_text(encoding="utf-8"), "a.html\n")
+
+    def test_no_dashboard_part_ends_in_a_blank_line(self):
+        for path in Path(ROOT, "dashboard").rglob("*"):
+            if path.is_file():
+                text = path.read_text(encoding="utf-8")
+                self.assertFalse(text.endswith("\n\n"), path)
+
+
 class DashboardServingTests(unittest.TestCase):
     def test_server_looks_for_the_dashboard_manifest_beside_the_source(self):
         with mock.patch.dict(os.environ, {}, clear=False):
@@ -91,6 +116,23 @@ def test_missing_part_serves_the_setup_error_instead_of_a_partial_page(self):
             manifest = write_parts(tmp, {"a.html": "x"}, ["a.html", "gone.js"])
             self.assertIsNone(meter.page_bytes(manifest))
 
+    def test_health_is_not_ready_when_a_listed_part_is_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            complete = write_parts(tmp, {"a.html": "x", "b.js": "y"})
+            with mock.patch.object(meter, "STATE", {}), \
+                    mock.patch.object(meter, "page_path", return_value=complete):
+                payload, status = meter.health_state(expected_runtime=tmp)
+            self.assertEqual(status, 200)
+            self.assertTrue(payload["page_ready"])
+            self.assertTrue(payload["runtime_matches"])
+            Path(tmp, "dashboard", "b.js").unlink()
+            with mock.patch.object(meter, "STATE", {}), \
+                    mock.patch.object(meter, "page_path", return_value=complete):
+                payload, status = meter.health_state()
+            self.assertEqual(status, 503)
+            self.assertFalse(payload["ok"])
+            self.assertFalse(payload["page_ready"])
+
     def test_bundled_assets_resolve_beside_the_dashboard_folder(self):
         with tempfile.TemporaryDirectory() as tmp:
             manifest = write_parts(tmp, {"a.html": "x"})
diff --git a/tests/test_work_requests.py b/tests/test_work_requests.py
index 2fad753a..677c9530 100644
--- a/tests/test_work_requests.py
+++ b/tests/test_work_requests.py
@@ -39,7 +39,7 @@ def test_file_kinds(self):
                            ("tests/test_meter.py", "tests"), ("specs/WORK_INSIGHTS.md", "docs"),
                            ("AGENTS.md", "tooling"), ("scripts/install", "tooling"),
                            (".github/workflows/ci.yml", "infra"), ("src/components/Button.ts", "frontend"),
-                           ("dashboard/js/spend.js", "frontend"),
+                           ("dashboard/js/spend.js", "frontend"), ("server/dashboard_api.js", "backend"),
                            ("notebooks/x.ipynb", "data"), ("Dockerfile", "infra"), ("config.yaml", "config")):
             self.assertEqual(E.file_kind(path), kind, path)
 
diff --git a/token_meter/app.py b/token_meter/app.py
index 05853b9a..2fe5b79b 100644
--- a/token_meter/app.py
+++ b/token_meter/app.py
@@ -366,6 +366,7 @@
     newest_current_source,
     observable_output_chars,
     optional_capability_summary,
+    page_available,
     page_bytes,
     page_root,
     parse_claude_quota,
@@ -10663,10 +10664,11 @@ def health_state(expected_runtime=None):
     Local paths are never returned; ``expected_runtime`` lets an installer confirm ownership.
     """
     path = page_path()
+    page_ready = page_available(path)
     inventory = _SOURCE_INVENTORY
     inventory_ready = bool(inventory.get("ready"))
     payload = {
-        "ok": bool(path),
+        "ok": page_ready,
         "state_ready": bool(STATE),
         "inventory_ready": inventory_ready,
         "sources": inventory.get("count") if inventory_ready else None,
@@ -10675,11 +10677,11 @@ def health_state(expected_runtime=None):
         "port": PORT,
         "pricing_revision": served_pricing_revision(),
         "pricing_recalculating": pricing_recalculation_running(),
-        "page_ready": bool(path),
+        "page_ready": page_ready,
     }
     if expected_runtime is not None:
         payload["runtime_matches"] = _page_within_runtime(path, expected_runtime)
-    return payload, 200 if path else 503
+    return payload, 200 if page_ready else 503
 
 
 class H(BaseHTTPRequestHandler):
diff --git a/token_meter/app_helpers/common.py b/token_meter/app_helpers/common.py
index 88dc204e..fb6ea550 100644
--- a/token_meter/app_helpers/common.py
+++ b/token_meter/app_helpers/common.py
@@ -2035,6 +2035,17 @@ def page_root(path):
     return os.path.dirname(path)
 
 
+def page_available(path):
+    """True when ``path`` can be served whole; a manifest needs every listed part.
+
+    ``page_path()`` only returns files that exist, so a single-file page is ready
+    whenever a path was found.
+    """
+    if dashboard_page.is_manifest(path):
+        return dashboard_page.parts_present(path)
+    return bool(path)
+
+
 def page_bytes(path):
     """Assembled dashboard bytes, or None when a part is missing or unreadable."""
     try:
diff --git a/token_meter/dashboard_page.py b/token_meter/dashboard_page.py
index 75a3be94..33259fa6 100644
--- a/token_meter/dashboard_page.py
+++ b/token_meter/dashboard_page.py
@@ -54,6 +54,14 @@ def part_paths(manifest):
     return [os.path.join(base, *name.split("/")) for name in part_names(manifest)]
 
 
+def parts_present(manifest):
+    """True when the manifest is valid and every listed part exists (stat only)."""
+    try:
+        return all(os.path.isfile(path) for path in part_paths(manifest))
+    except (OSError, UnicodeDecodeError, ValueError):
+        return False
+
+
 def _signature(manifest, paths):
     stamp = []
     for path in [manifest, *paths]:
diff --git a/token_meter/domain/work_evidence.py b/token_meter/domain/work_evidence.py
index f4a5c73c..f88d8557 100644
--- a/token_meter/domain/work_evidence.py
+++ b/token_meter/domain/work_evidence.py
@@ -82,7 +82,7 @@
     **dict.fromkeys((".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico", ".mp4", ".mov", ".pptx", ".key"),
                     "media"),
 }
-_FRONTEND_DIR_RE = re.compile(r"(^|/)(components?|pages?|views?|ui|frontend|client|web|public|static|styles?|dashboards?|app/)"
+_FRONTEND_DIR_RE = re.compile(r"(^|/)(components?|pages?|views?|ui|frontend|client|web|public|static|styles?|dashboards?/|app/)"
                               r"|\.(component|page|view)\.")
 _TEST_PATH_RE = re.compile(r"(^|/)(tests?|__tests__|spec)/|(^|/)test_[^/]+$|[._-](test|spec)\.[a-z]+$")
 _INFRA_PATH_RE = re.compile(r"(^|/)(\.github/workflows|\.circleci|k8s|kubernetes|helm|terraform|infra|deploy|ansible)"

From 5785acaad074b94e5a343b8edf9fe716ebf2f430 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 09:18:13 +0530
Subject: [PATCH 8/9] docs(agents): keep the reporter flow's commit before its
 gates

The condensed bullet placed the commit after the gates, contradicting the
intake and github-ops skills: gates bind to a commit, so the scoped commit
comes first and the push, PR, issue handoff, and Slack reply follow once
every gate passes. Also correct the health_state docstring.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 AGENTS.md          | 17 +++++++++--------
 specs/AGENTS.md    | 17 +++++++++--------
 token_meter/app.py |  5 ++++-
 3 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 6ad06aa3..b5b7d17f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -205,14 +205,15 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
   before acting:
   - `reporter-end-to-end` (Pratik explicitly asks to start the Token Meter team
     flow or manage a linked reporter request): `token-meter-intake` and
-    `token-meter-github-ops`. Only after every required gate passes on the
-    exact head with no open finding, it authorizes committing only the scoped
-    files, pushing a dedicated `codex/` branch, the linked pull request, the
-    issue testing handoff, and one short Slack reply in the existing thread
-    signed as Pratik's agent, for that linked issue and thread only. GitHub owns clone, install,
-    and procedural next steps; Slack gets no code or procedural next steps. It
-    never includes merge, release, close, label changes, or hosted review
-    requests.
+    `token-meter-github-ops`. It authorizes committing only the scoped files
+    so the gates can bind to that exact commit. Once every required gate
+    passes on that head with no open finding, it also authorizes pushing a
+    dedicated `codex/` branch, the linked pull request, the issue testing
+    handoff, and one short Slack reply in the existing thread signed as
+    Pratik's agent, for that linked issue and thread only. GitHub owns clone,
+    install, and procedural next steps; Slack gets no code or procedural next
+    steps. It never includes merge, release, close, label changes, or hosted
+    review requests.
   - Pull-request status replies and contributor result acknowledgments, also
     signed as Pratik's agent: `token-meter-github-ops` and
     `token-meter-communication`. Those approvals cover only one non-duplicate
diff --git a/specs/AGENTS.md b/specs/AGENTS.md
index 17879bbd..1e00217d 100644
--- a/specs/AGENTS.md
+++ b/specs/AGENTS.md
@@ -203,14 +203,15 @@ Token Meter reads local agent traces, calculates clearly labeled usage estimates
   before acting:
   - `reporter-end-to-end` (Pratik explicitly asks to start the Token Meter team
     flow or manage a linked reporter request): `token-meter-intake` and
-    `token-meter-github-ops`. Only after every required gate passes on the
-    exact head with no open finding, it authorizes committing only the scoped
-    files, pushing a dedicated `codex/` branch, the linked pull request, the
-    issue testing handoff, and one short Slack reply in the existing thread
-    signed as Pratik's agent, for that linked issue and thread only. GitHub owns clone, install,
-    and procedural next steps; Slack gets no code or procedural next steps. It
-    never includes merge, release, close, label changes, or hosted review
-    requests.
+    `token-meter-github-ops`. It authorizes committing only the scoped files
+    so the gates can bind to that exact commit. Once every required gate
+    passes on that head with no open finding, it also authorizes pushing a
+    dedicated `codex/` branch, the linked pull request, the issue testing
+    handoff, and one short Slack reply in the existing thread signed as
+    Pratik's agent, for that linked issue and thread only. GitHub owns clone,
+    install, and procedural next steps; Slack gets no code or procedural next
+    steps. It never includes merge, release, close, label changes, or hosted
+    review requests.
   - Pull-request status replies and contributor result acknowledgments, also
     signed as Pratik's agent: `token-meter-github-ops` and
     `token-meter-communication`. Those approvals cover only one non-duplicate
diff --git a/token_meter/app.py b/token_meter/app.py
index 2fe5b79b..d1b67279 100644
--- a/token_meter/app.py
+++ b/token_meter/app.py
@@ -10659,7 +10659,10 @@ def missing_page_html():
 
 
 def health_state(expected_runtime=None):
-    """Return constant-time liveness/readiness from watcher-owned cached state.
+    """Return cheap liveness/readiness from watcher-owned cached state.
+
+    Page readiness stats each dashboard part (no reads), so a partial runtime
+    reports not ready.
 
     Local paths are never returned; ``expected_runtime`` lets an installer confirm ownership.
     """

From 302b7644e6b46d85c3185e677eddf6158c9db0b9 Mon Sep 17 00:00:00 2001
From: Pratik Bhavsar <ptkbhv@cisco.com>
Date: Fri, 6 Nov 2026 10:06:04 +0530
Subject: [PATCH 9/9] fix(git): let simultaneous first opens of the delivery
 ledger share one salt

CI on this branch failed with "UNIQUE constraint failed: delivery_metadata.key":
two test workers created the same fresh ledger at once, and the salt was
read, then inserted, in separate steps. The server and the MCP can race the
same way on a new machine. Insert with OR IGNORE first and read the stored
salt back, so the first writer wins and nobody fails. A test injects the
competing write between the two steps; it fails on the old code with the
CI error and passes now.

Co-Authored-By: Claude Code <noreply@anthropic.com>
---
 tests/test_git_delivery.py           | 34 ++++++++++++++++++++++++++++
 token_meter/services/git_delivery.py | 15 ++++++------
 2 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/tests/test_git_delivery.py b/tests/test_git_delivery.py
index 51e57597..20ccd518 100644
--- a/tests/test_git_delivery.py
+++ b/tests/test_git_delivery.py
@@ -62,6 +62,40 @@ def local_timestamp(day, hour=12):
 
 
 class GitDeliveryLedgerTests(unittest.TestCase):
+    def test_salt_written_by_another_process_first_wins_without_error(self):
+        # Server, MCP, and parallel test workers can create the ledger at once:
+        # another process may store its salt just before this one writes.
+        with tempfile.TemporaryDirectory() as tmp:
+            path = str(Path(tmp) / "delivery.sqlite3")
+            real_connect = sqlite3.connect
+
+            class RacingConnection:
+                def __init__(self, *args, **kwargs):
+                    self._connection = real_connect(*args, **kwargs)
+
+                def __getattr__(self, name):
+                    return getattr(self._connection, name)
+
+                def __setattr__(self, name, value):
+                    if name == "_connection":
+                        object.__setattr__(self, name, value)
+                    else:
+                        setattr(self._connection, name, value)
+
+                def execute(self, sql, *args):
+                    if "INTO delivery_metadata" in sql:
+                        with real_connect(path) as other:
+                            other.execute(
+                                "INSERT OR IGNORE INTO delivery_metadata (key, value) "
+                                "VALUES ('salt', 'other-process-salt')"
+                            )
+                    return self._connection.execute(sql, *args)
+
+            with mock.patch.object(git_delivery.sqlite3, "connect", RacingConnection):
+                ledger = git_delivery.GitDeliveryLedger(path, "this-process-salt")
+            self.assertEqual(ledger.salt, "other-process-salt")
+            self.assertEqual(git_delivery.GitDeliveryLedger(path, "later").salt, "other-process-salt")
+
     def test_ledger_replaces_incompatible_unreleased_schema(self):
         with tempfile.TemporaryDirectory() as tmp:
             path = Path(tmp) / "delivery.sqlite3"
diff --git a/token_meter/services/git_delivery.py b/token_meter/services/git_delivery.py
index 650eff20..e1edf884 100644
--- a/token_meter/services/git_delivery.py
+++ b/token_meter/services/git_delivery.py
@@ -173,17 +173,16 @@ def initialize(self):
                 ON delivery_observations (repo_key, day)
                 """
             )
+            # Another process may create the ledger at the same moment; the first
+            # salt written wins and every process reads that one back.
+            connection.execute(
+                "INSERT OR IGNORE INTO delivery_metadata (key, value) VALUES ('salt', ?)",
+                (self.salt or secrets.token_hex(32),),
+            )
             stored_salt = connection.execute(
                 "SELECT value FROM delivery_metadata WHERE key = 'salt'"
             ).fetchone()
-            if stored_salt is None:
-                self.salt = self.salt or secrets.token_hex(32)
-                connection.execute(
-                    "INSERT INTO delivery_metadata (key, value) VALUES ('salt', ?)",
-                    (self.salt,),
-                )
-            else:
-                self.salt = str(stored_salt["value"])
+            self.salt = str(stored_salt["value"])
             connection.execute("PRAGMA user_version = {}".format(LEDGER_SCHEMA_VERSION))
 
     @staticmethod