claude-finops 0.16.0 → 0.17.1

package/README.md

@@ -10,8 +10,8 @@ It answers, in a few clicks:
 
 Everything runs on `127.0.0.1` with the Python standard library. No dependencies, and
 no data leaves the machine. No outbound calls except a once-a-day version check
-against the npm registry (disable with `--no-update-check`), and provider APIs only
-if you add a key.
+against the npm registry (disable with `--no-update-check`), and Anthropic's cost API
+only if you add an Admin key.
 
 ```bash
 npx claude-finops
@@ -85,8 +85,8 @@ no reason — each with the estimated money attached.
 
 ![Waste detection](https://raw.githubusercontent.com/mohit-raj-purohit/claude-finops/main/docs/img/waste.png)
 
-**Whether the model you are on is the right one.** Per-model cost and efficiency,
-plus a switch analysis that prices the same workload on a cheaper model.
+**Whether the model you are on is the right one.** Per-model cost and efficiency, and
+what each model really cost on the same kind of work, measured rather than repriced.
 
 ![Model analysis](https://raw.githubusercontent.com/mohit-raj-purohit/claude-finops/main/docs/img/models.png)
 
@@ -108,7 +108,7 @@ set.
   or estimated.
 - **Your data stays put.** It binds to `127.0.0.1`. No outbound calls except a
   once-a-day version check against the npm registry (disable with
-  `--no-update-check`), and provider APIs only if you add a key. The warehouse lives
+  `--no-update-check`), and Anthropic's cost API only if you add an Admin key. The warehouse lives
   in `~/.claude-finops`, so upgrading or deleting the package never touches it.
 - **It tells you what to change**, not just what happened — usually with a prompt you
   can paste into Claude Code.
@@ -149,7 +149,7 @@ labelled as your own configured figures.
 
 **Command center** — Executive overview (spend, tokens, usage %, remaining, forecast,
 today vs yesterday) opening with the ⚡ Act now strip, running sessions you can
-interrupt, compact, hand over or close, an AI FinOps Advisor that answers "what should I do today?" from live data, and a
+interrupt, compact, hand over, rename or close, an AI FinOps Advisor that answers "what should I do today?" from live data, and a
 0–100 FinOps scorecard with per-dimension reasoning.
 
 **Usage** — Interactive timeline across 10 metrics and 6 time ranges with day
@@ -167,8 +167,9 @@ latency and efficiency; five leaderboards; prompt intelligence (spend by activit
 and a Claude Code view (tools, files, branches, cost per repository).
 
 **Optimize** — A waste detector with seven rules, each showing the exact prompts or
-sessions it flagged; a recommendation engine that stays quiet without evidence; and
-anomaly detection you can click through to the underlying sessions.
+sessions it flagged; Subagent models, measured per subagent type; a recommendation
+engine that stays quiet without evidence; and anomaly detection you can click through
+to the underlying sessions.
 
 **Plan** — Forecast with conservative/expected/high scenario bands, and budgets with
 Budget → Actual → Forecast → Variance and configurable alert thresholds.
@@ -177,6 +178,11 @@ Global search spans prompt text, sessions, projects, models, tools and dates. Gl
 filters (date, model, project, category, cost/token thresholds, sandbox toggle) update
 every chart and KPI. Everything exports to CSV/JSON, plus a printable PDF report.
 
+Every page, and the side panel when it shows a session or a prompt, has its own URL, so a
+refresh keeps you where you were and Back/Forward work. Next to the version, the header
+says whether the dashboard runs from the npm install or from a source checkout (with its
+commit).
+
 ---
 
 ## Configuration
@@ -187,9 +193,10 @@ Two files, both editable without touching code. The server picks up changes to
 ### `config/pricing.json`
 
 Model prices per million tokens, kept strictly separate from usage data so the table
-can be updated as prices change. A `claude-*` model with no entry is priced as
-`unpriced` ($0, flagged as such in the Model analysis view) rather than silently
-billed at another model's rate.
+can be updated as prices change. A new `claude-*` model with no entry yet is priced
+like the newest listed model of its family and marked as such, instead of showing $0.
+A model that isn't Claude (such as a free local model behind a `claude-qwen` launcher)
+costs $0.
 
 ### `config/settings.json`
 
@@ -230,7 +237,7 @@ without it; it only adds the warning and "continue?" prompt inside Claude Code.
 **Settings** (sidebar, Setup) stores the optional API keys used by **Billed vs local**, in
 `~/.claude-finops/secrets.local.json` (0600, the same file `--set-key` writes). The page only
 ever gets back whether a key is set, where from, and its last four characters. An environment
-variable (`ANTHROPIC_ADMIN_KEY`, `CURSOR_API_KEY`) takes priority over a stored key.
+variable (`ANTHROPIC_ADMIN_KEY`) takes priority over a stored key.
 
 ### Per-session token budget and the session guard
 
@@ -320,8 +327,8 @@ claude-finops                 start the dashboard
 claude-finops --rebuild       re-read transcripts, then start
 claude-finops --stop          stop it
 claude-finops --where         where your data, settings and keys live
-claude-finops --set-key       store a provider API key (hidden prompt, 0600)
-claude-finops --keys          which provider keys are configured
+claude-finops --set-key       store the Anthropic Admin API key (hidden prompt, 0600)
+claude-finops --keys          whether that key is configured
 claude-finops --install-statusline    model, context % and 5-hour limit under every prompt
 claude-finops --uninstall-statusline  remove it again
 claude-finops --install-guard         warn near, and ask at, your per-session token budget
@@ -344,7 +351,7 @@ Everything the app writes lives outside the install folder, in one state directo
   data/cloud_cache.json   cached billing figures
   data/server.pid|.log    running server
   settings.local.json     budgets and limits set in the UI
-  secrets.local.json      provider API keys (0600)
+  secrets.local.json      Anthropic Admin API key (0600)
 ```
 
 Days, "today" and the billing period follow this computer's time zone (Claude Code
@@ -374,8 +381,7 @@ place for you to delete once you are happy.
 **What it reads, all read-only:** Claude Code transcripts in `~/.claude/projects`, and,
 if the Claude desktop app is installed, its Cowork transcripts and
 `plan-usage-history.json` (`~/Library/Application Support/Claude` on macOS,
-`%APPDATA%\Claude` on Windows, `~/.config/Claude` on Linux), plus the other coding
-agents listed under Multi-agent.
+`%APPDATA%\Claude` on Windows, `~/.config/Claude` on Linux).
 
 `~/.claude-finops/data/finops.db` and the prompt/CSV exports contain **your full prompt text**. The
 server binds to `127.0.0.1` only, but treat the database and any export you
@@ -383,15 +389,16 @@ generate as sensitive.
 
 **Hide prompts** (the eye icon in the top bar) hides prompt text and session titles as dots,
 for when you share your screen. Session titles fall back to their short id. The
-setting is remembered in that browser. It only changes what the page shows: the
+setting is remembered in that browser. The side panel has the same button, and using it there
+keeps the panel open. It only changes what the page shows: the
 database and exports still contain the full text.
 
 The app makes exactly one outbound request of its own: once a day it asks
 `registry.npmjs.org` what the latest `claude-finops` version is, so it can tell
 you when an upgrade is out (npm has no way to push one at you). It sends nothing
 about you or your usage. Turn it off with `NO_UPDATE_NOTIFIER=1` or
-`CLAUDE_FINOPS_NO_UPDATE_CHECK=1`. Provider cost APIs are called only if you
-configure a key (with `--set-key` or on the Settings page), and only
+`CLAUDE_FINOPS_NO_UPDATE_CHECK=1`. Anthropic's cost API is called only if you
+add an Admin key (with `--set-key` or on the Settings page), and only
 when you click Refresh on Billed vs local.
 
 ---
@@ -450,13 +457,18 @@ files on Windows.
   Code saves the name itself. In herdr, the agents sidebar gets the same name. Anywhere it can't
   type, the command lands on your clipboard.
 - **Recent** (clock icon in the top bar, or press `R`) opens a side panel on any page: running sessions first,
-  with Resume, Compact and Stop (Interrupt), then past sessions newest first. Click a session to
-  list its prompts, and click a prompt for its full details. Search matches your prompt text.
-  It covers all dates but keeps the agent and project filters. Close and Force kill stay on
+  with Resume, Compact and Stop (Interrupt), working ones first, then past sessions by their last
+  prompt. The sort button at the top puts the last-used past session on top or at the bottom;
+  running sessions always stay on top. Click a session to list its prompts, newest first; its own
+  sort button flips that list to oldest first. Click a prompt for its full details. Search matches your prompt text.
+  It covers all dates but keeps the project filters. Close and Force kill stay on
   Running sessions.
 - **Interrupt / Close / Force kill** (Running sessions) send the session's process a signal
   (in herdr, Interrupt presses Esc in the session's pane instead). Each asks you to click twice. Interrupt is macOS/Linux only: on Windows there is no way to
-  interrupt one console process without hitting the others in its window.
+  interrupt one console process without hitting the others in its window. A session that is
+  working is marked **Working now**, and closing it, or one used in the last 50 minutes, warns you
+  first. **Close selected** closes several idle sessions at once; a session that starts working
+  before you confirm is skipped.
 - **Install statusline** (Act now, or `--install-statusline`) adds a `statusLine` entry to
   `~/.claude/settings.json`, keeping a `.finops-backup` copy. It won't replace a statusline you
   already have.
@@ -508,23 +520,6 @@ The **Jev (fast decisions)** page (sidebar, Optimize):
   tools, worded as "which one", "yes or no", "classify"…) and what they would cost at TypeSafe's
   published price ($0.042 per million input tokens). Read-only.
 
----
-
-## Multi-agent
-
-Besides Claude Code, the warehouse loads every other coding agent it finds on the machine:
-
-| Agent | Read from | What it gives |
-|---|---|---|
-| Codex | `~/.codex/sessions` | Tokens + model per turn; cost at OpenAI list price |
-| Gemini CLI | `~/.gemini/tmp/*/chats` | Tokens + model per reply; cost at Gemini list price |
-| Cursor | Cursor IDE `state.vscdb` (read-only) | Prompts, times and tokens as the IDE stored them; no model, not priced. Agent transcripts are skipped: they carry no times or tokens |
-
-Pick agents with the chips at the top: click for one, Cmd/Ctrl-click to combine, **All** for
-everything. Every page follows the selection, and **Agents** shows them side by side.
-Prices for the other providers live in `config/pricing.json` with their source URLs.
-
-
 ---
 
 ## License and trademarks

package/config/pricing.json

@@ -3,7 +3,7 @@
   "currency": "USD",
   "unit": "per_million_tokens",
   "updated": "2026-10-02",
-  "source": "Anthropic list prices (platform.claude.com/docs/en/about-claude/pricing, fetched 2026-09-28; Sonnet 5.5 added 2026-10-02); OpenAI (developers.openai.com/api/docs/pricing) and Google (ai.google.dev/gemini-api/docs/pricing) checked 2026-10-02",
+  "source": "Anthropic list prices (platform.claude.com/docs/en/about-claude/pricing, fetched 2026-09-28; Sonnet 5.5 added 2026-10-02)",
   "models": {
     "claude-opus-5": {
       "display_name": "Claude Opus 5",
@@ -237,149 +237,9 @@
       "cache_write_1h": 0.0,
       "cache_read": 0.0,
       "context_window": 0
-    },
-    "gpt-5.5": {
-      "display_name": "GPT-5.5 (Codex)",
-      "tier": "frontier",
-      "provider": "openai",
-      "input": 5.0,
-      "output": 30.0,
-      "cache_read": 0.5,
-      "cache_write_5m": 5.0,
-      "cache_write_1h": 5.0,
-      "context_window": 400000
-    },
-    "gpt-5.3-codex": {
-      "display_name": "GPT-5.3 Codex",
-      "tier": "balanced",
-      "provider": "openai",
-      "input": 1.75,
-      "output": 14.0,
-      "cache_read": 0.175,
-      "cache_write_5m": 1.75,
-      "cache_write_1h": 1.75,
-      "context_window": 400000
-    },
-    "gpt-5.2-codex": {
-      "display_name": "GPT-5.2 Codex",
-      "tier": "balanced",
-      "provider": "openai",
-      "input": 1.75,
-      "output": 14.0,
-      "cache_read": 0.175,
-      "cache_write_5m": 1.75,
-      "cache_write_1h": 1.75,
-      "context_window": 400000,
-      "_note": "Not on OpenAI's price list; priced as GPT-5.2"
-    },
-    "gpt-5.2": {
-      "display_name": "GPT-5.2",
-      "tier": "balanced",
-      "provider": "openai",
-      "input": 1.75,
-      "output": 14.0,
-      "cache_read": 0.175,
-      "cache_write_5m": 1.75,
-      "cache_write_1h": 1.75,
-      "context_window": 400000
-    },
-    "gpt-5.1": {
-      "display_name": "GPT-5.1",
-      "tier": "balanced",
-      "provider": "openai",
-      "input": 1.25,
-      "output": 10.0,
-      "cache_read": 0.125,
-      "cache_write_5m": 1.25,
-      "cache_write_1h": 1.25,
-      "context_window": 400000
-    },
-    "gpt-5": {
-      "display_name": "GPT-5",
-      "tier": "balanced",
-      "provider": "openai",
-      "input": 1.25,
-      "output": 10.0,
-      "cache_read": 0.125,
-      "cache_write_5m": 1.25,
-      "cache_write_1h": 1.25,
-      "context_window": 400000
-    },
-    "gpt-5-mini": {
-      "display_name": "GPT-5 mini",
-      "tier": "economy",
-      "provider": "openai",
-      "input": 0.25,
-      "output": 2.0,
-      "cache_read": 0.025,
-      "cache_write_5m": 0.25,
-      "cache_write_1h": 0.25,
-      "context_window": 400000
-    },
-    "gemini-2.5-flash": {
-      "display_name": "Gemini 2.5 Flash",
-      "tier": "economy",
-      "provider": "google",
-      "input": 0.3,
-      "output": 2.5,
-      "cache_read": 0.03,
-      "cache_write_5m": 0.3,
-      "cache_write_1h": 0.3,
-      "context_window": 1048576,
-      "_note": "Cache read: lower bound of Google's published range"
-    },
-    "gemini-2.5-pro": {
-      "display_name": "Gemini 2.5 Pro",
-      "tier": "frontier",
-      "provider": "google",
-      "input": 1.25,
-      "output": 10.0,
-      "cache_read": 0.125,
-      "cache_write_5m": 1.25,
-      "cache_write_1h": 1.25,
-      "context_window": 1048576,
-      "_note": "<=200K prompt; $2.50/$15 above"
-    },
-    "gemini-3.5-flash": {
-      "display_name": "Gemini 3.5 Flash",
-      "tier": "balanced",
-      "provider": "google",
-      "input": 1.5,
-      "output": 9.0,
-      "cache_read": 0.15,
-      "cache_write_5m": 1.5,
-      "cache_write_1h": 1.5,
-      "context_window": 1048576
-    },
-    "gemini-3.8-flash": {
-      "display_name": "Gemini 3.8 Flash",
-      "tier": "economy",
-      "provider": "google",
-      "input": 0.75,
-      "output": 3.75,
-      "cache_read": 0.075,
-      "cache_write_5m": 0.75,
-      "cache_write_1h": 0.75,
-      "context_window": 1048576,
-      "_note": "Promo price through 2026-12-31; $1.50/$7.50 after"
-    },
-    "cursor": {
-      "display_name": "Cursor (model not recorded)",
-      "tier": "none",
-      "provider": "cursor",
-      "input": 0,
-      "output": 0,
-      "cache_read": 0,
-      "cache_write_5m": 0,
-      "cache_write_1h": 0,
-      "_note": "Cursor bills by subscription and doesn't record the model locally: no cost is estimated"
     }
   },
   "aliases": {
     "claude-haiku-4-5": "claude-haiku-4-5-20251001"
-  },
-  "_sources": {
-    "openai": "https://developers.openai.com/api/docs/pricing (standard tier, 2026-09-18)",
-    "google": "https://ai.google.dev/gemini-api/docs/pricing (paid tier, 2026-09-18)"
   }
 }

package/finops/actions.py

@@ -440,9 +440,7 @@ def _slug(s):
 def suggestions(a, f=None):
     """Skills and MCP servers worth adding, from recurring work (actual transcripts).
 
-    Only Claude Code's own prompts and commands count (these are Claude Code skills and
-    MCP servers; another agent's templated prompts would suggest things Claude never
-    repeats), within the date range when one is given. Scanning is cached per range on
+    Claude Code's own prompts and commands count, within the date range when one is given. Scanning is cached per range on
     the warehouse (reset by sync); installed-state is re-checked on every call.
     """
     f = f or {}
@@ -648,36 +646,32 @@ def free_model_test(log, mid):
     return {"ok": True, "command": m["command"]}
 
 
-def compare(a, agents=None, f=None):
-    """Each selected agent's priced models (with your usage) side by side; free models too
-    when Claude Code is selected, since they plug into Claude Code."""
+def compare(a, f=None):
+    """Claude models (with your usage) side by side with the free models that plug into
+    Claude Code."""
     with open(os.path.join(ROOT, "config", "model_compare.json")) as fh:
         ratings = json.load(fh)["ratings"]
-    agents = agents or ["claude"]
-    prov = {"claude": "anthropic", "codex": "openai", "gemini": "google"}
-    want = {prov[x] for x in agents if x in prov}
-    where = {"anthropic": "Anthropic cloud", "openai": "OpenAI cloud", "google": "Google cloud"}
-    w, wp = a.where(dict(f or {}, agents=agents))
+    w, wp = a.where(f or {})
     used = {r["model"]: r for r in a.q(f"""SELECT r.model, COUNT(*) requests, SUM(r.est_cost_usd) cost,
                                            SUM(r.billable_tokens) tokens FROM requests r
                                            WHERE {w} GROUP BY r.model""", wp)}
     rows = []
     for mid, p in a.pricing.models.items():
-        pv = p.get("provider", "anthropic")
-        if p.get("tier") in (None, "none", "other") or pv not in want or mid.endswith("[1m]"):
+        if p.get("tier") in (None, "none", "other") or p.get("provider", "anthropic") != "anthropic" \
+                or mid.endswith("[1m]"):
             continue
         u = used.get(mid) or {}
         # An unrated Claude model still belongs in the table when you used it; unused
         # unrated ones (old ids kept for pricing history) would only add noise.
-        if pv == "anthropic" and mid not in ratings and not u:
+        if mid not in ratings and not u:
             continue
         rt = ratings.get(mid) or {"tools": None, "reasoning": None, "multifile": None,
                                   "speed": "—", "best_for": p.get("tier", "").capitalize() + " tier"}
-        rows.append({"id": mid, "name": p.get("display_name", mid), "kind": "claude" if pv == "anthropic" else pv,
-                     "where": where.get(pv, pv), "price_in": p.get("input"), "price_out": p.get("output"),
+        rows.append({"id": mid, "name": p.get("display_name", mid), "kind": "claude",
+                     "where": "Anthropic cloud", "price_in": p.get("input"), "price_out": p.get("output"),
                      "context": p.get("context_window"), "requests": u.get("requests") or 0,
                      "cost": u.get("cost") or 0, "tokens": u.get("tokens") or 0, "tier": p.get("tier"), **rt})
-    fm = free_models() if "claude" in agents else {"models": [], "os": None}
+    fm = free_models()
     for m in fm["models"]:
         if m["id"] not in ratings:
             continue
@@ -691,7 +685,6 @@ def compare(a, agents=None, f=None):
                        -rank.get(r.get("tier"), 3))
     rows.sort(key=lambda r: score(r), reverse=True)
     return {"rows": rows, "os": fm["os"], "ram_gb": fm["models"][0]["ram_gb"] if fm["models"] else None,
-            "agents": agents,
             "note": "Ratings are judgement, not benchmarks; edit config/model_compare.json. "
                     "Models you used that have no rating show — until you add them there. Tool use matters most: coding "
                     "agents work by calling tools, and weak tool use means loops, broken edits "

package/finops/analytics.py

@@ -64,6 +64,21 @@ def _version():
         return ""
 
 
+def _served_from():
+    """Which copy is serving: a git checkout (with its commit) or an npm install."""
+    from .paths import ROOT
+    out = {"kind": "npm", "path": ROOT, "commit": None}
+    if os.path.exists(os.path.join(ROOT, ".git")):
+        out["kind"] = "source"
+        try:
+            import subprocess
+            out["commit"] = subprocess.run(["git", "-C", ROOT, "rev-parse", "--short", "HEAD"],
+                                           capture_output=True, text=True, timeout=3).stdout.strip() or None
+        except (OSError, subprocess.SubprocessError):
+            pass
+    return out
+
+
 def detect_account():
     """Who Claude Code is signed in as, read from ~/.claude.json (actual, not guessed).
 
@@ -257,8 +272,6 @@ class Analytics:
             cl.append("r.day >= ?"); p.append(f["start"])
         if f.get("end"):
             cl.append("r.day <= ?"); p.append(f["end"])
-        if f.get("agents"):
-            cl.append("r.agent IN (%s)" % ",".join("?" * len(f["agents"]))); p += f["agents"]
         if f.get("models"):
             cl.append("r.model IN (%s)" % ",".join("?" * len(f["models"]))); p += f["models"]
         if f.get("projects"):
@@ -353,8 +366,8 @@ class Analytics:
             p).get("n", 0)
         tot["tool_calls"] = self.one(
             f"SELECT COALESCE(SUM(r.tool_call_count),0) n FROM requests r WHERE {w}", p).get("n", 0)
-        # Requests with tokens but no price (an agent without price data, such as Cursor,
-        # or a model missing from pricing.json): they count, but at $0.
+        # Requests with tokens but no price (a model missing from pricing.json):
+        # they count, but at $0.
         tot["unpriced_requests"] = self.one(
             f"SELECT COUNT(*) n FROM requests r WHERE {w} AND r.est_cost_usd = 0 AND r.billable_tokens > 0",
             p).get("n", 0)
@@ -659,11 +672,12 @@ class Analytics:
     def sessions(self, f=None, limit=500, order="cost", offset=0):
         w, p = self.where(f)
         ob = {"cost": "cost DESC", "tokens": "tokens DESC", "duration": "s.duration_s DESC",
-              "recent": "s.started_at DESC", "prompts": "prompts DESC"}.get(order, "cost DESC")
+              "recent": "s.started_at DESC", "prompts": "prompts DESC",
+              "last_active": "last_ts DESC", "last_active_asc": "last_ts ASC"}.get(order, "cost DESC")
         rows = self.q(f"""
           SELECT s.id session_id, s.title, s.git_branch, s.cli_version, s.started_at,
                  s.ended_at, s.duration_s, s.files_touched, pr.name project, pr.id project_id,
-                 s.agent, s.source_file, pr.path project_path,
+                 MAX(r.ts) last_ts, s.agent, s.source_file, pr.path project_path,
                  s.billable_tokens session_tokens,
                  COUNT(DISTINCT r.prompt_id) prompts, COUNT(*) requests,
                  SUM(r.tool_call_count) tool_calls,
@@ -683,18 +697,12 @@ class Analytics:
             r["output_ratio"] = (r["output_tokens"] or 0) / r["tokens"] if r["tokens"] else 0
             cr, cw = r["cache_read_tokens"] or 0, r["cache_write_tokens"] or 0
             r["cache_hit_ratio"] = (cr / (cr + cw)) if (cr + cw) else None
-            r["budget_tokens"] = self.session_budget(r["agent"], r.pop("project_path"), r["session_id"])
+            r["budget_tokens"] = self.session_budget(r.pop("project_path"), r["session_id"])
             r["resume"] = resume_command(r["session_id"], r.pop("agent"), r.pop("source_file"))
         return rows
 
-    def session_budget(self, agent, project_path, session_id=None):
-        """The per-session token budget that applies to a session, or None.
-
-        Claude Code sessions only: the guard hook runs there, and other agents'
-        sessions are not what the budget was set for.
-        """
-        if agent != "claude":
-            return None
+    def session_budget(self, project_path, session_id=None):
+        """The per-session token budget that applies to a session, or None."""
         from .guard import budget_for
         return budget_for(self.settings.get("guard") or {}, project_path, session_id)
 
@@ -1228,8 +1236,7 @@ class Analytics:
           ORDER BY cost DESC LIMIT 20""", p + [thr])
         agg = self.one(f"SELECT AVG(r.context_tokens) a, MAX(r.context_tokens) m FROM requests r WHERE {w}", p)
         # Utilisation against each request's own model window, weighted by requests —
-        # not against the largest window anywhere in the price table (a Gemini window
-        # would set the scale for Claude-only usage).
+        # not against the largest window anywhere in the price table.
         num = den = 0.0
         wins = defaultdict(int)
         for v in self.q(f"""SELECT COALESCE(r.priced_as, r.model) m, COUNT(*) n, AVG(r.context_tokens) a
@@ -1792,8 +1799,8 @@ class Analytics:
             out["lines"].append(self._session_budget_line(f, bp, line))
         else:
             out["lines"].append(line("Per-session tokens", None, 0, None, unit="tokens"))
-        # Per-project and per-model lines follow the agent selection like every other line.
-        wa, pa = self.where({"agents": (f or {}).get("agents") or []})
+        # Per-project and per-model lines cover the whole budget period, not the date filter.
+        wa, pa = self.where({})
         for proj, bud in (b.get("per_project_usd") or {}).items():
             act = self.one(f"""SELECT COALESCE(SUM(r.est_cost_usd),0) c FROM requests r
                               JOIN projects pr ON pr.id=r.project_id
@@ -1850,7 +1857,7 @@ class Analytics:
                       p + [bp["start"], bp["end"]])
         scored = []
         for r in rows:
-            bud = self.session_budget("claude", r.pop("path"), r["session_id"])
+            bud = self.session_budget(r.pop("path"), r["session_id"])
             if bud:
                 r["budget"], r["pct"] = bud, round(100.0 * (r["tokens"] or 0) / bud, 1)
                 scored.append(r)
@@ -1877,8 +1884,8 @@ class Analytics:
         series = [d for d in self.daily_series(f, end=last_full.isoformat())]
         priced = [d for d in series if d["cost"] > 0]
         if len(priced) >= 14:
-            # Median/MAD, not mean/stdev: unpriced $0 days from agents without pricing
-            # data (e.g. Cursor) would otherwise pollute the mean/sd baseline and
+            # Median/MAD, not mean/stdev: unpriced $0 days (models without pricing
+            # data) would otherwise pollute the mean/sd baseline and
             # either mask real spikes or manufacture fake ones. MAD is scaled by
             # 1.4826 so it estimates the same thing a standard deviation would under
             # a normal distribution, without a few extreme days inflating it the way
@@ -1905,8 +1912,8 @@ class Analytics:
             # against — which understates how far out they really are. Candidates are
             # ranked by tokens too, since that is the metric being tested; ordering by
             # cost hid token-heavy work on cheap models.
-            # Sessions with no token data (Cursor transcripts don't always carry it)
-            # are not comparable and would drag the baseline down.
+            # Sessions with no token data are not comparable and would drag the
+            # baseline down.
             vals = [s["tokens"] for s in sess if (s["tokens"] or 0) > 0]
             mean = (statistics.median(vals) if vals else 0) or 1
             # Session sizes are heavy-tailed enough that any fixed multiple of the
@@ -2142,48 +2149,10 @@ class Analytics:
         }
 
     # ---------------- filter option lists ----------------
-    def agents(self):
-        """Every agent detected on this machine, with what its local data can show."""
-        from .agents import AGENTS, detect
-        found = detect()
-        used = {r["agent"]: r for r in self.q("""SELECT agent, COUNT(*) requests,
-            COUNT(DISTINCT session_id) sessions, SUM(billable_tokens) tokens,
-            SUM(est_cost_usd) cost, MIN(day) first, MAX(day) last FROM requests GROUP BY agent""")}
-        out = []
-        for k, a in AGENTS.items():
-            u = used.get(k) or {}
-            if not found.get(k) and not u:
-                continue
-            out.append({"id": k, "name": a["name"], "data": a["data"], "note": a["note"],
-                        "requests": u.get("requests") or 0, "sessions": u.get("sessions") or 0,
-                        "tokens": u.get("tokens") or 0, "cost": u.get("cost") or 0,
-                        "first": u.get("first"), "last": u.get("last")})
-        return out
-
-    def by_agent(self, f=None):
-        """Side-by-side totals per agent for the multi-agent view."""
-        f = dict(f or {})
-        w, p = self.where(f)
-        rows = self.q(f"""SELECT r.agent, COUNT(*) requests, COUNT(DISTINCT r.session_id) sessions,
-            COUNT(DISTINCT r.prompt_id) prompts, SUM(r.billable_tokens) tokens,
-            SUM(r.input_tokens) input_tokens, SUM(r.output_tokens) output_tokens,
-            SUM(r.cache_read_tokens) cache_read_tokens, SUM(r.est_cost_usd) cost,
-            SUM(r.tool_call_count) tool_calls, COUNT(DISTINCT r.day) active_days,
-            GROUP_CONCAT(DISTINCT r.model) models
-            FROM requests r WHERE {w} GROUP BY r.agent ORDER BY cost DESC, requests DESC""", p)
-        daily = self.q(f"""SELECT r.day, r.agent, SUM(r.billable_tokens) tokens, SUM(r.est_cost_usd) cost,
-            COUNT(*) requests FROM requests r WHERE {w} GROUP BY 1, 2 ORDER BY 1""", p)
-        from .agents import AGENTS
-        for r in rows:
-            a = AGENTS.get(r["agent"], {})
-            r["name"], r["data"], r["note"] = a.get("name", r["agent"]), a.get("data"), a.get("note")
-        return {"agents": rows, "daily": daily, "basis": "estimated"}
-
     def options(self):
         return {
-            "agents": self.agents(),
-            "models": self.q("SELECT model, agent, COUNT(*) n FROM requests GROUP BY 1 ORDER BY 3 DESC"),
-            "projects": self.q("SELECT pr.id project_id, pr.name, pr.path, pr.is_sandbox, pr.agent, COUNT(r.id) n"
+            "models": self.q("SELECT model, COUNT(*) n FROM requests GROUP BY 1 ORDER BY 2 DESC"),
+            "projects": self.q("SELECT pr.id project_id, pr.name, pr.path, pr.is_sandbox, COUNT(r.id) n"
                                " FROM projects pr LEFT JOIN requests r ON r.project_id=pr.id"
                                " GROUP BY pr.id HAVING n>0 ORDER BY n DESC"),
             "categories": self.q("SELECT category, COUNT(*) n FROM prompts GROUP BY 1 ORDER BY 2 DESC"),
@@ -2199,5 +2168,6 @@ class Analytics:
                             "SELECT DISTINCT model FROM requests")} & set(self.pricing.models))},
             "settings": self.settings,
             "version": _version(),
+            "served_from": _served_from(),
             "unavailable_label": UNAVAILABLE,
         }