claude-finops 0.7.2 → 0.9.0

package/finops/pricing.py

@@ -5,6 +5,7 @@ produced here is an ESTIMATE. Callers must label it as such.
 """
 import json
 import os
+import re
 
 from .paths import ROOT, PRICING_PATH
 
@@ -13,6 +14,11 @@ M = 1_000_000.0
 
 FREE = {"display_name": None, "tier": "free", "input": 0.0, "output": 0.0, "cache_read": 0.0,
         "cache_write_5m": 0.0, "cache_write_1h": 0.0}
+UNPRICED = dict(FREE, tier="unpriced")
+
+# provider prefixes (bedrock/vertex regions), dated and @version suffixes, bedrock ":0"
+_PREFIX = re.compile(r"^(?:[a-z]{2}(?:-[a-z]+)?\.)?anthropic\.")
+_SUFFIX = re.compile(r"(?:-\d{8}|@\d{8}|-v\d+:\d+|:\d+)+$")
 
 
 class Pricing:
@@ -20,21 +26,40 @@ class Pricing:
         with open(path) as fh:
             self.raw = json.load(fh)
         self.models = self.raw.get("models", {})
-        self.default = self.raw.get("default_model_pricing", {})
+        self.aliases = self.raw.get("aliases", {})
+        self.default = {}          # kept for callers; unknown ids are UNPRICED now
         self.updated = self.raw.get("updated")
         self.source = self.raw.get("source")
 
-    def rates(self, model):
+    def normalize(self, model):
+        """Canonical price-table key for any id Claude Code may record."""
+        if not model:
+            return "unknown"
         if model in self.models:
-            return self.models[model]
+            return model
+        m = _PREFIX.sub("", model)
+        m = _SUFFIX.sub("", m)
+        m = self.aliases.get(m, m)
+        if m in self.models:
+            return m
+        # a dated key in the table for an undated id: claude-haiku-4-5 -> ...-20251001
+        for k in self.models:
+            if k.startswith(m + "-") and re.fullmatch(r"\d{8}", k[len(m) + 1:]):
+                return k
+        return m
+
+    def rates(self, model):
+        m = self.normalize(model)
+        if m in self.models:
+            return self.models[m]
         # An unlisted non-Claude model reached through Claude Code (e.g. a local Ollama or
         # free OpenRouter model via a claude-qwen launcher) has no Anthropic price: $0.
-        if model and not model.startswith("claude") and model not in ("unknown",):
+        if m and not m.startswith("claude") and m != "unknown":
             return FREE
-        return self.default
+        return UNPRICED
 
     def is_known(self, model):
-        return model in self.models
+        return self.normalize(model) in self.models
 
     def display_name(self, model):
         return self.rates(model).get("display_name") or model
@@ -45,6 +70,32 @@ class Pricing:
     def context_window(self, model):
         return self.rates(model).get("context_window")
 
+    def effective_model(self, model, context_tokens=0, speed=None):
+        """The price list that actually applied, given how much context was sent.
+
+        A request whose prompt side exceeds the model's standard context window cannot
+        have been served by the standard variant — it was the long-context one, which
+        is billed at a premium. The transcript records only the base model name, so
+        pricing off that name alone understates every long-context request. Fast mode
+        is billed at its own rate; a `[1m]` premium applies only when the table lists
+        one for this model.
+
+        Returns (model_id_to_price_with, unpriced_long_context). The flag is set when
+        the context clearly exceeded the window but no `[1m]` entry exists to price it
+        with, so callers can surface it rather than quietly bill it at the low rate.
+        """
+        m = self.normalize(model)
+        if speed == "fast" and f"{m}[fast]" in self.models:
+            return f"{m}[fast]", False
+        r = self.models.get(m)
+        win = (r or {}).get("context_window") or 0
+        if not r or not win or not context_tokens or context_tokens <= win:
+            return m, False
+        alt = f"{m}[1m]"
+        if alt in self.models:
+            return alt, False
+        return m, True
+
     def estimate(self, model, input_tokens=0, output_tokens=0, cache_read=0,
                  cache_write_5m=0, cache_write_1h=0):
         """Return estimated USD for one request."""

package/finops/procs.py

@@ -18,11 +18,13 @@ HOME = os.path.expanduser("~")
 REG = os.path.join(HOME, ".claude", "sessions")
 PROJECTS = os.path.join(HOME, ".claude", "projects")
 
-ACTIONS = {
-    "interrupt": (getattr(signal, "CTRL_C_EVENT", signal.SIGINT) if os.name == "nt" else signal.SIGINT, "Interrupted the current turn (like pressing Esc/Ctrl-C)."),
-    "close": (signal.SIGTERM, "Asked the session to exit. Resume it later with `claude --resume`."),
-    "kill": (getattr(signal, "SIGKILL", signal.SIGTERM), "Force-killed the process."),
-}
+ACTIONS = {}
+if os.name != "nt":
+    # On Windows, CTRL_C_EVENT signals the whole console process group, not just
+    # the target process, so there is no safe way to interrupt just one session.
+    ACTIONS["interrupt"] = (signal.SIGINT, "Interrupted the current turn (like pressing Esc/Ctrl-C).")
+ACTIONS["close"] = (signal.SIGTERM, "Asked the session to exit. Resume it later with `claude --resume`.")
+ACTIONS["kill"] = (getattr(signal, "SIGKILL", signal.SIGTERM), "Force-killed the process.")
 
 
 def _ps():

package/finops/report.py

@@ -29,7 +29,7 @@ def build_report(a, f):
     md = a.models(f); pj = a.projects(f); wt = a.waste(f)
     rc = a.recommendations(f); ad = a.advisor(f); ef = a.efficiency(f)
     cat = a.categories(f); bp = ov["billing_period"]
-    lb = a.leaderboards(f, 10)
+    lb = a.leaderboards(f, 10); hy = a.hygiene(f)
 
     def table(headers, rows):
         h = "".join(f"<th>{html.escape(x)}</th>" for x in headers)
@@ -82,52 +82,61 @@ transcripts contain no billed amounts, so no figure here is an actual invoice va
   <div class="kpi"><div class="l">Avg / active day</div><div class="v">{_f(ov['avg_cost_per_active_day'])}</div></div>
 </div>
 
-<h2>2. FinOps scorecard</h2>
-<p><span class="score">{sc['score']}</span> / 100 &nbsp; grade <b>{sc['grade']}</b></p>
+<h2>2. Context hygiene</h2>
+{table(["Threshold", "Requests", "Cost", "Sessions", "Cost after first cross"],
+  [(f"{int(thr):,}", _f(v['requests'],'int'), _f(v['cost_usd']), _f(v['sessions'],'int'),
+    _f(v['cost_after_first_cross_usd'])) for thr, v in hy['above'].items()])}
+<div class="note">"Cost after first cross" is the spend on requests made once a session first passed the
+threshold in that column &mdash; not a saving, an observation of where spend concentrates.</div>
+
+<h2>3. FinOps scorecard</h2>
+<p><span class="score">{sc['score']}</span> / 100</p>
 {table(["Dimension","Score","Detail"], [(d['name'], d['score'], html.escape(d['detail'])) for d in sc['dimensions']])}
 <b>What is good</b><ul>{''.join(f'<li>{html.escape(x)}</li>' for x in sc['what_is_good']) or '<li>&mdash;</li>'}</ul>
 <b>Needs attention</b><ul>{''.join(f'<li>{html.escape(x)}</li>' for x in sc['needs_attention']) or '<li>&mdash;</li>'}</ul>
 
-<h2>3. What should I do? <span class="badge">Advisor</span></h2>
+<h2>4. What should I do? <span class="badge">Advisor</span></h2>
 <ol>{''.join(f"<li><b>{html.escape(x['text'])}</b><br><span style='color:#5b6570'>{html.escape(x['detail'])}</span></li>" for x in ad['actions']) or '<li>No actions.</li>'}</ol>
 
-<h2>4. Model breakdown <span class="badge est">Estimated cost</span></h2>
+<h2>5. Model breakdown <span class="badge est">Estimated cost</span></h2>
 {table(["Model","Requests","Input","Output","Cache read","Cache write","Billable tokens","Est. cost","% cost"],
   [(html.escape(r['display_name']), _f(r['requests'],'int'), _f(r['input_tokens'],'int'),
     _f(r['output_tokens'],'int'), _f(r['cache_read_tokens'],'int'), _f(r['cache_write_tokens'],'int'),
     _f(r['tokens'],'int'), _f(r['cost']), _f(r['cost_pct'],'pct')) for r in md['rows']])}
 
-<h2>5. Project breakdown</h2>
+<h2>6. Project breakdown</h2>
 {table(["Project","Sessions","Prompts","Requests","Tokens","Est. cost","Avg / session"],
   [(html.escape(r['name']), _f(r['sessions'],'int'), _f(r['prompts'],'int'), _f(r['requests'],'int'),
     _f(r['tokens'],'int'), _f(r['cost']), _f(r['avg_cost_per_session'])) for r in pj[:20]])}
 
-<h2>6. Spend by activity</h2>
+<h2>7. Spend by activity</h2>
 {table(["Category","Prompts","Tokens","Est. cost","% of spend"],
   [(html.escape(r['category']), _f(r['prompts'],'int'), _f(r['tokens'],'int'), _f(r['cost']),
     _f(r['cost_pct'],'pct')) for r in cat['rows']])}
 <div class="note">{html.escape(cat['note'])}</div>
 
-<h2>7. Efficiency &amp; caching</h2>
+<h2>8. Efficiency &amp; caching</h2>
 {table(["Metric","Value"], [
   ("Output share of billable tokens", f"{ef['output_ratio']*100:.2f}%"),
   ("Output per prompt-side token", f"{ef['output_per_input']*100:.2f}%"),
-  ("Cache hit ratio", (f"{ef['cache_hit_ratio']*100:.1f}%" if ef['cache_hit_ratio'] is not None else "&mdash;")),
+  ("Cache hit ratio (by token)", (f"{ef['cache_hit_ratio']*100:.1f}%" if ef['cache_hit_ratio'] is not None else "&mdash;")),
+  ("Cache reads as share of cache cost", (f"{ef['cache_read_cost_share']*100:.1f}%"
+                                          if ef.get('cache_read_cost_share') is not None else "&mdash;")),
   ("Tokens per request", _f(ef['tokens_per_request'],'int')),
   ("Avg context per request", _f(ef['avg_context_tokens'],'int')),
   ("Est. cost per 1K output tokens", f"${ef['cost_per_1k_output']:.3f}"),
   ("Est. cost with caching", _f(ef['cache']['cost_with_cache'])),
   ("Est. cost without caching", _f(ef['cache']['cost_without_cache'])),
-  ("Est. caching savings", f"{_f(ef['cache']['estimated_savings_usd'])} ({ef['cache']['savings_pct']}%)"),
+  ("Uncached counterfactual — not a saving", f"{_f(ef['cache']['uncached_counterfactual_delta_usd'])} ({ef['cache']['uncached_counterfactual_pct']}%)"),
 ])}
 
-<h2>8. Top 10 most expensive prompts <span class="badge est">Estimated</span></h2>
+<h2>9. Top 10 most expensive prompts <span class="badge est">Estimated</span></h2>
 {table(["#","Prompt","Model","Tokens","Est. cost","Date"],
   [(i, html.escape((r['preview'] or '')[:120]), html.escape((r['models'] or '')[:40]),
     _f(r['ptokens'],'int'), _f(r['pcost']), r['day'])
    for i, r in enumerate(lb['most_expensive'], 1)])}
 
-<h2>9. Waste detection <span class="badge est">Estimated exposure</span></h2>
+<h2>10. Waste detection <span class="badge est">Estimated exposure</span></h2>
 <p><b>Estimated excess: {_f(wt['estimated_excess_usd'])} ({wt['excess_pct']}%)</b> of
 {_f(wt['total_cost_usd'])} — how much more the flagged work cost than a reasonable baseline.
 It sits inside {_f(wt['exposed_cost_usd'])} ({wt['exposed_pct']}%) of exposed spend across
@@ -138,24 +147,21 @@ It sits inside {_f(wt['exposed_cost_usd'])} ({wt['exposed_pct']}%) of exposed sp
    for x in wt['findings']])}
 <div class="note">{html.escape(wt['note'])}</div>
 
-<h2>10. Optimization recommendations <span class="badge rec">Recommendation</span></h2>
-{table(["Recommendation","Actual cost","Est. alternative","Est. saving","Confidence"],
-  [(html.escape(r['title']), _f(r.get('actual_cost_usd')), _f(r.get('estimated_alternative_cost_usd')),
-    f"{_f(r.get('estimated_savings_usd'))} ({r.get('estimated_savings_pct')}%)",
-    r.get('confidence','')) for r in rc['recommendations']]) if rc['recommendations'] else '<p>No recommendation met the evidence threshold.</p>'}
-<div class="note">Estimated savings assume identical token usage on the alternative and do not model
-output quality. They are opportunities to evaluate, not booked savings.</div>
+<h2>11. Optimization recommendations <span class="badge rec">Recommendation</span></h2>
+{table(["Recommendation","Spend involved","Basis"],
+  [(html.escape(r['title']), _f(r.get('actual_cost_usd')), html.escape(r.get('basis','')))
+   for r in rc['recommendations']]) if rc['recommendations'] else '<p>No recommendation met the evidence threshold.</p>'}
+<div class="note">Observations only. No saving is estimated: what an alternative would have cost is a counterfactual.</div>
 
-<h2>11. Forecast <span class="badge fc">Forecast</span></h2>"""]
+<h2>12. Forecast <span class="badge fc">Forecast</span></h2>"""]
 
     if fc.get("available"):
         parts.append(f"""<p>Method: {html.escape(fc['method'])} over {fc['sample_days']} days.
 Period to date {_f(fc['period_used'])} with {fc['remaining_days']} days remaining.</p>
 {table(["Scenario","Daily rate","Projected end of period"],
   [(k.title(), _f(v['daily_rate']), _f(v['end_of_period_cost'])) for k, v in fc['scenarios'].items()])}
+{'<p class="note">Fewer than 7 priced days in the window: bands not shown.</p>' if fc.get('insufficient_history') else ''}
 {table(["Horizon","Projection"], [
-  ("End of day", _f(fc['end_of_day_cost'])),
-  ("End of week", _f(fc['end_of_week_cost'])),
   ("End of billing period (expected)", _f(fc['scenarios']['expected']['end_of_period_cost'])),
   ("Limit exhaustion date", html.escape(str(fc['limit_exhaustion_date']))),
 ])}""")
@@ -163,7 +169,7 @@ Period to date {_f(fc['period_used'])} with {fc['remaining_days']} days remainin
         parts.append("<p>Not enough data in range to forecast.</p>")
 
     parts.append(f"""
-<h2>12. Data provenance</h2>
+<h2>13. Data provenance</h2>
 {table(["Field","Value"], [
   ("Source", html.escape(str(a.meta.get('source_dir')))),
   ("Transcript files parsed", html.escape(str(a.meta.get('transcript_files')))),

package/finops/segments.py

@@ -0,0 +1,149 @@
+"""Cache segments and cache-TTL replay.
+
+A prompt cache belongs to one model and one continuous run of turns. The moment the
+run breaks — a new session, a subagent, a model change — the next turn pays to write
+the whole prefix again. Those breaks are the only places a model switch is free, so
+they are the unit this module produces.
+
+Everything here is arithmetic over token counts and timestamps that the transcripts
+already carry. No behavioural assumption is made about what a different model would
+have done, which is what separates these numbers from the model-switch estimates.
+
+Boundaries this can see:
+  * session start
+  * subagent (sidechain) start
+  * a model change between consecutive turns
+  * a compaction: context dropping by more than half (auto-compaction is not
+    recorded directly, but this is its trace; a typed /compact is recorded too)
+"""
+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.
+READ = "cache_read"
+W5M = "cache_write_5m"
+W1H = "cache_write_1h"
+
+
+def parse_ts(ts):
+    try:
+        return datetime.fromisoformat((ts or "").replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+
+
+def multipliers(pricing, model):
+    """(read, write_5m, write_1h) as multiples of the model's base input price."""
+    r = pricing.rates(model) or {}
+    base = float(r.get("input") or 0)
+    if not base:
+        return 0.0, 0.0, 0.0
+    g = lambda k: float(r.get(k) or 0) / base
+    return g(READ), g(W5M), g(W1H)
+
+
+def is_compaction(prev_ctx, ctx, threshold=100_000):
+    """A context drop of more than half from above `threshold` is a compaction or a
+    /clear. Claude Code does not record auto-compaction; this is the only trace."""
+    return bool(prev_ctx) and prev_ctx >= threshold and ctx < prev_ctx * 0.5
+
+
+def split_segments(turns):
+    """Split one session's turns into cache segments.
+
+    `turns` must be ordered by timestamp and carry: session_id, model, is_sidechain,
+    agent_id. Returns a list of lists, preserving order.
+    """
+    segments, current, prev = [], [], None
+    for t in turns:
+        boundary = (
+            prev is None
+            or t.get("session_id") != prev.get("session_id")
+            or t.get("model") != prev.get("model")
+            # a sidechain turn runs against its own prefix; entering or leaving one,
+            # or moving between two different subagents, rebuilds the cache
+            or (t.get("agent_id") or None) != (prev.get("agent_id") or None)
+            or bool(t.get("is_sidechain")) != bool(prev.get("is_sidechain"))
+            or is_compaction(prev.get("ctx") if prev else None, t.get("ctx"))
+        )
+        if boundary and current:
+            segments.append(current)
+            current = []
+        current.append(t)
+        prev = t
+    if current:
+        segments.append(current)
+    return segments
+
+
+def ttl_cost(segment, ttl_minutes, write_mult, pricing):
+    """Replay one segment's cost under a given cache TTL.
+
+    Within the TTL the prefix is still resident: the turn pays the read rate for it and
+    the write rate only for the delta it adds. Past the TTL the prefix is gone and the
+    whole thing is written again. A turn refreshes the TTL whether it read or wrote.
+    """
+    total = 0.0
+    last_cache_time = None
+    for t in segment:
+        # Price with the list that actually applied (a long-context variant bills at a
+        # premium), while segmentation keys off the plain model name, since that is what
+        # identifies the cache.
+        model = t.get("priced_as") or t.get("model")
+        rates = pricing.rates(model) or {}
+        base = float(rates.get("input") or 0) / 1e6
+        out_rate = float(rates.get("output") or 0) / 1e6
+        read_m, _, _ = multipliers(pricing, model)
+
+        prefix = t.get("cache_read_tokens") or 0
+        delta = (t.get("cache_write_5m") or 0) + (t.get("cache_write_1h") or 0)
+        when = parse_ts(t.get("ts"))
+        gap = None
+        if last_cache_time and when:
+            gap = (when - last_cache_time).total_seconds() / 60.0
+
+        if gap is not None and gap > ttl_minutes:
+            # The prefix expired between turns, so it has to be written again before it
+            # can be read. Charged on top of the delta this turn added.
+            total += prefix * write_mult * base
+            total += delta * write_mult * base
+        else:
+            # Either still inside the TTL, or the first turn we can see — where the
+            # tokens themselves say what happened, so they are charged as recorded
+            # rather than assumed cold. A segment often opens warm (a resumed session
+            # reads a prefix it did not pay to write inside this segment).
+            total += prefix * read_m * base
+            total += delta * write_mult * base
+
+        total += (t.get("input_tokens") or 0) * base
+        total += (t.get("output_tokens") or 0) * out_rate
+        if when:
+            last_cache_time = when
+    return total
+
+
+def replay(segments, pricing, tolerance=0.05):
+    """Compare the actual 1h TTL against a 5m TTL across every segment.
+
+    Reconciles the 1h replay against the cost actually logged first. A replay that
+    cannot reproduce the real bill is not evidence about a counterfactual one, so the
+    caller is handed `reconciled=False` and should show nothing.
+    """
+    actual = at_1h = at_5m = 0.0
+    for seg in segments:
+        actual += sum((t.get("est_cost_usd") or 0) for t in seg)
+        at_1h += ttl_cost(seg, 60, 2.0, pricing)
+        at_5m += ttl_cost(seg, 5, 1.25, pricing)
+    drift = abs(at_1h - actual) / actual if actual else 0.0
+    return {
+        "segments": len(segments),
+        "logged_cost_usd": actual,
+        "replay_1h_usd": at_1h,
+        "replay_5m_usd": at_5m,
+        "difference_usd": at_1h - at_5m,   # positive => 5m is cheaper
+        "cheaper_ttl": "5m" if at_5m < at_1h else "1h",
+        "reconciliation_drift_pct": round(100 * drift, 2),
+        "reconciled": drift <= tolerance,
+        "basis": "arithmetic",
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-finops",
-  "version": "0.7.2",
+  "version": "0.9.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"

package/run.cmd

@@ -1,4 +1,5 @@
 @echo off
-rem Claude FinOps Command Center (Windows). Same as: python run.py [--rebuild|--stop|--share]
+rem Claude FinOps Command Center (Windows). Same as: python run.py [--rebuild|--stop]
 cd /d "%~dp0"
-where py >nul 2>nul && (py -3 run.py %*) || (python run.py %*)
+where py >nul 2>nul
+if %errorlevel%==0 (py -3 "%~dp0run.py" %*) else (python "%~dp0run.py" %*)

package/run.py

@@ -4,7 +4,6 @@
   python3 run.py              build the warehouse if missing, then serve
   python3 run.py --rebuild    re-read transcripts first
   python3 run.py --stop       stop a running dashboard
-  python3 run.py --share      write ../claude-finops.zip (code + defaults, never your data)
   python3 run.py --set-key    store a provider API key
   python3 run.py --where      print where your data and keys live
   python3 run.py --help       all commands
@@ -18,7 +17,6 @@ import signal
 import subprocess
 import sys
 import time
-import zipfile
 
 ROOT = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, ROOT)
@@ -91,7 +89,9 @@ def _is_ours(pid):
     try:
         if IS_WIN:
             out = subprocess.run(
-                ["wmic", "process", "where", f"ProcessId={pid}", "get", "CommandLine"],
+                ["powershell", "-NoProfile", "-Command",
+                 f'Get-CimInstance Win32_Process -Filter "ProcessId={pid}" | '
+                 "Select-Object -ExpandProperty CommandLine"],
                 capture_output=True, text=True, timeout=10).stdout
         else:
             out = subprocess.run(["ps", "-o", "command=", "-p", str(pid)],
@@ -142,25 +142,6 @@ def stop_pidfile():
     return False
 
 
-def share(out=None):
-    out = out or os.path.join(os.path.dirname(ROOT), "claude-finops.zip")
-    skip_dirs = {"data", "__pycache__", ".git"}
-    with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
-        for base, dirs, files in os.walk(ROOT):
-            dirs[:] = [d for d in dirs if d not in skip_dirs]
-            for f in files:
-                if f.endswith((".pyc", ".zip", ".tgz")) or f in ("settings.local.json", "secrets.local.json"):
-                    continue
-                full = os.path.join(base, f)
-                arc = os.path.join("claude-finops", os.path.relpath(full, ROOT)).replace(os.sep, "/")
-                info = zipfile.ZipInfo.from_file(full, arc)
-                info.external_attr = (0o755 if f.endswith((".sh", ".py")) else 0o644) << 16
-                info.compress_type = zipfile.ZIP_DEFLATED
-                with open(full, "rb") as fh:
-                    z.writestr(info, fh.read())
-    print(f"Wrote {out} (code + default config only; your data/ and local settings are excluded)")
-
-
 HELP = """Claude FinOps Command Center
 
   claude-finops                 start the dashboard (builds the warehouse first run)
@@ -169,11 +150,10 @@ HELP = """Claude FinOps Command Center
   claude-finops --where         print where your data, settings and keys live
   claude-finops --set-key       store a provider API key (prompts, never echoes)
   claude-finops --keys          list which provider keys are configured
-  claude-finops --share         write ../claude-finops.zip (code only, never your data)
   claude-finops --version       print the installed version, and whether a newer one is out
-  claude-finops --advise        what to switch to in the sessions running right now
-  claude-finops --install-hook  suggest a cheaper model in Claude Code, as you send each prompt
-  claude-finops --install-statusline   show model, context and advice in your statusline
+  claude-finops --no-update-check   skip the once-a-day npm version check
+  claude-finops --install-hook  retired no-op (prints a message, changes nothing)
+  claude-finops --install-statusline   show model and context % in your statusline
   claude-finops --help          this message
 
 Environment:
@@ -182,31 +162,10 @@ Environment:
   CLAUDE_PROJECTS=/path         where to read transcripts from
   CLAUDE_FINOPS_PYTHON=/path    which Python the npm wrapper should use
   NO_UPDATE_NOTIFIER=1          never check npm for a newer release
+  CLAUDE_FINOPS_NO_UPDATE_CHECK=1   same as --no-update-check
 """
 
 
-def advise_now():
-    """What every session running right now should consider switching to."""
-    from finops.advisor import advise, evidence
-    from finops.procs import list_sessions
-    from finops.analytics import Analytics
-    ev = evidence()
-    if not ev:
-        return print("No model evidence yet — you need two models run on the same kind of "
-                     "work before there is anything to compare.")
-    rows = list_sessions(Analytics(DB_PATH).pricing)
-    if not rows:
-        return print("No Claude Code sessions are running.")
-    for r in rows:
-        a = advise(model=r.get("model"), transcript=r.get("transcript"), ev=ev)
-        head = f"  {r.get('project') or r.get('session_id') or 'session'}"
-        if a:
-            print(f"{head}: {a['line']}")
-            print(f"{' ' * len(head)}  run {a['command']}")
-        else:
-            print(f"{head}: nothing to change.")
-
-
 def _version():
     from finops.update import _installed
     return _installed()
@@ -219,16 +178,20 @@ def version():
     a repo checkout side by side, and the usual confusion is not "what version
     am I on" but "why does the one I am looking at not have the feature".
     """
-    from finops.update import check, disabled, _key
+    from finops.update import check, disabled, _key, _installed
+    # Print what we know locally first: the network check can be slow, disabled,
+    # or simply fail, and none of that should delay the one line people actually
+    # came here for.
+    print(f"  claude-finops {_installed() or 'unknown'}")
+    print(f"  installed at  {ROOT}")
+    if disabled():
+        print("  update        check is off (NO_UPDATE_NOTIFIER)")
+        return
     # Asking outright is worth a fresh request: a day-old cached answer is the
     # one thing this command must not give you.
     u = check(force=True)
-    print(f"  claude-finops {u['current'] or 'unknown'}")
-    print(f"  installed at  {ROOT}")
     if u.get("update_available"):
         print(f"  update        {u['latest']} is out - {u['command']}")
-    elif disabled():
-        print("  update        check is off (NO_UPDATE_NOTIFIER)")
     elif u.get("latest") and _key(u["current"]) > _key(u["latest"]):
         # A checkout mid-release is ahead of what is published. Saying "up to
         # date" there would hide exactly the gap you are looking for.
@@ -313,6 +276,8 @@ def main():
     os.chdir(ROOT)
     ensure_dirs()
     migrate()
+    if "--no-update-check" in args:
+        os.environ["CLAUDE_FINOPS_NO_UPDATE_CHECK"] = "1"
     if "--help" in args or "-h" in args:
         return print(HELP)
     if "--version" in args or "-v" in args or "-V" in args:
@@ -332,8 +297,6 @@ def main():
     if "--install-statusline" in args or "--uninstall-statusline" in args:
         from finops.integrate import install_statusline
         return install_statusline(remove="--uninstall-statusline" in args)
-    if "--advise" in args:
-        return advise_now()
     if "--where" in args:
         return where()
     if "--keys" in args:
@@ -344,12 +307,10 @@ def main():
     if "--stop" in args:
         print("Stopped." if stop() else "Not running.")
         return
-    if "--share" in args:
-        return share()
     # A flag we do not know used to fall straight through and start the
     # dashboard, so a typo (or a flag from a newer release than the one you
     # have installed) looked like the command silently doing nothing.
-    known = {"--rebuild", "--detach", "--foreground"}
+    known = {"--rebuild", "--detach", "--foreground", "--no-update-check"}
     unknown = [a for a in args if a.startswith("-") and a not in known]
     if unknown:
         print(f"Unknown option: {unknown[0]}")
@@ -381,9 +342,15 @@ def main():
                  else f"lsof -iTCP:{port} -sTCP:LISTEN"))
         sys.exit(1)
     source = os.environ.get("CLAUDE_PROJECTS", os.path.join(os.path.expanduser("~"), ".claude", "projects"))
-    if "--rebuild" in args or not os.path.exists(DB_PATH):
+    from finops.etl import needs_rebuild
+    db_existed = os.path.exists(DB_PATH)
+    rebuild_needed = needs_rebuild(DB_PATH)
+    if "--rebuild" in args or rebuild_needed:
         if not os.path.isdir(source):
             sys.exit(f"No Claude Code transcripts at {source}. Use Claude Code once, or set CLAUDE_PROJECTS.")
+        if db_existed and rebuild_needed and "--rebuild" not in args:
+            print("Warehouse schema changed (pricing and request counting were corrected); rebuilding…",
+                  flush=True)
         print(f"Building warehouse from {source} …", flush=True)
         subprocess.run(_python() + ["-m", "finops.etl", source], check=True)
     rest = [a for a in args if a != "--rebuild"]