claude-finops 0.16.0 → 0.17.0

package/README.md

@@ -230,7 +230,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
 
@@ -374,8 +374,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
@@ -452,7 +451,7 @@ files on Windows.
 - **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
+  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
@@ -508,23 +507,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)
@@ -683,18 +696,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 +1235,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 +1798,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 +1856,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 +1883,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 +1911,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 +2148,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 +2167,6 @@ class Analytics:
                             "SELECT DISTINCT model FROM requests")} & set(self.pricing.models))},
             "settings": self.settings,
             "version": _version(),
+            "served_from": _served_from(),
             "unavailable_label": UNAVAILABLE,
         }

package/finops/api.py

@@ -184,7 +184,7 @@ def filters_from(qs):
     f = {
         "start": _date("start"),
         "end": _date("end"),
-        "agents": lst("agents"), "models": lst("models"), "projects": projects,
+        "models": lst("models"), "projects": projects,
         "sessions": lst("sessions"), "categories": lst("categories"),
         "include_sandbox": qs.get("include_sandbox", ["1"])[0] != "0",
         "min_cost": _num("min_cost", float),
@@ -417,7 +417,7 @@ class Handler(BaseHTTPRequestHandler):
                 a = A
             qs = parse_qs(urlparse(self.path).query)
             f = filters_from(qs)
-            return self.send_json(X.compare(a, f["agents"] or None, f))
+            return self.send_json(X.compare(a, f))
         if parts == ["suggestions"]:
             with _lock:
                 a = A
@@ -448,13 +448,6 @@ class Handler(BaseHTTPRequestHandler):
         parts = path.strip("/").split("/")
         if len(parts) != 4 or not parts[2].isdigit():
             return self.send_json({"ok": False, "error": "bad request"}, 400)
-        agent = (self._payload or {}).get("agent") or "claude"
-        if agent != "claude":
-            from .procs import act_agent
-            if parts[3] in ("handover", "compact", "rename"):
-                return self.send_json({"ok": False,
-                                       "error": f"{parts[3].capitalize()} is only available for Claude Code."})
-            return self.send_json(act_agent(int(parts[2]), parts[3], agent))
         if parts[3] == "handover":
             from .procs import handover
             return self.send_json(handover(int(parts[2]), self._payload))
@@ -476,6 +469,10 @@ class Handler(BaseHTTPRequestHandler):
                 return self.api(path[5:], qs)
             rel = "index.html" if path in ("/", "") else path.lstrip("/")
             fp = os.path.normpath(os.path.join(WEB, rel))
+            # Every dashboard has its own URL (/live, /sessions …): a path that isn't a
+            # file and has no extension is a page of the app, so serve the app.
+            if not os.path.isfile(fp) and "." not in os.path.basename(path.rstrip("/")):
+                fp = os.path.join(WEB, "index.html")
             if os.path.commonpath([fp, WEB]) != WEB or not os.path.isfile(fp):
                 return self.send_text("not found", "text/plain", code=404)
             ext = os.path.splitext(fp)[1]
@@ -519,8 +516,6 @@ class Handler(BaseHTTPRequestHandler):
             except Exception:
                 o["guard_installed"] = False
             return self.send_json(o)
-        if route == "by_agent":
-            return self.send_json(a.by_agent(f))
         if route == "overview":
             return self.send_json(a.overview(f))
         if route == "burn":
@@ -584,14 +579,9 @@ class Handler(BaseHTTPRequestHandler):
             from .diagnose import Diagnoser
             return self.send_json(Diagnoser(a).breakdown(f))
         if route == "live":
-            from .procs import list_sessions, list_agent_sessions, ACTIONS
-            want = [x for x in (g("agents", "") or "").split(",") if x]
-            claude = [dict(s, agent="claude", signalable=True,
-                           resume=f"claude --resume {s.get('session_id')}")
-                      for s in list_sessions(a.pricing)] if not want or "claude" in want else []
-            others = list_agent_sessions(a.pricing, [x for x in want if x != "claude"] or None) \
-                if not want or any(x != "claude" for x in want) else []
-            rows = sorted(claude + others, key=lambda x: -(x.get("context") or 0))
+            from .procs import list_sessions, ACTIONS
+            rows = sorted((dict(s, resume=f"claude --resume {s.get('session_id')}")
+                           for s in list_sessions(a.pricing)), key=lambda x: -(x.get("context") or 0))
             return self.send_json({"sessions": rows, "actions": list(ACTIONS)})
         if route.startswith("session_prompts/"):
             from .procs import session_prompts