claude-finops 0.16.0 → 0.17.0

package/finops/cloud.py

@@ -1,4 +1,4 @@
-"""Billed numbers from the vendors' own APIs, next to what this machine recorded.
+"""Billed numbers from Anthropic's Admin API, next to what this machine recorded.
 
 Everything else in this dashboard reads local files. This module is the one part that
 talks to the internet, and only when you ask it to (the Refresh button / --cloud-sync).
@@ -8,18 +8,15 @@ API keys section on the Budgets page. Both write ~/.claude-finops/secrets.local.
 (0600, outside the install tree, never packaged); the dashboard never sends a stored
 key back to the browser, only whether it is set and its last four characters:
 
-    {"anthropic_admin_key": "sk-ant-admin...", "cursor_api_key": "key_..."}
+    {"anthropic_admin_key": "sk-ant-admin..."}
 
   Anthropic  Admin API key from Console → Settings → Admin keys. Org accounts only;
              individual accounts have no Admin API.
              /v1/organizations/usage_report/claude_code   per user per day, incl. Pro/Max
              /v1/organizations/cost_report                billed USD (API spend only)
-  Cursor     Team/Org admin key from Cursor dashboard → Settings → Admin API.
-             POST /teams/daily-usage-data, /teams/spend, GET /teams/members
 
 Responses are cached in ~/.claude-finops/data/cloud_cache.json so the dashboard never calls out on its own.
 """
-import base64
 import json
 import os
 import time
@@ -40,12 +37,6 @@ PROVIDERS = {
         "covers": "Per-user Claude Code sessions, tokens and estimated cost (including Pro/Max "
                   "subscription users), plus billed API cost for the org.",
     },
-    "cursor": {
-        "name": "Cursor", "agent": "cursor", "env": "CURSOR_API_KEY", "field": "cursor_api_key",
-        "how": "Cursor dashboard → Settings → Admin API → create a key. Team/Business plans only; "
-               "an individual Pro account has no admin API.",
-        "covers": "Per-member daily activity and billed spend for the team.",
-    },
 }
 
 
@@ -70,7 +61,6 @@ def configured():
 KEY_SHAPES = {
     "anthropic": (lambda v: v.startswith("sk-ant-admin"),
                   "An Anthropic Admin key starts with sk-ant-admin (a regular API key will not work)."),
-    "cursor": (lambda v: len(v) >= 16, "That looks too short for a Cursor Admin API key."),
 }
 
 
@@ -198,63 +188,6 @@ def anthropic_cost(key, days=30):
     return out
 
 
-# --------------------------------------------------------------------- Cursor ----
-def _cursor_headers(key):
-    tok = base64.b64encode(f"{key}:".encode()).decode()      # basic auth, key as username
-    return {"Authorization": f"Basic {tok}", "Content-Type": "application/json"}
-
-
-def _cursor_post(key, path, body):
-    try:
-        return _get(f"https://api.cursor.com{path}", _cursor_headers(key),
-                    data=json.dumps(body).encode(), method="POST")
-    except RuntimeError as e:
-        if "401" in str(e):                    # the key is fine; the account just isn't a team
-            raise RuntimeError(
-                "Cursor rejected the key for team endpoints (401 Invalid Team API Key). The key "
-                "itself is valid, but /teams/* answers only for Team/Enterprise accounts — an "
-                "individual account has no team data to report. Cursor stays local-only.") from None
-        raise
-
-
-def cursor_usage(key, days=30):
-    """Daily per-member activity. The API allows at most 30 days per call."""
-    end = int(time.time() * 1000)
-    start = end - min(days, 30) * 86400000
-    out, page = [], 1
-    while True:
-        d = _cursor_post(key, "/teams/daily-usage-data",
-                         {"startDate": start, "endDate": end, "page": page, "pageSize": 1000})
-        rows = d.get("data") or []
-        for r in rows:
-            ts = r.get("date")
-            day = datetime.fromtimestamp(int(ts) / 1000, timezone.utc).date().isoformat() \
-                if ts else None
-            out.append({"day": day, "member": r.get("email") or r.get("userId") or "unknown",
-                        "is_active": r.get("isActive"),
-                        "lines_added": r.get("totalLinesAdded") or 0,
-                        "lines_removed": r.get("totalLinesDeleted") or 0,
-                        "accepted": r.get("acceptedLinesAdded") or 0,
-                        "requests": r.get("composerRequests") or r.get("totalApplies") or 0,
-                        "model": r.get("mostUsedModel")})
-        if len(rows) < 1000 or page > 20:
-            break
-        page += 1
-    return out
-
-
-def cursor_spend(key):
-    d = _cursor_post(key, "/teams/spend", {"page": 1, "pageSize": 500})
-    out = []
-    for r in d.get("teamMemberSpend") or d.get("data") or []:
-        cents = r.get("spendCents")
-        out.append({"member": r.get("email") or r.get("name") or "unknown",
-                    "spend_usd": (float(cents) / 100.0) if cents is not None else None,
-                    "requests": r.get("fastPremiumRequests") or r.get("requests"),
-                    "role": r.get("role")})
-    return out
-
-
 # ---------------------------------------------------------------------- cache ----
 def load_cache():
     try:
@@ -281,18 +214,6 @@ def sync(days=30, log=print):
             cache["anthropic_cost"] = anthropic_cost(k, days)
         except RuntimeError as e:
             errors["anthropic_cost"] = str(e)
-    k = key_for("cursor")
-    if k:
-        log("Cursor: daily usage…")
-        try:
-            cache["cursor_usage"] = cursor_usage(k, days)
-        except RuntimeError as e:
-            errors["cursor_usage"] = str(e)
-        log("Cursor: spend…")
-        try:
-            cache["cursor_spend"] = cursor_spend(k)
-        except RuntimeError as e:
-            errors["cursor_spend"] = str(e)
     cache["errors"] = errors
     cache["fetched_at"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
     os.makedirs(os.path.dirname(CACHE_PATH), exist_ok=True)
@@ -302,20 +223,18 @@ def sync(days=30, log=print):
 
 
 def report(analytics, days=30):
-    """Billed (vendor API) next to local (this machine), per agent and per day."""
+    """Billed (Anthropic API) next to local (this machine), per day and per user."""
     c = load_cache()
     cc = c.get("anthropic_claude_code") or []
     cost = c.get("anthropic_cost") or []
-    cu = c.get("cursor_usage") or []
-    cs = c.get("cursor_spend") or []
     since = (datetime.now(timezone.utc).date() - timedelta(days=days)).isoformat()
-    # The vendor APIs report UTC days, so this page compares on UTC days too (every
+    # The Anthropic API reports UTC days, so this page compares on UTC days too (every
     # other page uses your local calendar days); otherwise a late-evening session would
     # sit on different dates on the two sides.
-    local = {r["agent"]: r for r in analytics.q(
-        "SELECT agent, SUM(est_cost_usd) cost, SUM(billable_tokens) tokens,"
+    claude_local = analytics.one(
+        "SELECT SUM(est_cost_usd) cost, SUM(billable_tokens) tokens,"
         " COUNT(DISTINCT session_id) sessions, COUNT(*) requests"
-        " FROM requests WHERE substr(ts,1,10) >= ? GROUP BY agent", (since,))}
+        " FROM requests WHERE agent='claude' AND substr(ts,1,10) >= ?", (since,))
 
     by_day = {}
     for r in cc:
@@ -346,19 +265,6 @@ def report(analytics, days=30):
     for u in users.values():
         u["terminals"] = sorted(u["terminals"])
 
-    cur = {}
-    for r in cu:
-        m = cur.setdefault(r["member"], {"member": r["member"], "days": 0, "lines_added": 0,
-                                         "lines_removed": 0, "accepted": 0, "requests": 0})
-        m["days"] += 1 if r.get("is_active") is not False else 0
-        for k2 in ("lines_added", "lines_removed", "accepted", "requests"):
-            m[k2] += r.get(k2) or 0
-    spend = {s["member"]: s for s in cs}
-    for m in cur.values():
-        m["spend_usd"] = (spend.get(m["member"]) or {}).get("spend_usd")
-
-    claude_local = local.get("claude") or {}
-    cursor_local = local.get("cursor") or {}
     return {
         "configured": configured(), "providers": PROVIDERS,
         "fetched_at": c.get("fetched_at"), "errors": c.get("errors") or {},
@@ -369,20 +275,17 @@ def report(analytics, days=30):
             "local_claude_cost": claude_local.get("cost") or 0.0,
             "local_claude_tokens": claude_local.get("tokens") or 0,
             "billed_api_cost": sum(r["cost_usd"] for r in cost),
-            "cursor_spend": sum(s["spend_usd"] or 0 for s in cs) if cs else None,
-            "local_cursor_requests": cursor_local.get("requests") or 0,
-            "org_users": len(users), "cursor_members": len(cur),
+            "org_users": len(users),
         },
         "by_day": sorted(by_day.values(), key=lambda x: x["day"]),
         "users": sorted(users.values(), key=lambda x: -x["cost"]),
-        "cursor_members": sorted(cur.values(), key=lambda x: -(x["spend_usd"] or 0)),
         "api_cost_by_description": sorted(
             [{"description": k2, "cost_usd": v} for k2, v in
              {r["description"]: sum(x["cost_usd"] for x in cost if x["description"] == r["description"])
               for r in cost}.items()], key=lambda x: -x["cost_usd"])[:20],
-        "note": "Billed figures come from the vendor APIs (org-wide, every machine and member). "
+        "note": "Billed figures come from the Anthropic Admin API (org-wide, every machine and member). "
                 "Local figures are what this machine's transcripts recorded. A gap usually means "
                 "other machines, other members, or work outside this machine. Days on this "
-                "page are UTC days, as the vendors report them.",
+                "page are UTC days, as Anthropic reports them.",
         "basis": "billed",
     }

package/finops/diagnose.py

@@ -19,7 +19,7 @@ CHARS_PER_TOKEN = 4          # rough, stated wherever it is used
 CLAUDE_MD_WARN_TOKENS = 2500
 MEMORY_WARN_TOKENS = 1500
 EXPLORE_BASH = re.compile(r"^\s*(cd [^;&]+[;&]+\s*)?(ls|find|grep|rg|cat|head|tail|sed -n|tree|wc)\b")
-# What each agent calls the same things, so advice names the right file and command.
+# The names advice uses for Claude Code's files and commands.
 VOCAB = {
     "claude": {"name": "Claude Code", "md": "CLAUDE.md", "md_paths": ("CLAUDE.md", ".claude/CLAUDE.md"),
                "clear": "/clear", "compact": "/compact", "shell": ("Bash",),
@@ -28,18 +28,6 @@ VOCAB = {
                             "\"model\" in ~/.claude/settings.json). Give subagents a cheaper model in "
                             "their agent definition.",
                "cheaper": "Default to Sonnet; switch to Opus only for hard problems"},
-    "codex": {"name": "Codex", "md": "AGENTS.md", "md_paths": ("AGENTS.md",),
-              "clear": "/new", "compact": "/compact", "shell": ("exec_command", "shell", "local_shell"),
-              "explore": (),
-              "model_how": "Use /model to pick a smaller GPT-5 model (or lower reasoning effort) for "
-                           "routine edits, tests and docs; set model = \"...\" in ~/.codex/config.toml.",
-              "cheaper": "Use a cheaper GPT model for routine work"},
-    "gemini": {"name": "Gemini CLI", "md": "GEMINI.md", "md_paths": ("GEMINI.md", ".gemini/GEMINI.md"),
-               "clear": "/clear", "compact": "/compress", "shell": ("run_shell_command",),
-               "explore": ("read_file", "read_many_files", "glob", "search_file_content", "list_directory"),
-               "model_how": "Run gemini -m gemini-2.5-flash (or /model) for routine edits, tests "
-                            "and docs; set \"model\" in ~/.gemini/settings.json.",
-               "cheaper": "Default to Flash; switch to Pro only for hard problems"},
 }
 NOISY_PATH = re.compile(r"(node_modules/|/dist/|/build/|/\.next/|/coverage/|package-lock\.json|"
                         r"yarn\.lock|pnpm-lock\.yaml|\.min\.js|\.map$|/data/.*\.(json|csv)$)")
@@ -300,40 +288,6 @@ class Diagnoser:
                 "custom_agents": sorted(os.listdir(agents)) if os.path.isdir(agents) else [],
                 "default_model": st.get("model"), "issues": issues}
 
-    def agent_global_config(self):
-        """Codex / Gemini equivalent of global_config(): instructions file, default model, MCP."""
-        v, issues, files, model, mcp = self.v, [], [], None, []
-        base = os.path.join(HOME, ".codex" if self.agent == "codex" else ".gemini")
-        for rel in (v["md"], "config.toml", "settings.json"):
-            p = os.path.join(base, rel)
-            if os.path.exists(p):
-                files.append({"path": p, "tokens": _tok(p)})
-        if self.agent == "codex":
-            try:
-                txt = open(os.path.join(base, "config.toml"), errors="replace").read()
-            except OSError:
-                txt = ""
-            m = re.search(r'^\s*model\s*=\s*"([^"]+)"', txt, re.M)
-            model = m.group(1) if m else None
-            mcp = re.findall(r'^\s*\[mcp_servers\.([^\]]+)\]', txt, re.M)
-            where = "model = \"...\" in ~/.codex/config.toml"
-        else:
-            st = _load_json(os.path.join(base, "settings.json"))
-            model = (st.get("model") or {}).get("name") if isinstance(st.get("model"), dict) else st.get("model")
-            mcp = list((st.get("mcpServers") or {}).keys())
-            where = "\"model\": {\"name\": \"...\"} in ~/.gemini/settings.json"
-        g = next((x for x in files if x["path"].endswith(v["md"])), None)
-        if g and g["tokens"] and g["tokens"] > CLAUDE_MD_WARN_TOKENS:
-            issues.append({"severity": "medium", "title": f"Global {v['md']} is large",
-                           "fix": f"~{g['tokens']:,} tokens load into every session in every "
-                                  f"project. Move project-specific parts into that project."})
-        if not model:
-            issues.append({"severity": "low", "title": "No default model set",
-                           "fix": f"Set a cheaper everyday default with {where}; switch up with "
-                                  f"/model when a task needs it."})
-        return {"files": files, "mcp_servers": mcp, "custom_agents": [],
-                "default_model": model, "issues": issues}
-
     def projects(self, f):
         a = self.a
         w, p = a.where(f)
@@ -352,7 +306,6 @@ class Diagnoser:
             ph = ",".join("?" * len(pids))
             exists = bool(path) and os.path.isdir(path)
             v = getattr(self, "v", VOCAB["claude"])
-            claude = v is VOCAB["claude"]
             cm = [os.path.join(path, x) for x in v["md_paths"]] if path else []
             cm_found = [x for x in cm if os.path.exists(x)]
             cm_tok = sum(_tok(x) or 0 for x in cm_found)
@@ -415,18 +368,15 @@ class Diagnoser:
                                       "\"Read(./dist/**)\", \"Read(./**/*.lock)\"]}. Seen: "
                                       + ", ".join(os.path.basename(x["path"]) for x in noisy[:3]),
                                "evidence": noisy})
-            unused = [m for m in mcp_per.get(path, []) if m not in mcp_used] if claude else []
+            unused = [m for m in mcp_per.get(path, []) if m not in mcp_used]
             if unused:
                 issues.append({"severity": "low", "title": "Unused MCP servers enabled",
                                "fix": f"{', '.join(unused)} never called here but their tool "
                                       f"definitions load every session. Remove with "
                                       f"`claude mcp remove <name>`."})
-            if claude and exists and cm_found:
+            if exists and cm_found:
                 issues += self.claude_md_quality(path, cm_found)
-            if claude:
-                issues += self.memory_quality(pj["slug"], heavy)
-            else:                                      # Claude-only files: don't flag them
-                issues = [i for i in issues if not i["title"].startswith(("MEMORY.md", "Generated/large"))]
+            issues += self.memory_quality(pj["slug"], heavy)
             if not exists:
                 issues = []
             out.append({
@@ -440,8 +390,7 @@ class Diagnoser:
                              "deny_rules": len(((s_json or {}).get("permissions") or {}).get("deny") or [])},
                 "mcp_servers": mcp_per.get(path, []),
                 "issues": issues,
-                "harness": self.harness(pj, path, exists, cm_found, s_json, explore_pct, pids, ph)
-                if claude else None,
+                "harness": self.harness(pj, path, exists, cm_found, s_json, explore_pct, pids, ph),
             })
         return out
 
@@ -629,8 +578,7 @@ class Diagnoser:
             "skills": skills, "slash_commands": slash,
             "mcp": [r for r in mcp if r["kind"] == "mcp"],
             "connectors": [r for r in mcp if r["kind"] == "connector"],
-            "configured_unused_mcp": sorted(configured - used)
-            if "claude" in ((f or {}).get("agents") or ["claude"]) else [],
+            "configured_unused_mcp": sorted(configured - used),
             "cache_read_rate_per_mtok": rate * 1e6,
             "note": "Injected = size of what came back into context (actual size, ~4 chars/token). "
                     "Carried = injected × later requests in the same session that re-read it — an "
@@ -971,46 +919,25 @@ class Diagnoser:
         return out[:40]
 
     # ------------------------------------------------------------------ entry point
-    def _agent(self, f):
-        """The agent the advice is written for: the one that spent most tokens in range."""
-        w, p = self.a.where(f)
-        r = self.a.one(f"SELECT r.agent a FROM requests r WHERE {w} AND r.agent IN "
-                       f"('claude','codex','gemini') GROUP BY r.agent "
-                       f"ORDER BY SUM(r.billable_tokens) DESC LIMIT 1", p)
-        return r.get("a") or "claude"
-
     def run(self, f=None):
         f = f or {}
-        self.agent = self._agent(f)
-        self.v = VOCAB[self.agent]
+        self.v = VOCAB["claude"]
         drv = self.drivers(f)
         tr = self.trend(f)
         pj = self.projects(f)
-        gl = self.global_config() if self.agent == "claude" else self.agent_global_config()
+        gl = self.global_config()
         recs = self.recommendations(f, drv, pj)
         top = drv["drivers"][:3]
         headline = ("Your tokens are high mainly because of: "
                     + "; ".join(f"{d['title'].lower()} ({d['share_pct']}%)" for d in top)
                     + ".") if top else "No usage in the selected range."
         from .playbook import attach
-        wants = f.get("agents") or ["claude"]
         res = attach({"headline": headline, "trend": tr, **drv, "recommendations": recs,
-                "live_sessions": self.live_sessions() if "claude" in wants else [], "session_health": self.session_health(f),
+                "live_sessions": self.live_sessions(), "session_health": self.session_health(f),
                 "memory_suggestions": self.memory_suggestions(f),
                 "projects": pj, "global": gl,
                 "note": "Token counts are actual. Dollar figures are estimated. Config checks "
                         f"read files on disk now; token sizes use ~{CHARS_PER_TOKEN} chars/token.",
-                "basis": "mixed", "agent": self.agent, "vocab": {k: v for k, v in self.v.items()
-                                                                  if isinstance(v, str)}})
-        return res if self.agent == "claude" else _swap_md(res, self.v["md"])
-
-
-def _swap_md(obj, md):
-    """Advice text for a non-Claude agent: point at its instructions file, not CLAUDE.md."""
-    if isinstance(obj, str):
-        return obj.replace("CLAUDE.md", md).replace("Claude Code", "the agent")
-    if isinstance(obj, list):
-        return [_swap_md(x, md) for x in obj]
-    if isinstance(obj, dict):
-        return {k: (x if k in ("path", "paths", "session_id") else _swap_md(x, md)) for k, x in obj.items()}
-    return obj
+                "basis": "mixed", "vocab": {k: v for k, v in self.v.items() if isinstance(v, str)}})
+        return res
+

package/finops/etl.py

@@ -110,7 +110,7 @@ CREATE TABLE requests (
   tool_call_count INTEGER DEFAULT 0,
   is_sidechain INTEGER DEFAULT 0,
   agent_id TEXT, agent_type TEXT, agent_desc TEXT,  -- set for subagent requests
-  agent TEXT DEFAULT 'claude'                        -- claude / codex / gemini / cursor
+  agent TEXT DEFAULT 'claude'
 );
 
 CREATE TABLE tool_calls (
@@ -218,9 +218,8 @@ def keep_deleted_history():
 
 
 class Loader:
-    def __init__(self, db_path=DB_PATH, source=DEFAULT_SOURCE, pricing=None, other_agents=True,
+    def __init__(self, db_path=DB_PATH, source=DEFAULT_SOURCE, pricing=None,
                  desktop_roots=None, keep_from=None):
-        self.other_agents = other_agents
         # An explicit source means "load exactly this"; only the default also picks up
         # the desktop app's Cowork sessions (same JSONL format, different config dir).
         self.desktop_roots = (desktop_roots if desktop_roots is not None
@@ -294,12 +293,6 @@ class Loader:
             except Exception as exc:  # a corrupt transcript must not kill the load
                 print(f"  ! skipped {os.path.basename(fp)}: {exc}", file=sys.stderr)
         self.cowork = False
-        if self.other_agents:
-            from .agents import AgentLoader
-            counts = AgentLoader(self, log=lambda m: print(m, file=sys.stderr)).run()
-            if verbose and counts:
-                print("  other agents: " + ", ".join(f"{k} {v:,} requests" for k, v in counts.items()),
-                      file=sys.stderr)
         carried = 0
         if prev and keep_deleted_history() and os.path.exists(prev):
             self.db.commit()              # the fresh read is safe whatever happens next
@@ -647,8 +640,11 @@ class Loader:
             d.row_factory = sqlite3.Row
             cols = lambda db, t: [r[1] for r in d.execute(f"PRAGMA {db}.table_info({t})")]
             common = lambda t: [c for c in cols("main", t) if c in set(cols("old", t)) and c != "id"]
+            # Only Claude Code sessions: warehouses from before 0.17 also held Codex,
+            # Gemini CLI and Cursor rows, which are no longer read.
+            claude_only = " AND COALESCE(agent, 'claude') = 'claude'" if "agent" in cols("old", "sessions") else ""
             gone = [r for r in d.execute(
-                "SELECT * FROM old.sessions WHERE id NOT IN (SELECT id FROM main.sessions)")
+                "SELECT * FROM old.sessions WHERE id NOT IN (SELECT id FROM main.sessions)" + claude_only)
                 if r["source_file"] and not os.path.exists(r["source_file"])]
             if not gone:
                 return 0

package/finops/procs.py

@@ -1,4 +1,4 @@
-"""Running agent sessions (Claude Code, Codex, Gemini CLI, Cursor) and the actions the dashboard can take on them.
+"""Running Claude Code sessions and the actions the dashboard can take on them.
 
 Source of truth is ~/.claude/sessions/<pid>.json (written by Claude Code), checked
 against the live process table. A signal is only ever sent to a PID that, at the
@@ -191,194 +191,6 @@ def act(pid, action):
     return {"ok": True, "message": msg}
 
 
-# ------------------------------------------------------------ other agents ----
-# Codex, Gemini CLI and Cursor keep no pid registry, so a session counts as running
-# when its transcript was written recently. A CLI session is tied to a process by
-# working directory; Cursor sessions live inside the IDE and are never signalled.
-LIVE_WINDOW_S = 20 * 60
-BUSY_WINDOW_S = 60
-AGENT_BINS = {"codex": ("codex",), "gemini": ("gemini",)}
-RESUME = {"codex": "codex resume {sid}", "gemini": "gemini --resume"}
-
-
-def _is_agent(p, agent):
-    if agent == "claude":
-        return _is_claude(p)
-    words = [os.path.basename(w.strip('"').replace("\\", "/")).lower()
-             for w in (p["command"] or "").split()[:3]]
-    return any(w in AGENT_BINS.get(agent, ()) or w in tuple(b + ".exe" for b in AGENT_BINS.get(agent, ()))
-               for w in words)
-
-
-def _cwd_of(pid):
-    if os.name == "nt":
-        return None
-    try:
-        out = subprocess.run(["lsof", "-a", "-d", "cwd", "-p", str(pid), "-Fn"],
-                             capture_output=True, text=True, timeout=5).stdout
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-    return next((l[1:] for l in out.splitlines() if l.startswith("n")), None)
-
-
-def _recent(pattern, now):
-    out = []
-    for fp in glob.glob(pattern, recursive=True):
-        try:
-            age = now - os.path.getmtime(fp)
-        except OSError:
-            continue
-        if age <= LIVE_WINDOW_S:
-            out.append((fp, age))
-    return out
-
-
-def _codex_live(fp, pricing):
-    meta, model, steps, tokens, ctx, cost, prev = {}, "unknown", 0, 0, None, 0.0, None
-    with open(fp, errors="replace") as fh:
-        for line in fh:
-            try:
-                r = json.loads(line)
-            except ValueError:
-                continue
-            typ, p = r.get("type"), r.get("payload") or {}
-            if typ == "session_meta":
-                meta = p
-            elif typ == "turn_context":
-                model = p.get("model") or model
-            elif typ == "event_msg" and p.get("type") == "token_count" and p.get("info"):
-                tot = tuple(sorted(((p["info"] or {}).get("total_token_usage") or {}).items()))
-                if tot == prev:
-                    continue
-                prev = tot
-                last = (p["info"] or {}).get("last_token_usage") or {}
-                cached = int(last.get("cached_input_tokens") or 0)
-                inp, out = int(last.get("input_tokens") or 0), int(last.get("output_tokens") or 0)
-                steps += 1
-                tokens += inp + out
-                ctx = inp
-                if pricing.is_known(model):
-                    cost += pricing.estimate(model, max(inp - cached, 0), out, cached)
-    return {"session_id": meta.get("id"), "cwd": meta.get("cwd"), "version": meta.get("cli_version"),
-            "model": model, "steps": steps, "tokens": tokens, "context": ctx, "est_cost_usd": cost}
-
-
-def _gemini_live(fp, pricing):
-    with open(fp, errors="replace") as fh:
-        d = json.load(fh)
-    steps, tokens, ctx, cost, model = 0, 0, None, 0.0, None
-    for m in d.get("messages") or []:
-        if m.get("type") != "gemini":
-            continue
-        t = m.get("tokens") or {}
-        model = m.get("model") or model
-        cached, inp = int(t.get("cached") or 0), int(t.get("input") or 0)
-        out = int(t.get("output") or 0) + int(t.get("thoughts") or 0)
-        steps += 1
-        tokens += inp + out
-        ctx = inp
-        if pricing.is_known(model):
-            cost += pricing.estimate(model, max(inp - cached, 0), out, cached)
-    return {"session_id": d.get("sessionId"), "cwd": None, "model": model, "steps": steps,
-            "tokens": tokens, "context": ctx, "est_cost_usd": cost}
-
-
-def _cursor_live(fp, pricing):
-    steps = 0
-    with open(fp, errors="replace") as fh:
-        for line in fh:
-            if '"tool_use"' in line:
-                steps += line.count('"tool_use"')
-    slug = os.path.relpath(fp, os.path.join(HOME, ".cursor", "projects")).split(os.sep)[0]
-    guess = "/" + slug.replace("-", "/")
-    return {"session_id": os.path.splitext(os.path.basename(fp))[0],
-            "cwd": guess if os.path.isdir(guess) else None, "project_hint": slug.rsplit("-", 1)[-1],
-            "model": None, "steps": steps, "tokens": None, "context": None, "est_cost_usd": None}
-
-
-LIVE_SOURCES = {
-    "codex": (os.path.join(HOME, ".codex", "sessions", "**", "*.jsonl"), _codex_live),
-    "gemini": (os.path.join(HOME, ".gemini", "tmp", "*", "chats", "*.json"), _gemini_live),
-    "cursor": (os.path.join(HOME, ".cursor", "projects", "*", "agent-transcripts", "*", "*.jsonl"), _cursor_live),
-}
-
-
-def list_agent_sessions(pricing, agents=None, procs=None):
-    procs = procs if procs is not None else _ps()
-    now = time.time()
-    cli = {a: [(pid, p) for pid, p in procs.items() if _is_agent(p, a)] for a in AGENT_BINS}
-    cwds = {}
-    out = []
-    for agent, (pattern, parse) in LIVE_SOURCES.items():
-        if agents and agent not in agents:
-            continue
-        for fp, age in _recent(pattern, now):
-            try:
-                st = parse(fp, pricing)
-            except (OSError, ValueError):
-                continue
-            match = None
-            for pid, p in cli.get(agent, []):
-                if pid not in cwds:
-                    cwds[pid] = _cwd_of(pid)
-                if st.get("cwd") is None or cwds[pid] == st.get("cwd"):
-                    match = (pid, p)
-                    break
-            ctx = st.get("context") or 0
-            cwd = st.get("cwd")
-            out.append({
-                "agent": agent, "pid": match[0] if match else None,
-                "signalable": bool(match), "session_id": st.get("session_id"), "name": None,
-                "cwd": cwd, "project": os.path.basename(cwd or "") or st.get("project_hint") or agent,
-                "status": "busy" if age <= BUSY_WINDOW_S else "idle", "version": st.get("version"),
-                "model": st.get("model"), "uptime": match[1]["etime"] if match else "",
-                "memory_mb": round(match[1]["rss_kb"] / 1024) if match else None,
-                "hosts_dashboard": False, "transcript": fp, "last_write_s": age,
-                "steps": st.get("steps"), "tokens": st.get("tokens"), "context": st.get("context"),
-                "est_cost_usd": st.get("est_cost_usd"),
-                "resume": RESUME.get(agent, "").format(sid=st.get("session_id") or "") or None,
-                "severity": "high" if ctx >= 300_000 else "medium" if ctx >= 150_000 else "ok",
-            })
-    return out
-
-
-def act_agent(pid, action, agent):
-    """Signal a Codex / Gemini CLI process — only one the live list currently shows."""
-    if action not in ACTIONS:
-        return {"ok": False, "error": f"unknown action {action}"}
-    if agent not in AGENT_BINS:
-        return {"ok": False, "error": "This agent's sessions can't be stopped from here."}
-    procs = _ps()
-    p = procs.get(pid)
-    if not p or not _is_agent(p, agent):
-        return {"ok": False, "error": "Process is no longer running."}
-    live = [s for s in list_agent_sessions(_NoPricing(), [agent], procs) if s["pid"] == pid]
-    if not live:
-        return {"ok": False, "error": "Not a live session the dashboard shows; refusing."}
-    sig, msg = ACTIONS[action]
-    try:
-        os.kill(pid, sig)
-    except ProcessLookupError:
-        return {"ok": False, "error": "Process already exited."}
-    except PermissionError:
-        return {"ok": False, "error": "Not permitted to signal this process."}
-    res = {"ok": True, "message": msg.replace("`claude --resume`", "its resume command"),
-           "resume": live[0]["resume"]}
-    if action in ("close", "kill"):
-        for _ in range(20):
-            time.sleep(0.1)
-            if pid not in _ps():
-                res["exited"] = True
-                return res
-        res["exited"] = False
-    return res
-
-
-class _NoPricing:
-    def is_known(self, model):
-        return False
-
-
 # ---------------------------------------------------------------- handover ----
 HANDOFFS = os.path.join(HOME, ".claude", "finops-handoffs")
 EDIT_TOOLS = {"Edit", "Write", "MultiEdit", "NotebookEdit"}

package/finops/segments.py

@@ -19,8 +19,8 @@ Boundaries this can see:
 from datetime import datetime
 
 # Multipliers are derived per model from the price table rather than hardcoded: the
-# 0.1x read / 1.25x 5m / 2.0x 1h shape holds for Anthropic, but Gemini reads at 0.25x
-# and OpenAI writes at 1.0x, so a fixed constant would quietly corrupt those agents.
+# 0.1x read / 1.25x 5m / 2.0x 1h shape holds for today's Claude models, but a fixed
+# constant would quietly go wrong the day a model is priced differently.
 READ = "cache_read"
 W5M = "cache_write_5m"
 W1H = "cache_write_1h"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-finops",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Local FinOps dashboard for Claude Code: what you used, what it cost, why it cost that much, and what to change. Reads your own transcripts, no API key, no data leaves the machine.",
   "bin": {
     "claude-finops": "bin/claude-finops.js"
@@ -33,10 +33,7 @@
     "dashboard",
     "finops",
     "analytics",
-    "cli",
-    "codex",
-    "gemini-cli",
-    "cursor"
+    "cli"
   ],
   "license": "MIT",
   "private": false,