sessioncost 0.2.2__tar.gz → 0.3.1__tar.gz

{sessioncost-0.2.2/sessioncost.egg-info → sessioncost-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sessioncost
-Version: 0.2.2
+Version: 0.3.1
 Summary: See how many tokens each turn of your coding-agent chat sends, why, and what to cut. Cost goes down with it.
 Author: kish21
 License-Expression: MIT
@@ -88,6 +88,20 @@ Report: ~/.sessioncost/reports/<session-id>.html
 Asking costs almost nothing: the agent runs the tool and shows its summary, and never reads the log or the report
 into the chat.
 
+## Updating
+
+| How you installed it | How to update |
+|---|---|
+| The one line above | Paste the same line again, then restart your agent. |
+| Claude Code plugin | **/plugin → Marketplaces → sessioncost → Update** (or type `/plugin marketplace update sessioncost`, then `/plugin update sessioncost@sessioncost`), then restart Claude Code. You can also turn on auto-update for this marketplace there. |
+| pip | `pip install -U sessioncost`, then `sessioncost setup`. |
+
+## Old reports
+
+Each chat keeps one report in `~/.sessioncost/reports/` (a few hundred KB each). When more than 10 older ones pile up,
+the summary says so. Type `/sessioncost clean` in a chat, or `sessioncost clean` in a terminal, to delete all of them
+except the latest. Nothing is ever deleted unless you ask.
+
 ## If something goes wrong
 
 - **`/sessioncost` does nothing:** restart the agent after installing.
@@ -124,6 +138,7 @@ sessioncost 3f2a9c1e           # one chat, by the first characters of its id
 sessioncost path/to/session.jsonl   # or an Antigravity .db
 sessioncost 3f2a9c1e --cursor-usage usage-events.csv   # a Cursor chat, with exact tokens from your export
 sessioncost setup              # add /sessioncost to your agents again
+sessioncost clean              # delete all saved reports except the latest
 ```
 
 Options: `--project <dir>` (another project folder), `--no-open` (write the report, do not open it), `--json`

{sessioncost-0.2.2 → sessioncost-0.3.1}/README.md

@@ -73,6 +73,20 @@ Report: ~/.sessioncost/reports/<session-id>.html
 Asking costs almost nothing: the agent runs the tool and shows its summary, and never reads the log or the report
 into the chat.
 
+## Updating
+
+| How you installed it | How to update |
+|---|---|
+| The one line above | Paste the same line again, then restart your agent. |
+| Claude Code plugin | **/plugin → Marketplaces → sessioncost → Update** (or type `/plugin marketplace update sessioncost`, then `/plugin update sessioncost@sessioncost`), then restart Claude Code. You can also turn on auto-update for this marketplace there. |
+| pip | `pip install -U sessioncost`, then `sessioncost setup`. |
+
+## Old reports
+
+Each chat keeps one report in `~/.sessioncost/reports/` (a few hundred KB each). When more than 10 older ones pile up,
+the summary says so. Type `/sessioncost clean` in a chat, or `sessioncost clean` in a terminal, to delete all of them
+except the latest. Nothing is ever deleted unless you ask.
+
 ## If something goes wrong
 
 - **`/sessioncost` does nothing:** restart the agent after installing.
@@ -109,6 +123,7 @@ sessioncost 3f2a9c1e           # one chat, by the first characters of its id
 sessioncost path/to/session.jsonl   # or an Antigravity .db
 sessioncost 3f2a9c1e --cursor-usage usage-events.csv   # a Cursor chat, with exact tokens from your export
 sessioncost setup              # add /sessioncost to your agents again
+sessioncost clean              # delete all saved reports except the latest
 ```
 
 Options: `--project <dir>` (another project folder), `--no-open` (write the report, do not open it), `--json`

{sessioncost-0.2.2 → sessioncost-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sessioncost"
-version = "0.2.2"
+version = "0.3.1"
 description = "See how many tokens each turn of your coding-agent chat sends, why, and what to cut. Cost goes down with it."
 readme = "README.md"
 license = "MIT"

{sessioncost-0.2.2 → sessioncost-0.3.1}/sessioncost/__init__.py

@@ -1,2 +1,2 @@
 """SessionCost: see where every token of your agent session went, turn by turn, and what to fix."""
-__version__ = "0.2.2"
+__version__ = "0.3.1"

{sessioncost-0.2.2 → sessioncost-0.3.1}/sessioncost/analyse.py

@@ -11,10 +11,12 @@ import re
 
 from datetime import datetime
 
-from . import fixes as fixmod
+from . import fixes as fixmod, summary as summarymod
 from . import prices as pricemod
 from .model import Call, Session
 
+SAID = ("typed", "command", "queued", "answer")    # what you said, as opposed to what the agent added
+
 CATEGORIES = [
     ("start", "Start (first call)"),
     ("questions", "Asking you questions"),
@@ -117,23 +119,34 @@ def call_label(c: Call) -> str:
     return "thought, wrote nothing visible"
 
 
-def sent_parts(c: Call, r: dict, setup_tokens: int) -> list[dict]:
-    """What was sent: fixed setup + carried history + new input = the call's context, exactly."""
+def sent_parts(c: Call, r: dict, setup_tokens: int, carried_max: int | None) -> list[dict]:
+    """What was sent, by what it is: fixed setup (step 0) + earlier conversation (step 1) + new (step 2) = the call's
+    context, exactly. Earlier conversation is what the previous call of this thread sent and wrote, minus the setup,
+    whether it came from the cache or not (after a pause the cache expires and it is sent again at full price).
+    The cache only sets the price: cache reads are counted against the setup first, then the conversation."""
     u = c.usage
     cr_rate, new_rate = r["cache_read"], pricemod.new_input_rate(u, r)
     setup = min(setup_tokens, u.context) if c.agent == "main" else 0
-    s_cr = min(setup, u.cache_read)
-    s_new = setup - s_cr
-    carried = u.cache_read - s_cr
-    new = u.new_input - s_new
+    if carried_max is None:                       # first call of its thread: nothing earlier to carry
+        carried_max = 0 if c.agent == "main" else u.cache_read
+    carried = max(0, min(u.context - setup, carried_max))
+    new = u.context - setup - carried
+    cr_left = u.cache_read
+    s_cr = min(setup, cr_left); cr_left -= s_cr
+    h_cr = min(carried, cr_left); cr_left -= h_cr
+    n_cr = min(new, cr_left)
+    price = lambda tokens, cr: (cr * cr_rate + (tokens - cr) * new_rate) / 1e6
     parts = []
     if setup_tokens and c.agent == "main":
-        parts.append({"what": "fixed setup (system prompt, tool definitions, lists)", "tokens": setup,
-                      "usd": (s_cr * cr_rate + s_new * new_rate) / 1e6, "estimated": True})
-    parts.append({"what": "carried history (re-read from cache)", "tokens": carried, "usd": carried * cr_rate / 1e6,
-                  "estimated": bool(setup_tokens and c.agent == "main")})
-    parts.append({"what": "new input (read for the first time)", "tokens": new, "usd": new * new_rate / 1e6,
-                  "estimated": bool(s_new)})
+        parts.append({"what": "fixed setup (instructions, tools, skills: step 0)", "tokens": setup,
+                      "usd": price(setup, s_cr), "estimated": False})
+    # the newest piece (the last reply and tool results) is always written to the cache on this call, not read:
+    # only call it an expired cache when most of the earlier conversation missed it
+    expired = carried > 2000 and h_cr < carried / 2
+    parts.append({"what": "earlier conversation" + (" (sent again at full price: the cache had expired)" if expired else ""),
+                  "tokens": carried, "usd": price(carried, h_cr), "estimated": False})
+    parts.append({"what": "new input (sent for the first time)", "tokens": new, "usd": price(new, n_cr),
+                  "estimated": False})
     return parts
 
 
@@ -178,19 +191,36 @@ def money_label(exact: bool, as_of: str, subscription: bool, tokens_exact: bool
 def analyse(s: Session, prices: dict, subscription: bool = False, engines: list | None = None) -> dict:
     P = Pricer(prices)
     subscription = subscription or not s.billed_per_token
-    setup_tokens = tok(s.setup.chars) if s.setup.known else 0
     main_calls = s.calls
+    # Step 0, the fixed setup: the first call has no history yet, so everything it sent except what you said is the
+    # agent's own setup (instructions, tools, skills, project rules). Measured this way it includes the parts the log
+    # does not spell out (Claude Code's built-in instructions), and it works for agents that log no setup at all.
+    setup_logged = tok(s.setup.chars) if s.setup.known else 0
+    setup_tokens = setup_logged
+    first = main_calls[0] if main_calls else None
+    if first is not None:
+        t0 = next((t for t in s.turns if first in t.calls), None)
+        said = sum(tok(e.chars) for e in (t0.events if t0 else [])
+                   if e.kind in SAID and (e.ts is None or first.ts_first is None or e.ts <= first.ts_first))
+        setup_tokens = max(first.usage.context - said, 0)     # measured; the text estimate only splits it
     first_id = main_calls[0].msg_id if main_calls else None
     last_id = main_calls[-1].msg_id if main_calls else None
 
     # ---- calls (main first, then helpers), each with its parts
     calls: list[dict] = []
     by_obj: dict[int, dict] = {}
+    prev_of: dict[str, Call] = {}                 # the previous call of each thread (main, or one helper)
     for c in s.all_calls:
         r = P.rates(c)
         cc = pricemod.cost(c.usage, r)
         total = sum(cc.values())
-        sp = sent_parts(c, r, setup_tokens)
+        pv = prev_of.get(c.agent)
+        prev_setup = min(setup_tokens, pv.usage.context) if pv is not None and c.agent == "main" else 0
+        sp = sent_parts(c, r, setup_tokens, None if pv is None else pv.usage.context - prev_setup + pv.usage.output)
+        prev_of[c.agent] = c
+        sp_by = {"setup": sum(x["tokens"] for x in sp if x["what"].startswith("fixed setup")),
+                 "history": sum(x["tokens"] for x in sp if x["what"].startswith("earlier conversation")),
+                 "new": sum(x["tokens"] for x in sp if x["what"].startswith("new input"))}
         wp = written_parts(c, r)
         d = {
             "agent": c.agent, "n": c.n, "turn": c.turn, "model": c.model,
@@ -207,7 +237,7 @@ def analyse(s: Session, prices: dict, subscription: bool = False, engines: list
             "context": c.usage.context,
             "cost_by_class": cc,
             "usd": total,
-            "sent": {"tokens": c.usage.context, "usd": sum(p["usd"] for p in sp), "parts": sp},
+            "sent": {"tokens": c.usage.context, "usd": sum(p["usd"] for p in sp), "parts": sp, **sp_by},
             "written": {"tokens": c.usage.output, "usd": sum(p["usd"] for p in wp), "parts": wp},
             "mix": {"written": cc["output"], "new": cc["input"] + cc["cache_write_5m"] + cc["cache_write_1h"],
                     "reread": cc["cache_read"]},
@@ -231,7 +261,7 @@ def analyse(s: Session, prices: dict, subscription: bool = False, engines: list
                     keep = bool(e.ts and prev is not None and prev.ts_last and c.ts_first
                                 and prev.ts_last < e.ts <= c.ts_first)
                 if keep:
-                    said = e.kind in ("typed", "command", "queued", "answer")
+                    said = e.kind in SAID
                     items.append({"what": e.label + (f": “{e.text}”" if said else ""),
                                   "tokens": tok(e.chars)})
             by_obj[id(c)]["new_items"] = [x for x in items if x["tokens"]]
@@ -259,6 +289,7 @@ def analyse(s: Session, prices: dict, subscription: bool = False, engines: list
             "usd": sum(d["usd"] for d in tc),
             "helper_usd": sum(by_obj[id(c)]["usd"] for c in s.helper_calls if c.turn == t.n),
             "sent": sum(d["sent"]["tokens"] for d in tc), "written": sum(d["written"]["tokens"] for d in tc),
+            "sent_by": {k: sum(d["sent"][k] for d in tc) for k in ("setup", "history", "new")},
             "helper_sent": sum(by_obj[id(c)]["sent"]["tokens"] for c in s.helper_calls if c.turn == t.n),
             "calls": [calls.index(d) for d in tc],
             "mix": {k: sum(d["mix"][k] for d in tc) for k in ("written", "new", "reread")},
@@ -282,8 +313,14 @@ def analyse(s: Session, prices: dict, subscription: bool = False, engines: list
 
     # ---- setup
     used = {a.tool for a in s.actions()}
-    setup = {"known": s.setup.known, "tokens": setup_tokens,
-             "parts": [{"what": p.what, "tokens": tok(p.chars)} for p in s.setup.parts],
+    parts = [{"what": p.what, "tokens": tok(p.chars)} for p in s.setup.parts]
+    if setup_logged > setup_tokens and setup_logged:    # the text estimate ran over the measured size: scale it to fit
+        parts = [dict(x, tokens=round(x["tokens"] * setup_tokens / setup_logged)) for x in parts]
+    elif setup_tokens > setup_logged:
+        parts.append({"what": "the agent's built-in instructions and other start-up text (not spelled out in the log)",
+                      "tokens": setup_tokens - setup_logged})
+    setup = {"known": s.setup.known, "measured": first is not None, "tokens": setup_tokens, "logged": setup_logged,
+             "parts": parts,
              "tools": [{"name": p.what, "tokens": tok(p.chars),
                         "used": p.what in used} for p in s.setup.tools]}
     setup["unused"] = [t["name"] for t in setup["tools"] if not t["used"]]
@@ -340,6 +377,7 @@ def analyse(s: Session, prices: dict, subscription: bool = False, engines: list
             "working_min": round(working, 1), "waiting_min": round(waiting / 60, 1),
             "context_max": max((d["context"] for d in calls if d["agent"] == "main"), default=0),
             "sent": sum(d["sent"]["tokens"] for d in calls),
+            "sent_by": {k: sum(d["sent"][k] for d in calls) for k in ("setup", "history", "new")},
             "output": sum(d["usage"]["output"] for d in calls), "thinking": thinking,
             "thinking_known": thinking_known,
             "by_class": by_class,
@@ -366,6 +404,7 @@ def analyse(s: Session, prices: dict, subscription: bool = False, engines: list
         for tr in turn_rows:
             if tr["n"] in f.turns:
                 tr["fixes"].append(f.id)
+    out["summary"] = summarymod.build(s, out)      # what a deeper-fix check would receive: no content (summary.py)
     return out
 
 

{sessioncost-0.2.2 → sessioncost-0.3.1}/sessioncost/cli.py

@@ -64,6 +64,34 @@ def summary(a: dict, path: Path | None) -> str:
     return "\n".join(lines)
 
 
+OLD_REPORTS_HINT = 10      # past this many older reports, the summary says how to delete them (it never asks)
+
+
+def old_reports(keep: Path | None, folder: Path = REPORTS) -> list[Path]:
+    """Every saved report except the one to keep (the current one; by default the newest)."""
+    files = sorted(folder.glob("*.html"), key=lambda f: f.stat().st_mtime, reverse=True) if folder.is_dir() else []
+    keep = keep or (files[0] if files else None)
+    return [f for f in files if keep is None or f.resolve() != keep.resolve()]
+
+
+def size(n: int) -> str:
+    return f"{n / 1e6:.1f} MB" if n >= 1e6 else f"{max(1, round(n / 1e3))} KB"
+
+
+def cmd_clean(folder: Path = REPORTS) -> int:
+    old = old_reports(None, folder)
+    if not old:
+        print("No older reports to delete.")
+        return 0
+    freed = sum(f.stat().st_size for f in old)
+    for f in old:
+        f.unlink()
+    kept = sorted(folder.glob("*.html"))
+    print(f"Deleted {plural(len(old), 'older report')} ({size(freed)})." +
+          (f" Kept the latest: {kept[0]}" if kept else ""))
+    return 0
+
+
 def build(path, args) -> tuple[dict, Path | None]:
     s = readers.read(path)
     if args.cursor_usage:
@@ -173,7 +201,7 @@ def main(argv: list[str] | None = None) -> int:
         description="See where every token of your agent session went, turn by turn, and what to fix. "
                     "Local only: reads log files, sends nothing anywhere.")
     ap.add_argument("target", nargs="?", default="last",
-                    help="'last' (newest Claude Code, Codex, Antigravity or Cursor session of this project, the default), 'list', 'setup' (add /sessioncost to your agents), or a session file (.jsonl, or an Antigravity .db)")
+                    help="'last' (newest Claude Code, Codex, Antigravity or Cursor session of this project, the default), 'list', 'setup' (add /sessioncost to your agents), 'clean' (delete all saved reports but the latest), or a session file (.jsonl, or an Antigravity .db)")
     ap.add_argument("--project", help="project folder (default: the current folder)")
     ap.add_argument("--no-open", action="store_true", help="write the report but do not open it")
     ap.add_argument("--json", action="store_true", help="print the full model as JSON instead of a report")
@@ -188,6 +216,8 @@ def main(argv: list[str] | None = None) -> int:
 
     if args.target == "setup":
         return cmd_setup()
+    if args.target == "clean":
+        return cmd_clean()
     if args.target == "list":
         return cmd_list(args)
     if args.target == "last":
@@ -213,6 +243,9 @@ def main(argv: list[str] | None = None) -> int:
         print(json.dumps(a, indent=1, ensure_ascii=False, default=str))
         return 0
     print(summary(a, out))
+    old = old_reports(out) if out else []
+    if len(old) > OLD_REPORTS_HINT:
+        print(f"Old reports: {len(old)} ({size(sum(f.stat().st_size for f in old))}) · delete them with: sessioncost clean")
     if out and not args.no_open:
         webbrowser.open(out.resolve().as_uri())
     return 0

{sessioncost-0.2.2 → sessioncost-0.3.1}/sessioncost/report_template.html

@@ -5,6 +5,7 @@
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>__TITLE__ · SessionCost</title>
 <link rel="preconnect" href="https://fonts.googleapis.com">
+<script>try{var th=localStorage.getItem('sessioncost-theme');if(th==='light'||th==='dark')document.documentElement.dataset.theme=th;}catch(e){}</script>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap">
 <style>
 /* One column of panels: headline, turns (with drill-down), replay, where the cost went, fixes, fixed setup.
@@ -12,7 +13,7 @@
 :root{
   --bg:#f5f6f8; --surface:#ffffff; --raise:#f9fafb; --line:#e3e6eb; --grid:#eceef2;
   --ink:#14171c; --ink-2:#454b56; --ink-3:#5d636e;
-  --c-write:#4a3aa7; --c-new:#1baf7a; --c-reread:#d99400; --c-setup:#8a93a3;
+  --c-write:#4a3aa7; --c-new:#1baf7a; --c-reread:#d99400; --c-setup:#8a93a3; --c-hist:#3d7fd1;
   --accent:#2a78d6; --helper:#eb6834;
   --chip-bg:#e3f1ff; --chip:#1c5cab; --warn-bg:#fdf0e3; --warn:#9a4d0b;
   --focus:#2a78d6;
@@ -23,18 +24,24 @@
 @media (prefers-color-scheme: dark){:root:not([data-theme="light"]){
   --bg:#101216; --surface:#181b20; --raise:#1d2026; --line:#2a2e35; --grid:#22262c;
   --ink:#f2f3f5; --ink-2:#cdd1d8; --ink-3:#a6acb7;
-  --c-write:#9085e9; --c-new:#1c9e70; --c-reread:#bf8610; --c-setup:#6b7381;
+  --c-write:#9085e9; --c-new:#1c9e70; --c-reread:#bf8610; --c-setup:#6b7381; --c-hist:#5b95e0;
   --accent:#5b9be8; --helper:#e2723f;
   --chip-bg:#16273d; --chip:#9ec5f4; --warn-bg:#3a2a16; --warn:#f2bf86;
   --focus:#86b6ef; color-scheme:dark}}
 :root[data-theme="dark"]{
   --bg:#101216; --surface:#181b20; --raise:#1d2026; --line:#2a2e35; --grid:#22262c;
   --ink:#f2f3f5; --ink-2:#cdd1d8; --ink-3:#a6acb7;
-  --c-write:#9085e9; --c-new:#1c9e70; --c-reread:#bf8610; --c-setup:#6b7381;
+  --c-write:#9085e9; --c-new:#1c9e70; --c-reread:#bf8610; --c-setup:#6b7381; --c-hist:#5b95e0;
   --accent:#5b9be8; --helper:#e2723f;
   --chip-bg:#16273d; --chip:#9ec5f4; --warn-bg:#3a2a16; --warn:#f2bf86;
   --focus:#86b6ef; color-scheme:dark}
 *{box-sizing:border-box}
+header{position:relative}
+.theme{position:absolute;top:0;right:0;display:inline-flex;align-items:center;gap:6px;font:600 12px var(--f-body);color:var(--ink-2);background:var(--surface);border:1px solid var(--line);border-radius:999px;padding:5px 11px;cursor:pointer}
+.theme:hover{color:var(--ink);border-color:var(--ink-3)}
+.theme:focus-visible{outline:2px solid var(--focus);outline-offset:2px}
+.theme svg{width:14px;height:14px}
+@media (max-width:640px){.theme{position:static;margin-bottom:8px}}
 [hidden]{display:none !important}
 html{-webkit-text-size-adjust:100%}
 body{margin:0;background:var(--bg);color:var(--ink);font-family:var(--f-body);font-size:15px;line-height:1.55;-webkit-font-smoothing:antialiased}
@@ -60,7 +67,10 @@ code{font-family:var(--f-mono);font-size:.92em;overflow-wrap:anywhere}
 .kpi{background:var(--surface);border:1px solid var(--line);border-radius:10px;padding:12px 14px;min-width:0;display:flex;flex-direction:column;gap:4px}
 .kpi .v{font-size:26px;white-space:nowrap;font-weight:700;line-height:1.15;letter-spacing:-.02em;font-variant-numeric:tabular-nums}
 .kpi .s{color:var(--ink-2);font-size:13px}
-.kpi .eyebrow{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.kpi .eyebrow{white-space:normal;overflow-wrap:anywhere;line-height:1.3}
+/* inside a tile nothing is cut: chips wrap onto a second line */
+.kpi .chip{white-space:normal;border-radius:8px;line-height:1.3;padding:3px 8px;max-width:100%}
+.kpi .s{overflow-wrap:anywhere}
 button.kpi{font:inherit;color:inherit;text-align:left;cursor:pointer;transition:border-color .15s,box-shadow .15s}
 button.kpi:hover{border-color:var(--ink-3)}
 button.kpi:focus-visible{outline:2px solid var(--focus);outline-offset:2px}
@@ -148,6 +158,20 @@ button{font:inherit;color:inherit}
 /* stacked mini bar */
 .stack{display:flex;height:10px;border-radius:3px;overflow:hidden;background:var(--grid);min-width:0}
 .stack span{display:block;height:100%}
+.s-hist{background:var(--c-hist)}
+/* under each bar: the share of what was sent that was re-read from the cache (cheap); the rest went at full price */
+.cacheline{height:4px;margin-top:3px;border-radius:2px;background:var(--grid);overflow:hidden;min-width:0}
+.cacheline span{display:block;height:100%;background:var(--c-reread)}
+.sw.line{height:4px;vertical-align:2px}
+/* the numbers right under a bar: its parts in the bar's colours, then what came from the cache */
+.barnums{font-size:12px;color:var(--ink-2);margin-top:5px;line-height:1.45;font-variant-numeric:tabular-nums}
+.barnums .dot{display:inline-block;width:8px;height:8px;border-radius:2px;margin-right:4px;vertical-align:0}
+.barnums .dot.line{height:4px;width:10px;vertical-align:2px}
+.barnums b{font-weight:600;color:var(--ink)}
+.barnums .cache{color:var(--ink-3)}
+table.t.steps .sub-item{display:block;padding-left:22px;color:var(--ink-3);font-size:12.5px}
+table.t.steps .dot{display:inline-block;width:8px;height:8px;border-radius:2px;margin-right:6px}
+.sumline .dot{display:inline-block;width:10px;height:4px;border-radius:2px;margin-right:6px;vertical-align:2px}
 .s-write{background:var(--c-write)} .s-new{background:var(--c-new)} .s-reread{background:var(--c-reread)} .s-setup{background:var(--c-setup)}
 
 /* bar lists: label | track | value (the value has its own column, so it is never clipped) */
@@ -166,6 +190,8 @@ button{font:inherit;color:inherit}
 .turn > button:hover{background:var(--raise)}
 .turn > button:focus-visible{outline:2px solid var(--focus);outline-offset:-2px}
 .turn .no{color:var(--ink-3);font-size:13px;font-variant-numeric:tabular-nums}
+.turn.step0{border-style:dashed;background:var(--raise)}
+.turn.step0 .no{font-weight:700;color:var(--ink-2)}
 .turn .ask{font-weight:500;overflow-wrap:anywhere}
 .turn .meta{font-size:13px;color:var(--ink-3);display:flex;flex-wrap:wrap;gap:2px 10px;margin-top:2px}
 .turn .cost{text-align:right;font-weight:600}
@@ -271,6 +297,14 @@ input[type=range]{flex:1 1 160px;accent-color:var(--accent);min-width:120px}
 
 /* fixes, setup, footer */
 .fixes{display:grid;gap:10px}
+.deeper{margin-top:14px;border:1px dashed var(--line);border-radius:10px;padding:14px 16px;background:var(--surface)}
+.deeper-head{display:flex;gap:16px;align-items:flex-start;justify-content:space-between;flex-wrap:wrap}
+.deeper-head > div{flex:1 1 420px;min-width:0}
+.deeper h3{margin:0 0 4px;font-size:15px}
+.deeper .soon{margin:12px 0 8px;padding:10px 12px;border-radius:8px;background:var(--chip-bg);color:var(--chip);font-weight:600}
+.deeper ul{margin:6px 0 10px;padding-left:18px;color:var(--ink-2);font-size:13px}
+.deeper pre{max-height:360px;overflow:auto;background:var(--raise);border:1px solid var(--line);border-radius:8px;padding:10px;font:12px/1.45 var(--f-mono);white-space:pre-wrap;overflow-wrap:anywhere}
+.deeper .row{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin-top:8px}
 .fix{border:1px solid var(--line);border-radius:8px;padding:12px 14px;display:grid;gap:6px;background:var(--raise)}
 .fix .top{display:flex;flex-wrap:wrap;justify-content:space-between;gap:6px 12px;align-items:baseline}
 .fix ul{margin:4px 0 0;padding-left:18px;color:var(--ink-2);font-size:12px}
@@ -290,6 +324,7 @@ details summary{cursor:pointer;color:var(--ink-2);font-size:12px}
 <body>
 <div class="wrap">
   <header>
+    <button type="button" class="theme" id="theme" aria-label="Switch between light and dark"></button>
     <div class="eyebrow" id="eyebrow">SessionCost</div>
     <h1 id="title"></h1>
     <p class="sub" id="subtitle"></p>
@@ -302,9 +337,9 @@ details summary{cursor:pointer;color:var(--ink-2);font-size:12px}
 
   <section class="panel" aria-labelledby="h-turns" id="turns-panel">
     <div class="panel-head"><h2 id="h-turns">Turn by turn</h2>
-      <span class="legend"><span><span class="sw s-write"></span>written by the model</span><span><span class="sw s-new"></span>new text read</span><span><span class="sw s-reread"></span>re-read from cache</span></span></div>
+      <span class="legend"><span><span class="sw s-setup"></span>0 · fixed setup</span><span><span class="sw s-hist"></span>1 · earlier conversation</span><span><span class="sw s-new"></span>2 · new</span><span><span class="sw line s-reread"></span>re-read from cache</span></span></div>
     <p class="lede">Each row is one thing you asked. Click a row to open its model calls, then click a call to see what it sent and what it wrote. The parts always add up to the number above them.</p>
-    <div class="howto"><svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><path d="M1.5 8s2.4-4.5 6.5-4.5S14.5 8 14.5 8 12.1 12.5 8 12.5 1.5 8 1.5 8z"/><circle cx="8" cy="8" r="2"/></svg><span><b>How to read:</b> one row per message you sent. The colored bar is its cost: longer means more expensive, and the colors show what the money paid for (purple: the AI writing, green: new text read, amber: re-reading the conversation). Click a row to see the model calls behind it.</span></div>
+    <div class="howto"><svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><path d="M1.5 8s2.4-4.5 6.5-4.5S14.5 8 14.5 8 12.1 12.5 8 12.5 1.5 8 1.5 8z"/><circle cx="8" cy="8" r="2"/></svg><span><b>How to read:</b> one row per message you sent. The bar is the tokens it sent, in three parts: grey, the agent's fixed setup (step 0, sent with every call); blue, the earlier conversation sent again (step 1); green, what was new (step 2). The thin amber line under it is how much of that was re-read from the cache, cheaply; the rest went at full price. Click a row to see the model calls behind it.</span></div>
     <div class="turns" id="turns"></div>
   </section>
 
@@ -345,9 +380,20 @@ details summary{cursor:pointer;color:var(--ink-2);font-size:12px}
     <div class="panel-head"><h2 id="h-fix">What to fix</h2><span class="eyebrow">tokens cut, measured from this session</span></div>
     <p class="lede">Each saving is what those tokens or calls cost in this session, priced like the rest of this page. Fixes can overlap.</p>
     <div class="fixes" id="fixes"></div>
+    <div class="deeper" id="deeper">
+      <div class="deeper-head">
+        <div><h3>Deeper fixes</h3>
+          <p class="lede">These are the three basic checks. Our catalog of measured waste patterns has dozens more: an agent
+            polling instead of waiting, files re-read, tool results far bigger than the work, research in the main chat,
+            and others. To check them, SessionCost would share a <b>summary</b> of this session: numbers, tool names and
+            yes/no flags. Never your messages, code, file names or project.</p></div>
+        <button type="button" class="btn primary" id="deeper-btn" aria-expanded="false" aria-controls="deeper-box">Find deeper fixes</button>
+      </div>
+      <div id="deeper-box" hidden></div>
+    </div>
   </section>
 
-  <section class="panel" aria-labelledby="h-setup">
+  <section class="panel" aria-labelledby="h-setup" id="setup-panel">
     <div class="panel-head"><h2 id="h-setup">Sent with every call</h2><span class="eyebrow num" id="setup-total"></span></div>
     <p class="lede" id="setup-lede"></p>
     <div class="bars" id="setup-parts"></div>
@@ -383,6 +429,18 @@ const tin = cs => cs.reduce((a, c) => a + c.context, 0), tout = cs => cs.reduce(
 const io_ = cs => `${K(tin(cs))} in · ${K(tout(cs))} out`;
 const who = c => c.agent === 'main' ? 'Call ' + c.n : 'Helper ' + c.agent.split(':').pop().slice(0,6) + ', call ' + c.n;
 
+/* ---------- light / dark switch: follows the system until clicked, then remembers the choice ---------- */
+(function theme(){
+  const btn = $('theme'), root = document.documentElement;
+  const sun = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><circle cx="8" cy="8" r="3"/><path d="M8 1v2M8 13v2M1 8h2M13 8h2M3 3l1.4 1.4M11.6 11.6 13 13M3 13l1.4-1.4M11.6 4.4 13 3"/></svg>';
+  const moon = '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><path d="M13.5 9.5A5.5 5.5 0 0 1 6.5 2.5a5.5 5.5 0 1 0 7 7z"/></svg>';
+  const isDark = () => root.dataset.theme ? root.dataset.theme === 'dark' : matchMedia('(prefers-color-scheme: dark)').matches;
+  const paint = () => { const d = isDark(); btn.innerHTML = (d ? sun : moon) + (d ? 'Light mode' : 'Dark mode'); btn.setAttribute('aria-pressed', String(d)); };
+  btn.onclick = () => { const next = isDark() ? 'light' : 'dark'; root.dataset.theme = next;
+    try { localStorage.setItem('sessioncost-theme', next); } catch (e) {} paint(); };
+  paint();
+})();
+
 /* ---------- header ---------- */
 $('eyebrow').textContent = 'SessionCost · ' + M.agent_label + (M.date ? ' · ' + M.date : '');
 $('title').textContent = M.title;
@@ -402,7 +460,11 @@ const GLOSS = {
   apieq: ['API-equivalent', 'You pay a fixed plan, not per token. This is what the same work would cost at the public pay-per-use prices.'],
   working: ['Agent working', 'Time from each of your messages to the AI\'s last step on it, added up. Model time is the AI reading and writing; tool time is commands, searches and file reads running.'],
   waiting: ['Waiting for you', 'Time the AI sat stopped until you answered. It costs nothing, but the work stood still.'],
-  savings: ['Tokens you could cut', 'How many fewer tokens this session would have sent with each fix, measured from its own calls, not guessed. Fewer tokens sent is what lowers the cost.'],
+  savings: ['Tokens to cut', 'How many fewer tokens this session would have sent with each fix, measured from its own calls, not guessed. Fewer tokens sent is what lowers the cost.'],
+  step0: ['Step 0 · fixed setup', 'What the agent sends before you type a word, again with every call: its instructions, the list of its tools and skills, your project rules. Measured from the first call of the session. Turning off tools and skills you do not use makes it smaller.'],
+  history: ['Step 1 · earlier conversation', 'Everything said and read earlier in the chat, sent again with every call. It grows with every step, which is why long chats get expensive.'],
+  fresh: ['Step 2 · new', 'What is sent for the first time in a call: your message, a file just read, a command\'s output.'],
+  cache: ['Re-read from the cache', 'Text the model provider already has from a moment ago is read back from its cache at about a tenth of the price. The setup and the earlier conversation usually come from the cache; after a pause of more than a few minutes (one hour at most) the cache expires and everything is sent again at full price.'],
   sent: ['Tokens sent', 'Everything the agent sent to the model, added up over all its calls: its setup, the whole conversation so far, and whatever it read. Each call re-sends all of it, so this grows fast. It is what you can cut.'],
 };
 const q = k => `<span class="q" role="button" tabindex="0" data-help="${k}" aria-label="What is ${esc(GLOSS[k][0])}?">?</span>`;
@@ -428,19 +490,23 @@ const q = k => `<span class="q" role="button" tabindex="0" data-help="${k}" aria
   }, true);
   addEventListener('scroll', close, {passive: true});
 })();
+const SB = T.sent_by || {setup: 0, history: 0, new: T.sent};
+const RR_T = (T.by_class.find(c => c.key === 'cache_read') || {tokens: 0}).tokens;
+const OUT_USD = (T.by_class.find(c => c.key === 'output') || {usd: 0}).usd;
+const STEPS = [['setup', '0 · fixed setup', 'var(--c-setup)', 'step0'], ['history', '1 · earlier conversation', 'var(--c-hist)', 'history'], ['new', '2 · new', 'var(--c-new)', 'fresh']];
 const SAVE = D.fixes.reduce((a, f) => a + f.saving_usd, 0), SAVE_T = D.fixes.reduce((a, f) => a + f.saving_tokens, 0);
 const ENGINE = (D.fix_engines || []).some(n => n !== 'built-in');
 const kp = [
-  ['Tokens sent', K(T.sent), `${K(T.output)} written by the model`,
-   (() => { const rr = T.by_class.find(c => c.key === 'cache_read'); return rr && T.sent ? `<span class="chip">${pct(rr.tokens, T.sent)} re-sent history</span>` : ''; })(), '', 'tokens'],
+  ['Tokens sent', K(T.sent), `${K(SB.setup)} setup · ${K(SB.history)} conversation · ${K(SB.new)} new`,
+   T.sent ? `<span class="chip">${K(RR_T)} from the cache</span>` : '', `<div class="why">+ ${K(T.output)} written by the model</div>`, 'tokens'],
   ['Turns', T.turns, `message${T.turns === 1 ? '' : 's'} you sent`, T.turns ? `<span class="chip">${K(T.sent / T.turns)} sent per message</span>` : '', '', 'turns'],
   ['Model calls', T.calls + T.helper_calls, T.helper_calls ? `${T.calls} main · ${T.helper_calls} by helpers` : 'all in the main chat',
    T.turns ? `<span class="chip">${((T.calls + T.helper_calls) / T.turns).toFixed(1).replace(/\.0$/, '')} per message</span>` : '', '', 'calls'],
-  ['Tokens you could cut', K(SAVE_T), `${D.fixes.length} fix${D.fixes.length === 1 ? '' : 'es'} · ${pct(SAVE_T, T.sent)} of tokens sent`,
-   ENGINE ? '' : '<span class="chip warn">basic fixes only</span>', `<div class="why">saves ${$$(SAVE)} · measured from this session</div>`, 'savings'],
   ['Cost', $$(T.usd), 'the result of the tokens', `<span class="chip ${MO.exact || MO.subscription ? '' : 'warn'}">${esc(MO.short)}</span>`, '', 'total'],
   ['Agent working', mins(T.working_min), 'summed over turns', '', '', 'working'],
   ['Waiting for you', mins(T.waiting_min), 'until you replied', '', '', 'waiting'],
+  ['Tokens to cut', K(SAVE_T), `${D.fixes.length} fix${D.fixes.length === 1 ? '' : 'es'} · ${pct(SAVE_T, T.sent)} of tokens sent`,
+   ENGINE ? '' : '<span class="chip warn">basic fixes only</span>', `<div class="why">saves ${$$(SAVE)} · measured from this session</div>`, 'savings'],
 ];
 const TQ = {total: MO.subscription ? 'apieq' : MO.exact ? 'exact' : 'estimate', turns: 'turn', tokens: 'sent', calls: 'call', working: 'working', waiting: 'waiting', savings: 'savings'};
 $('kpis').innerHTML = kp.map(([l, v, s, chip, extra, key]) => `<button type="button" class="kpi" data-drill="${key}" aria-expanded="false" aria-controls="drill">` +
@@ -469,17 +535,19 @@ function openTurn(n){
   const short = s => s.length > 70 ? s.slice(0, 69) + '…' : s;
   const label = MO.subscription ? 'would have cost' : 'cost';
   $('story').innerHTML = `<p class="headline">This ${esc(M.agent_label)} session sent <b>${K(T.sent)} tokens</b>${q('sent')} to the model
-      for <b>${T.turns} message${T.turns === 1 ? '' : 's'}</b> from you${big[1] ? `, and <b>${pct(big[1], all)}</b> of the traffic was <b>${big[0]}</b>${q(big[3])}` : ''}.
+      for <b>${T.turns} message${T.turns === 1 ? '' : 's'}</b> from you: <b>${K(SB.setup)}</b> fixed setup${q('step0')}, <b>${K(SB.history)}</b> earlier conversation${q('history')} and <b>${K(SB.new)}</b> new${q('fresh')}.
+      It wrote <b>${K(T.output)}</b> back${q('out')}: few tokens, but <b>${pct(OUT_USD, T.usd)}</b> of the cost.
       That ${label} <b>${$$(T.usd)}</b>${MO.subscription ? ' at pay-per-use prices' : ''}${MO.exact ? '' : ' (an estimate)'}.</p>
     <div class="cards">
       ${top ? `<div class="card warm"><div class="eyebrow">Heaviest message</div>
         <div class="say">“${esc(short(top.t.text))}” sent <b>${K(top.s)} tokens</b>, ${pct(top.s, T.sent)} of the session (${$$(top.u)}).</div>
         <button type="button" class="act" data-turn-go="${top.t.n}">Show me this message →</button></div>` : ''}
-      <div class="card"><div class="eyebrow">Where the tokens went</div>
-        <div class="split">${parts.filter(x => x[1] > 0).map(x => `<i style="flex:${x[1]};background:${x[2]}" title="${x[0]}: ${K(x[1])} tokens"></i>`).join('')}</div>
-        <div class="split-key">${parts.filter(x => x[1] > 0).map(x => `<span><b style="background:${x[2]}"></b>${pct(x[1], all)} ${x[0]}${q(x[3])}</span>`).join('')}</div></div>
+      <div class="card"><div class="eyebrow">What was sent</div>
+        <div class="split">${STEPS.filter(x => SB[x[0]] > 0).map(x => `<i style="flex:${SB[x[0]]};background:${x[2]}" title="${x[1]}: ${K(SB[x[0]])} tokens"></i>`).join('')}</div>
+        <div class="split-key">${STEPS.map(x => `<span><b style="background:${x[2]}"></b><b class="num" style="background:none;width:auto;height:auto">${K(SB[x[0]])}</b>&nbsp;${x[1]}${q(x[3])}</span>`).join('')}
+          <span class="muted">${K(RR_T)} of it re-read from the cache${q('cache')}, ${K(T.sent - RR_T)} at full price · ${K(T.output)} written back</span></div></div>
       <div class="card work"><div class="eyebrow">How hard it worked</div>
-        <div class="say">It made <b>${C.length} model calls</b>${q('call')}, about <b>${per.toFixed(per >= 10 ? 0 : 1)} per message</b>${T.helper_calls ? `, ${T.helper_calls} of them by helpers${q('helper')}` : ''}. Each call re-sends the conversation so far.</div>
+        <div class="say">It made <b>${C.length} model call${C.length === 1 ? '' : 's'}</b>${q('call')}, about <b>${per.toFixed(per >= 10 ? 0 : 1)} per message</b>${T.helper_calls ? `, ${T.helper_calls} of them by helpers${q('helper')}` : ''}. Each call re-sends the conversation so far.</div>
         <button type="button" class="act" data-drill-go="calls">See every call →</button></div>
       <div class="card good"><div class="eyebrow">Biggest cut</div>
         ${fix ? `<div class="say"><b>${esc(fix.title)}</b>: <b>${K(fix.saving_tokens)} fewer tokens</b> sent (${pct(fix.saving_tokens, T.sent)}), saving ${$$(fix.saving_usd)} on a session like this.</div>
@@ -513,7 +581,7 @@ function tbl(head, rows, sum){
 const ofTurn = n => C.filter(c => c.turn === n);
 const turnNs = [...new Set([...D.turns.map(t => t.n), ...C.map(c => c.turn)])].sort((a, b) => a - b).filter(n => ofTurn(n).length || n);
 /* charts for the drill-downs: HTML bars (label | bar | value), one hover tip per panel, numbers one click away */
-const COL = {new: 'var(--c-new)', reread: 'var(--c-reread)', out: 'var(--c-write)', setup: 'var(--c-setup)', main: 'var(--accent)', helper: 'var(--helper)'};
+const COL = {new: 'var(--c-new)', hist: 'var(--c-hist)', reread: 'var(--c-reread)', out: 'var(--c-write)', setup: 'var(--c-setup)', main: 'var(--accent)', helper: 'var(--helper)'};
 const KQ = {'new input': 'new', 'new in': 'new', 're-read from cache': 'reread', 're-read': 'reread', 'written by the model': 'out', 'out': 'out',
   'fixed setup': 'setup', 'helpers': 'helper', 'main chat': 'call'};
 const key = items => `<div class="ch-key">${items.map(([name, col]) => `<span><b style="background:${col}"></b>${name}${KQ[name] ? q(KQ[name]) : ''}</span>`).join('')}</div>`;
@@ -530,7 +598,7 @@ function chart(rows, opts = {}){
   }).join('') + `</div>`;
 }
 const nums = html => `<details class="nums"><summary>Show the numbers</summary>${html}</details>`;
-const HOW = {"total": "the top bar is the whole cost, split by kind of token; the bars below show each kind and each of your messages. Longer means more money.", "tokens": "each row is one of your messages; its bar is the tokens it sent, split into new text read (green) and the conversation re-sent (amber). Longer means more tokens: that is what to cut.", "calls": "each row is one of your messages; the bar counts its model calls, blue in the main chat and orange by helpers. On the right, the costliest single calls.", "working": "each row is one of your messages; the bar is its working time, blue while the AI read and wrote, grey while tools (commands, searches) ran.", "waiting": "each row is a message where the AI stopped and waited: blue before you wrote, orange while a question card was open. Longer means a longer wait.", "savings": "each bar is one fix; its length is how many fewer tokens this session would have sent with it. The last row is the total."};
+const HOW = {"total": "the top bar is the whole cost, split by kind of token; the bars below show each kind and each of your messages. Longer means more money.", "tokens": "each row is one of your messages; its bar is the tokens it sent: grey the fixed setup (step 0), blue the earlier conversation (step 1), green what was new (step 2). The table adds how much was re-read from the cache. Longer means more tokens: that is what to cut.", "calls": "each row is one of your messages; the bar counts its model calls, blue in the main chat and orange by helpers. On the right, the costliest single calls.", "working": "each row is one of your messages; the bar is its working time, blue while the AI read and wrote, grey while tools (commands, searches) ran.", "waiting": "each row is a message where the AI stopped and waited: blue before you wrote, orange while a question card was open. Longer means a longer wait.", "savings": "each bar is one fix; its length is how many fewer tokens this session would have sent with it. The last row is the total."};
 const howto = k => `<div class="howto"><svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><path d="M1.5 8s2.4-4.5 6.5-4.5S14.5 8 14.5 8 12.1 12.5 8 12.5 1.5 8 1.5 8z"/><circle cx="8" cy="8" r="2"/></svg><span><b>How to read:</b> ${HOW[k]}</span></div>`;
 const tname = n => n ? `#${n} ${(D.turns.find(t => t.n === n) || {text: ''}).text}` : 'before your first message';
 const DRILL = {
@@ -550,22 +618,21 @@ const DRILL = {
           ['Total', C.length, $$(T.usd), '100%']))}</div></div>`;
   },
   tokens(){
-    const I = tin(C), RR = C.reduce((a, c) => a + c.usage.cache_read, 0), O = tout(C);
-    const setupRe = C.reduce((a, c) => { const p = c.sent.parts.find(x => x.what.startsWith('fixed setup')); return a + (p ? Math.min(p.tokens, c.usage.cache_read) : 0); }, 0);
-    const rows = turnNs.map(n => { const cs = ofTurn(n), i = tin(cs), r = cs.reduce((a, c) => a + c.usage.cache_read, 0), o = tout(cs); return {n, i, r, o}; });
-    return `<p class="lede"><b>${K(I)}</b> tokens sent to the model, <b>${K(RR)}</b> of them (${pct(RR, I)}) the conversation re-sent from the cache; <b>${K(O)}</b> written back.
-      Every call re-sends the whole conversation so far, so a long chat or a big file read early is paid for again on every later call. Cutting what is sent is what lowers the cost.</p><div class="grid2">
-      <div><h3>Sent per turn</h3>${key([['new in', COL.new], ['re-read', COL.reread]])}
+    const I = tin(C), RR = RR_T, O = tout(C);
+    const rows = turnNs.map(n => ({n, ...tmix(n)}));
+    const sum = k => rows.reduce((a, x) => a + x[k], 0);
+    return `<p class="lede"><b>${K(I)}</b> tokens sent to the model: <b>${K(SB.setup)}</b> fixed setup (step 0), <b>${K(SB.history)}</b> earlier conversation (step 1) and <b>${K(SB.new)}</b> new (step 2). <b>${K(RR)}</b> of them were re-read from the cache, cheaply; <b>${K(O)}</b> were written back.
+      Steps 0 and 1 go out again with every call, so they are what grows the bill and what you can cut.</p><div class="grid2">
+      <div><h3>Sent per turn</h3>${key(STEPS.map(x => [x[1], x[2]]))}
         ${chart([...rows.map(x => ({label: tname(x.n), segs: [
-            {v: x.i - x.r, col: COL.new, tip: `new in: ${K(x.i - x.r)}`}, {v: x.r, col: COL.reread, tip: `re-sent from cache: ${K(x.r)}`}],
-            value: K(x.i), sub: pct(x.i, I)})), {label: 'Total', sum: true, segs: [], value: K(I), sub: '100%'}])}
-        ${nums(tbl(['Turn', 'New in', 'Re-read', 'Sent', 'Written'], rows.map(x => [esc(tname(x.n).slice(0, 60)), K(x.i - x.r), K(x.r), K(x.i), K(x.o)]),
-          ['Total', K(I - RR), K(RR), K(I), K(O)]))}</div>
-      <div><h3>What the ${pct(RR, I)} re-sent is</h3>${key([['fixed setup', COL.setup], ['earlier conversation', COL.reread]])}
-        ${chart([{label: 'Re-sent in all', segs: [{v: setupRe, col: COL.setup, tip: `fixed setup: ${K(setupRe)} (${pct(setupRe, RR)})`}, {v: RR - setupRe, col: COL.reread, tip: `earlier conversation: ${K(RR - setupRe)} (${pct(RR - setupRe, RR)})`}], value: K(RR)},
-          {label: D.setup.known ? 'Fixed setup' : 'Fixed setup (not logged)', segs: [{v: setupRe, col: COL.setup, tip: 'system prompt, tool definitions, lists: sent with every call'}], value: K(setupRe), sub: pct(setupRe, RR)},
-          {label: 'Earlier conversation', segs: [{v: RR - setupRe, col: COL.reread, tip: 'everything said and read earlier in the chat'}], value: K(RR - setupRe), sub: pct(RR - setupRe, RR)}])}
-        <p class="muted" style="font-size:12px">Fixed setup: the agent's system prompt, tool definitions and lists, sent with every call. Earlier conversation: everything said and read before this call. ${D.setup.known ? 'The setup size is estimated from its text (characters ÷ 4); the rest is exact.' : 'This agent does not log its setup, so all of it shows as earlier conversation.'}</p></div></div>`;
+            {v: x.setup, col: COL.setup, tip: `fixed setup: ${K(x.setup)}`}, {v: x.history, col: COL.hist, tip: `earlier conversation: ${K(x.history)}`}, {v: x.new, col: COL.new, tip: `new: ${K(x.new)}`}],
+            value: K(x.setup + x.history + x.new), sub: pct(x.setup + x.history + x.new, I)})), {label: 'Total', sum: true, segs: [], value: K(I), sub: '100%'}])}
+        ${nums(tbl(['Turn', '0 · Setup', '1 · Conversation', '2 · New', 'Sent', 'From cache', 'Written'], rows.map(x => [esc(tname(x.n).slice(0, 60)), K(x.setup), K(x.history), K(x.new), K(x.setup + x.history + x.new), K(x.cache), K(x.written)]),
+          ['Total', K(sum('setup')), K(sum('history')), K(sum('new')), K(I), K(sum('cache')), K(O)]))}</div>
+      <div><h3>What was sent, in three steps</h3>${key(STEPS.map(x => [x[1], x[2]]))}
+        ${chart([{label: 'Sent in all', segs: STEPS.map(x => ({v: SB[x[0]], col: x[2], tip: `${x[1]}: ${K(SB[x[0]])} (${pct(SB[x[0]], I)})`})), value: K(I)},
+          ...STEPS.map(x => ({label: x[1], segs: [{v: SB[x[0]], col: x[2], tip: GLOSS[x[3]][1]}], value: K(SB[x[0]]), sub: pct(SB[x[0]], I)}))])}
+        <p class="muted" style="font-size:12px">Step 0 is measured: the first call has no conversation yet, so everything it sent except your message is the agent's setup${D.setup.known ? '' : ' (this agent does not log its setup, so it is known only from that size)'}. "Sent with every call" below shows what the setup is made of.</p></div></div>`;
   },
   calls(){
     const main = C.filter(c => c.agent === 'main'), helpers = D.helpers.filter(h => h.calls);
@@ -617,7 +684,7 @@ const DRILL = {
         nums(tbl(['Fix', 'Where', 'Tokens cut', 'Share of sent', 'Saves'], fx.map(f => [`<b>${esc(f.title)}</b><br><span class="muted">${esc(f.why)}</span>`, esc(f.where), K(f.saving_tokens), pct(f.saving_tokens, T.sent), $$(f.saving_usd)]),
           ['Total', '', K(SAVE_T), pct(SAVE_T, T.sent), $$(SAVE)])) :
         '<p class="muted">None of the checks fired for this session.</p>'}
-      <div><button type="button" class="btn" data-go="fix-panel">See the fixes in detail ↓</button></div>`;
+      <div class="row" style="display:flex;gap:8px;flex-wrap:wrap"><button type="button" class="btn" data-go="fix-panel">See the fixes in detail ↓</button>${D.summary ? '<button type="button" class="btn" data-go="deeper">Find deeper fixes ↓</button>' : ''}</div>`;
   },
 };
 let openDrill = null;
@@ -660,13 +727,26 @@ if (!reduce && 'IntersectionObserver' in window){
 /* ---------- turns + drill-down ---------- */
 const maxTurn = Math.max(...D.turns.map(t => t.sent + t.helper_sent), 1);
 /* a turn's tokens by kind: new text read, conversation re-sent, written */
-const tmix = n => { const cs = ofTurn(n), rr = cs.reduce((a, c) => a + c.usage.cache_read, 0);
-  return {new: tin(cs) - rr, reread: rr, written: tout(cs)}; };
+const tmix = n => { const cs = ofTurn(n), s = k => cs.reduce((a, c) => a + (c.sent[k] || 0), 0);
+  return {setup: s('setup'), history: s('history'), new: s('new'), written: tout(cs), cache: cs.reduce((a, c) => a + c.usage.cache_read, 0)}; };
 const FIXBY = {}; D.fixes.forEach(f => FIXBY[f.id] = f);
+const dot = c => `<i class="dot ${c}"></i>`;
+/* under a bar, numbers only (the colours say which part): "■45K + ■1.3K + ■8.2K = 55K", then "▬44K" from the cache.
+   The words are in the hover text and for screen readers. */
+function barNums(mix){
+  const tot = mix.setup + mix.history + mix.new;
+  const parts = [['s-setup', mix.setup, 'fixed setup'], ['s-hist', mix.history, 'earlier conversation'], ['s-new', mix.new, 'new']].filter(x => x[1] > 0);
+  const said = parts.map(([, v, w]) => `${K(v)} ${w}`).join(' + ') + ` = ${K(tot)} sent; ${K(mix.cache)} re-read from the cache, ${K(tot - mix.cache)} at full price`;
+  return `<div class="barnums" title="${said}" aria-label="${said}"><div aria-hidden="true">${parts.map(([c, v]) => `${dot(c)}<b>${K(v)}</b>`).join(' + ')}${parts.length > 1 ? ` = <b>${K(tot)}</b>` : ''}` +
+    `<span class="cache">&nbsp;&nbsp;${dot('s-reread line')}${K(mix.cache)}</span></div></div>`;
+}
 function stack(mix, scale){
-  const tot = mix.new + mix.reread; if (!tot) return '<div class="stack" style="width:2%"></div>';
-  return `<div class="stack" style="width:${Math.max(2, scale * 100)}%" title="sent ${K(tot)}: new text read ${K(mix.new)} · conversation re-sent ${K(mix.reread)} · then written ${K(mix.written)}">` +
-    [['s-new', mix.new], ['s-reread', mix.reread]].map(([c, v]) => v > 0 ? `<span class="${c}" style="width:${v / tot * 100}%"></span>` : '').join('') + '</div>';
+  const tot = mix.setup + mix.history + mix.new; if (!tot) return '<div class="stack" style="width:2%"></div>';
+  const w = Math.max(2, scale * 100);
+  return `<div class="stack" style="width:${w}%" title="sent ${K(tot)}: fixed setup ${K(mix.setup)} · earlier conversation ${K(mix.history)} · new ${K(mix.new)}">` +
+    [['s-setup', mix.setup], ['s-hist', mix.history], ['s-new', mix.new]].map(([c, v]) => v > 0 ? `<span class="${c}" style="width:${v / tot * 100}%"></span>` : '').join('') + '</div>' +
+    `<div class="cacheline" style="width:${w}%" title="re-read from the cache: ${K(mix.cache)} of ${K(tot)} (${pct(mix.cache, tot)}); full price: ${K(tot - mix.cache)}"><span style="width:${mix.cache / tot * 100}%"></span></div>` +
+    barNums(mix);
 }
 function turnRow(t, i){
   const cost = t.usd + t.helper_usd, sent = t.sent + t.helper_sent;
@@ -681,17 +761,33 @@ function turnRow(t, i){
     <span class="cost num">${K(sent)}<small>sent · ${pct(sent, T.sent)} of all</small></span>
   </button><div class="drill" hidden></div></div>`;
 }
-$('turns').innerHTML = D.turns.map(turnRow).join('');
+/* step 0: the agent's setup, sent before your first message and again with every call */
+function step0Row(){
+  const s = D.setup.tokens || 0, mainCalls = C.filter(c => c.agent === 'main').length;
+  if (!s) return '';
+  const sCache = C.filter(c => c.agent === 'main').reduce((a, c) => a + Math.min(c.sent.setup || 0, c.usage.cache_read), 0);
+  return `<div class="turn step0"><button type="button" data-go="setup-panel">
+    <span class="no">0</span>
+    <span><span class="ask">Step 0 · the agent's setup, before your first message</span>
+      <span class="meta"><span>its instructions, tools and skills</span><span>sent again with every call</span><span>the grey part of every bar below</span></span></span>
+    <span class="mini"><div class="stack" style="width:${Math.max(2, s / maxTurn * 100)}%" title="fixed setup: ${K(s)} per call"><span class="s-setup" style="width:100%"></span></div><div class="cacheline" style="width:${Math.max(2, s / maxTurn * 100)}%" title="re-read from the cache: ${pct(sCache, SB.setup)} of the setup sent"><span style="width:${SB.setup ? sCache / SB.setup * 100 : 0}%"></span></div>
+      <div class="barnums" title="${K(s)} per call × ${mainCalls} call${mainCalls === 1 ? '' : 's'} = ${K(SB.setup)}; ${K(sCache)} re-read from the cache" aria-label="${K(s)} per call times ${mainCalls} calls = ${K(SB.setup)}; ${K(sCache)} re-read from the cache"><div aria-hidden="true">${dot('s-setup')}<b>${K(s)}</b> × ${mainCalls} = <b>${K(SB.setup)}</b><span class="cache">&nbsp;&nbsp;${dot('s-reread line')}${K(sCache)}</span></div></div></span>
+    <span class="cost num">${K(s)}<small>per call</small></span>
+  </button></div>`;
+}
+$('turns').innerHTML = step0Row() + D.turns.map(turnRow).join('');
 function turnDrill(t){
   const cs = t.calls.map(i => C[i]);
   const evs = t.events.map(e => `<span class="ev ${['typed','command','queued','answer'].includes(e.kind) ? 'you' : ''}" title="${esc(e.text)}">${esc(e.label)}${e.kind === 'answer' && e.text ? ': “' + esc(e.text.slice(0, 60)) + '”' : ''}${e.tokens ? ' · ~' + K(e.tokens) : ''}</span>`).join('');
-  let sum = (cs.length <= 6 ? 'sent ' + cs.map(c => K(c.context)).join(' + ') + ' = <b>' + K(t.sent) + ' tokens</b>'
+  let sum = (cs.length === 1 ? `1 call sent <b>${K(t.sent)} tokens</b>`
+            : cs.length <= 6 ? `${cs.length} calls sent ` + cs.map(c => K(c.context)).join(' + ') + ' = <b>' + K(t.sent) + ' tokens</b>'
                              : `${cs.length} calls (each listed below) sent <b>${K(t.sent)} tokens</b>`) + ` · cost ${$$(t.usd, 4)}`;
   if (t.helper_sent) sum += ` · plus helpers started in this turn: ${K(t.helper_sent)} tokens, ${$$(t.helper_usd, 4)}`;
   return `${evs ? `<div><div class="eyebrow" style="margin-bottom:4px">What came in this turn (~ tokens)</div><div class="events">${evs}</div></div>` : ''}
     <div class="sumline num">${sum}</div>
     <div class="calls">${t.calls.map(i => { const c = C[i]; return `<div class="call"><button type="button" aria-expanded="false" data-call="${i}">
-      <span><span class="what"><span class="caret" aria-hidden="true"><svg viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M4.5 2.5 8 6l-3.5 3.5"/></svg></span>${md(c.label)}</span><br><span class="tag">${who(c)} · ${c.time} · ${esc(catLabel(c.category))} · wrote ${K(c.usage.output)} · ${$$(c.usd, 4)}</span></span>
+      <span><span class="what"><span class="caret" aria-hidden="true"><svg viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M4.5 2.5 8 6l-3.5 3.5"/></svg></span>${md(c.label)}</span><br><span class="tag">${who(c)} · ${c.time} · ${esc(catLabel(c.category))} · wrote ${K(c.usage.output)} · ${$$(c.usd, 4)}</span>
+      ${barNums({setup: c.sent.setup || 0, history: c.sent.history || 0, new: c.sent.new || 0, cache: c.usage.cache_read})}</span>
       <span class="c num">${K(c.context)}<small style="display:block;font-size:11px;color:var(--muted);font-weight:400">sent</small></span></button><div class="parts" hidden></div></div>`; }).join('')}</div>`;
 }
 function partsTable(title, block, unit){
@@ -701,19 +797,38 @@ function partsTable(title, block, unit){
 }
 function callDrill(c){
   const u = c.usage, cc = c.cost_by_class;
-  const items = c.new_items.length ? `<details><summary>Where the new input came from (${c.new_items.length})</summary><table class="t">${c.new_items.map(x => `<tr><td>${md(x.what)}</td><td class="n num">~${N(x.tokens)}</td></tr>`).join('')}</table></details>` : '';
+  const part = pre => c.sent.parts.find(x => x.what.startsWith(pre)) || {tokens: 0, usd: 0, what: ''};
+  const s0 = part('fixed setup'), s1 = part('earlier conversation'), s2 = part('new input');
+  const row = (label, tokens, usd, cls = '') => `<tr class="${cls}"><td>${label}</td><td class="n num">${tokens}</td><td class="n num">${usd}</td></tr>`;
+  /* step 2 itemised: what the log names, then the rest it does not */
+  const named = c.new_items.reduce((a, x) => a + x.tokens, 0), rest = s2.tokens - named;
+  const items = c.new_items.map(x => row(`<span class="sub-item">${md(x.what)}</span>`, '~' + N(x.tokens), ''))
+    .concat(rest > 50 && c.new_items.length ? [row('<span class="sub-item">not itemised in the log (added by the agent without recording it)</span>', '~' + N(rest), '')] : []).join('');
+  const expired = s1.what.includes('expired') ? ' <span class="chip warn">sent again: the cache had expired</span>' : '';
+  const wrote = c.written.parts.map(x => row(`<span class="sub-item">${esc(x.what)}${x.estimated ? ' <span class="est">~ estimated split</span>' : ''}</span>`, N(x.tokens), $$(x.usd, 4))).join('');
   const acts = c.actions.length ? `<details><summary>Actions in this call (${c.actions.length})</summary><table class="t">${c.actions.map(a => `<tr><td>${md(a.label)}${a.error ? ' <span class="chip warn">error</span>' : ''}</td><td class="n num">${a.result_tokens ? '~' + N(a.result_tokens) + ' came back' : ''}</td></tr>`).join('')}</table></details>` : '';
   const think = u.thinking == null ? '<p class="est">This log does not separate hidden thinking from the rest of the output, so it is estimated.</p>' : '';
-  return `<div class="parts-grid">${partsTable('What it sent', c.sent, 'sent this call')}${partsTable('What it wrote', c.written, 'written this call')}</div>
+  const notCached = Math.max(0, c.context - u.cache_read - u.cache_write_5m - u.cache_write_1h);
+  return `<table class="t steps"><thead><tr><th>What this call sent</th><th class="n">tokens</th><th class="n">cost</th></tr></thead><tbody>
+      ${c.agent === 'main' ? row(`${dot('s-setup')}Step 0 · fixed setup`, N(s0.tokens), $$(s0.usd, 4)) : ''}
+      ${row(`${dot('s-hist')}Step 1 · earlier conversation${expired}`, N(s1.tokens), $$(s1.usd, 4))}
+      ${row(`${dot('s-new')}Step 2 · new`, N(s2.tokens), $$(s2.usd, 4))}
+      ${items}
+      ${row('= sent', N(c.context), $$(c.sent.usd, 4), 'sum')}
+    </tbody></table>
+    <div class="sumline num">${dot('s-reread line')}of which re-read from the cache <b>${N(u.cache_read)}</b> (cheap) · written to the cache ${N(u.cache_write_5m + u.cache_write_1h)} · not cached ${N(notCached)}</div>
+    <table class="t steps"><thead><tr><th>What it wrote</th><th class="n">tokens</th><th class="n">cost</th></tr></thead><tbody>
+      ${wrote}${row('= written', N(c.written.tokens), $$(c.written.usd, 4), 'sum')}</tbody></table>
     <div class="sumline num">sent ${$$(c.sent.usd, 4)} + written ${$$(c.written.usd, 4)} = <b>${$$(c.usd, 4)}</b> for this call · ${esc(c.model)}</div>
-    <details><summary>Exact token counts from the log</summary><table class="t">
-      <tr><td>new input, not cached</td><td class="n num">${N(u.input)}</td><td class="n num">${$$(cc.input, 4)}</td></tr>
-      <tr><td>new input, cached for 5 minutes</td><td class="n num">${N(u.cache_write_5m)}</td><td class="n num">${$$(cc.cache_write_5m, 4)}</td></tr>
-      <tr><td>new input, cached for 1 hour</td><td class="n num">${N(u.cache_write_1h)}</td><td class="n num">${$$(cc.cache_write_1h, 4)}</td></tr>
-      <tr><td>re-read from cache</td><td class="n num">${N(u.cache_read)}</td><td class="n num">${$$(cc.cache_read, 4)}</td></tr>
-      <tr><td>written${u.thinking != null ? ' (of which ' + N(u.thinking) + ' hidden thinking)' : ''}</td><td class="n num">${N(u.output)}</td><td class="n num">${$$(cc.output, 4)}</td></tr>
-      <tr class="sum"><td>= this call</td><td class="n num">${N(c.context + u.output)}</td><td class="n num">${$$(c.usd, 4)}</td></tr></table></details>
-    ${items}${acts}${think}`;
+    <details><summary>As the log records it (by cache status)</summary><table class="t">
+      ${row('new input, not cached', N(u.input), $$(cc.input, 4))}
+      ${row('new input, cached for 5 minutes', N(u.cache_write_5m), $$(cc.cache_write_5m, 4))}
+      ${row('new input, cached for 1 hour', N(u.cache_write_1h), $$(cc.cache_write_1h, 4))}
+      ${row('re-read from cache', N(u.cache_read), $$(cc.cache_read, 4))}
+      ${row(`written${u.thinking != null ? ' (of which ' + N(u.thinking) + ' hidden thinking)' : ''}`, N(u.output), $$(cc.output, 4))}
+      ${row('= this call', N(c.context + u.output), $$(c.usd, 4), 'sum')}</table>
+      <p class="muted" style="font-size:12px">The same tokens as above, grouped the way the log counts them. The steps above group them by what they are.</p></details>
+    ${acts}${think}`;
 }
 function toggle(btn, box, fill){
   const open = btn.getAttribute('aria-expanded') !== 'true';
@@ -723,6 +838,8 @@ function toggle(btn, box, fill){
   return open;
 }
 $('turns').addEventListener('click', e => {
+  const go = e.target.closest('[data-go]');
+  if (go){ $(go.dataset.go).scrollIntoView({behavior: reduce ? 'auto' : 'smooth', block: 'start'}); return; }
   const cb = e.target.closest('button[data-call]');
   if (cb){ toggle(cb, cb.nextElementSibling, () => callDrill(C[+cb.dataset.call])); return; }
   const tb = e.target.closest('button[data-turn]');
@@ -876,12 +993,38 @@ $('fixes').innerHTML = D.fixes.length ? D.fixes.map(f => `<div class="fix"><div
   ${f.items.length ? `<details><summary>Details (${f.items.length})</summary><ul>${f.items.map(x => `<li>${md(x)}</li>`).join('')}</ul></details>` : ''}</div>`).join('')
   : '<p class="lede">None of the built-in checks fired: no unused tools sent with every call, no unchanged file read twice, no stop that only waited for a yes.</p>';
 
+/* ---------- deeper fixes: preview what would be shared; nothing is sent yet ---------- */
+(function deeper(){
+  const SUM = D.summary, btn = $('deeper-btn'), box = $('deeper-box');
+  if (!SUM){ $('deeper').hidden = true; return; }
+  const json = JSON.stringify(SUM, null, 2), kb = Math.max(1, Math.round(json.length / 1024));
+  const steps = SUM.calls.reduce((a, c) => a + c.steps.length, 0);
+  const codes = new Set(SUM.calls.flatMap(c => c.steps.map(s => s.target).filter(Boolean)));
+  box.innerHTML = `<div class="soon">Coming soon: deeper fixes from our catalog of measured patterns. Nothing has been sent: this is a preview of what would be shared.</div>
+    <b>What the summary holds</b>
+    <ul><li>For each of the ${SUM.calls.length} model calls: when it ran (seconds from the start), its model, and the tokens it sent (setup, earlier conversation, new) and wrote.</li>
+      <li>For each of the ${steps} tool steps: the tool's name, its size in tokens, whether it failed, and how long it took. Commands only by their program (like <code>git</code> or <code>python</code>) and yes/no flags (chained, waits, rewrites a file).</li>
+      <li>Files and commands only as codes (${codes.size} codes like <code>f1</code>, <code>c2</code>), new for every summary, so a file read twice shows as the same code without its name.</li>
+      <li>The size of the agent's setup, how many tools it defines and uses, your ${SUM.turns.length} turns' sizes and waits, and the basic fixes found.</li></ul>
+    <b>What it never holds</b>
+    <ul><li>Your messages or the agent's replies, code or file contents, command text, file or folder names, the project name, the session id, or clock times.</li></ul>
+    <details><summary>See the exact summary (${kb} KB)</summary><pre id="deeper-json"></pre>
+      <div class="row"><button type="button" class="btn" id="deeper-copy">Copy</button><span class="muted" id="deeper-copied" style="font-size:12px"></span></div></details>`;
+  $('deeper-json').textContent = json;
+  $('deeper-copy').onclick = async () => {
+    try { await navigator.clipboard.writeText(json); $('deeper-copied').textContent = 'Copied.'; }
+    catch (e) { $('deeper-copied').textContent = 'Could not copy here: select the text above instead.'; }
+  };
+  btn.onclick = () => { const open = box.hidden; box.hidden = !open; btn.setAttribute('aria-expanded', String(open));
+    btn.textContent = open ? 'Hide' : 'Find deeper fixes'; if (open) box.scrollIntoView({behavior: reduce ? 'auto' : 'smooth', block: 'nearest'}); };
+})();
+
 /* ---------- setup ---------- */
 const S = D.setup;
-if (S.known){
-  $('setup-total').textContent = '~' + K(S.tokens) + ' tokens';
-  $('setup-lede').innerHTML = `Before you say a word, every call carries about <b>${K(S.tokens)}</b> tokens of the agent's own setup. After the first call it is mostly re-read from the cache: cheap per call, but never free.` +
-    (S.tools.length ? ` <b>${S.unused.length} of ${S.tools.length}</b> tool definitions (~${K(S.unused_tokens)} tokens) were never used in this session.` : '') + ' Sizes are estimates (characters ÷ 4).';
+if (S.measured && S.tokens){
+  $('setup-total').textContent = K(S.tokens) + ' tokens';
+  $('setup-lede').innerHTML = `Step 0: before you say a word, every call carries <b>${K(S.tokens)}</b> tokens of the agent's own setup, measured from the first call of this session. After the first call it is mostly re-read from the cache: cheap per call, but never free.` +
+    (S.tools.length ? ` <b>${S.unused.length} of ${S.tools.length}</b> tool definitions (~${K(S.unused_tokens)} tokens) were never used in this session.` : '') + (S.parts.length > 1 ? ' The split into parts is estimated from their text (characters ÷ 4).' : '');
   barList('setup-parts', [...S.parts].sort((a, b) => b.tokens - a.tokens).map(p => ({l: esc(p.what), v: p.tokens, s: '~' + K(p.tokens)})), '--c-setup');
   $('tools-sum').textContent = `Each tool definition (${S.tools.length}) and whether this session used it`;
   $('tools').innerHTML = S.tools.map(t => `<div class="${t.used ? '' : 'unused'}"><span>${esc(t.name)}${t.used ? '' : ' · never used'}</span><span class="num">~${K(t.tokens)}</span></div>`).join('');

{sessioncost-0.2.2 → sessioncost-0.3.1}/sessioncost/skill/SKILL.md

@@ -29,11 +29,24 @@ no AI model.
    and its path from the summary. Do not offer to open it. Only if the user says it did not open, open the file with
    the system's default opener (`start "" <path>` on Windows, `open <path>` on macOS, `xdg-open <path>` on Linux).
 
+## Deleting old reports
+
+Each session keeps one report in `~/.sessioncost/reports/`. If the summary ends with an "Old reports: ..." line, show
+it as printed and do not ask anything about it. Only when the user asks to delete or clean old reports (for example
+"/sessioncost clean"), run (with the same fallbacks as step 1):
+
+```
+{{RUN}} clean
+```
+
+It deletes every saved report except the latest and prints what it freed. Show that line.
+
 ## Never
 
 - Never read the session log or the HTML report into the conversation. Both are large; reading them would cost more
   tokens than the session you are measuring.
 - Never run `--json` unless the user asks for the raw numbers, and then show only the part they asked about.
 - Never estimate costs yourself. The tool's numbers are the answer.
+- Never delete reports unless the user asked for it.
 - If the user says they are on a subscription plan (Claude Pro or Max, a ChatGPT plan), add `--subscription` so money
   is labelled API-equivalent. Antigravity is always labelled that way.

sessioncost-0.3.1/sessioncost/summary.py

@@ -0,0 +1,157 @@
+"""The summary SessionCost would send for deeper fixes: numbers, tool names and yes/no flags, never content.
+
+What it never holds: your messages, the agent's replies, code, file contents, command text, file or folder names,
+the project name, the session id, or clock times. Files and commands appear only as short codes that are random for
+each summary ("f3", "c7"), so the same file read twice shows as the same code without saying which file it is.
+Times are seconds from the start of the session.
+
+Nothing is sent yet: the report shows this summary so you can see exactly what would be shared.
+"""
+from __future__ import annotations
+
+import re
+
+from . import __version__
+
+FORMAT = "sessioncost-summary/1"
+
+# Program names that say what kind of step a command was, and nothing about your project. Anything else is "other".
+PROGRAMS = {
+    "git", "gh", "npm", "npx", "pnpm", "yarn", "node", "bun", "deno", "python", "python3", "py", "pip", "pip3", "uv",
+    "uvx", "pytest", "go", "cargo", "rustc", "java", "mvn", "gradle", "dotnet", "make", "cmake", "docker", "kubectl",
+    "ls", "dir", "cat", "head", "tail", "type", "grep", "rg", "find", "sed", "awk", "echo", "cd", "pwd", "mkdir", "rm",
+    "cp", "mv", "touch", "chmod", "curl", "wget", "sleep", "timeout", "start-sleep", "netstat", "lsof", "ps", "kill",
+    "tasklist", "taskkill", "get-childitem", "get-content", "set-content", "select-string", "powershell", "pwsh",
+    "bash", "sh", "cmd", "wc", "sort", "diff", "tar", "zip", "unzip", "which", "where", "ssh", "scp", "jq",
+}
+GIT_SUB = {"status", "diff", "log", "add", "commit", "push", "pull", "fetch", "checkout", "switch", "branch", "merge",
+           "rebase", "stash", "show", "reset", "tag", "clone", "init", "remote", "rev-parse", "ls-files", "restore"}
+SOURCE_EXT = r"\.(py|js|jsx|ts|tsx|mjs|cjs|go|rs|java|kt|cs|cpp|c|h|rb|php|swift|html|css|scss|vue|svelte|json|ya?ml|toml|md)\b"
+
+
+def _flags(cmd: str) -> list[str]:
+    """Yes/no facts about a command's shape. The command text itself is not kept."""
+    whole = cmd.strip()
+    c = whole.splitlines()[0] if whole else ""          # the shape is the first line; a script body is not a chain
+    low = c.lower()
+    f = []
+    if re.search(r"(^|\s)(--help|-h|/\?)(\s|$)|\bhelp\b", low):
+        f.append("help")
+    if re.match(r"(cd|set-location|pushd)\s", low):
+        f.append("cd_prefix")
+    if "&&" in c or re.search(r";\s*\S", c):
+        f.append("chained")
+    if re.search(r"(^|\s)&\s*$|start-process|nohup|run_in_background", low):
+        f.append("background")
+    if re.match(r"(sleep|start-sleep|timeout)\b", low):
+        f.append("wait")
+    wl = whole.lower()
+    if re.search(r"(sed\s+-i|perl\s+-pi|set-content|out-file|python3?\s+-c|>\s*\S+" + SOURCE_EXT + r"|<<)", wl) \
+            and re.search(r"(write_text|>\s*\S+|sed\s+-i|set-content|out-file|\.write\()", wl) and re.search(SOURCE_EXT, wl):
+        f.append("rewrites_file")
+    return f
+
+
+def _program(cmd: str) -> tuple[str, str]:
+    words = re.findall(r"[^\s;&|]+", cmd.strip())
+    i = 0
+    while i < len(words) and (words[i].lower() in ("cd", "set-location", "pushd") or "=" in words[i]):
+        i += 2 if words[i].lower() in ("cd", "set-location", "pushd") else 1          # skip "cd dir &&" and VAR=x
+        while i < len(words) and words[i] in ("&&", ";"):
+            i += 1
+    if i >= len(words):
+        return "other", ""
+    prog = re.split(r"[\\/]", words[i].strip("\"'"))[-1].lower().removesuffix(".exe")
+    if prog not in PROGRAMS:
+        return "other", ""
+    sub = ""
+    if prog == "git" and i + 1 < len(words) and words[i + 1].lower() in GIT_SUB:
+        sub = words[i + 1].lower()
+    return prog, sub
+
+
+SETUP_KINDS = [("system prompt", "system prompt"), ("base instructions", "system prompt"), ("tool definition", "tool definitions"),
+               ("skill", "skill list"), ("helper", "helper list"), ("agent", "helper list"), ("loaded on demand", "deferred tool names"),
+               ("mcp", "MCP server instructions"), ("instruction", "instruction files"), ("rule", "instruction files"),
+               ("context", "session context"), ("built-in", "built-in instructions (not in the log)")]
+
+
+def _setup_kind(what: str) -> str:
+    """Setup parts can be named after your own files (Cursor, Codex): keep only a generic kind."""
+    w = what.lower()
+    if w.startswith("the agent's built-in"):
+        return "built-in instructions (not in the log)"
+    return next((kind for key, kind in SETUP_KINDS if key in w), "other")
+
+
+def _tool_name(tool: str) -> str:
+    """The agent's own tool names (Read, Bash, ...) are public. MCP tool names can name private servers: keep only
+    that it was an MCP tool."""
+    return "mcp" if tool.lower().startswith("mcp") else tool
+
+
+def build(s, a: dict) -> dict:
+    """The summary for one session: s is the Session, a the analysis made from it."""
+    codes: dict[tuple[str, str], str] = {}
+
+    def code(kind: str, target: str) -> str:
+        key = (kind, target.strip())
+        if key not in codes:
+            codes[key] = ("f" if kind == "file" else "c" if kind == "command" else "q") + str(len(codes) + 1)
+        return codes[key]
+
+    t0 = s.started
+    secs = lambda d: round((d - t0).total_seconds(), 1) if d and t0 else None
+    seen_result: dict[str, str] = {}                  # target code -> result fingerprint last seen
+    by_id = {(c["agent"], c["n"]): c for c in a["calls"]}
+
+    def step(x) -> dict:
+        kind = {"read": "file", "edit": "file", "write": "file", "command": "command"}.get(x.kind, "query")
+        st = {"tool": _tool_name(x.tool), "kind": x.kind,
+              "in": round(x.args_chars / 4), "out": round(x.result_chars / 4), "wrote": round(x.written_chars / 4),
+              "error": x.is_error,
+              "secs": round((x.result_ts - x.ts).total_seconds(), 1) if x.ts and x.result_ts else None}
+        if x.target:
+            st["target"] = code(kind, x.target)
+            if x.result_hash:
+                st["same_result_as_last_time"] = seen_result.get(st["target"]) == x.result_hash
+                seen_result[st["target"]] = x.result_hash
+        if x.kind == "command" and x.target:
+            st["program"], sub = _program(x.target)
+            if sub:
+                st["git"] = sub
+            st["flags"] = _flags(x.target)
+        return st
+
+    def call(c) -> dict:
+        d = by_id.get((c.agent, c.n), {})
+        sent = d.get("sent", {})
+        return {"thread": "main" if c.agent == "main" else "helper", "turn": c.turn, "t": secs(c.ts_first),
+                "model": c.model,
+                "sent": {k: sent.get(k, 0) for k in ("setup", "history", "new")},
+                "cache_read": c.usage.cache_read, "cache_write": c.usage.cache_write, "written": c.usage.output,
+                "thinking": c.usage.thinking, "steps": [step(x) for x in c.actions]}
+
+    tools = a["setup"]["tools"]
+    return {
+        "format": FORMAT,
+        "made_by": f"sessioncost {__version__}",
+        "agent": s.agent, "agent_version": s.agent_version, "models": a["meta"]["models"],
+        "session": {"turns": a["totals"]["turns"], "calls": a["totals"]["calls"],
+                    "helper_calls": a["totals"]["helper_calls"], "working_min": a["totals"]["working_min"],
+                    "waiting_min": a["totals"]["waiting_min"], "tokens_exact": a["money"]["tokens_exact"]},
+        "setup": {"tokens": a["setup"]["tokens"],
+                  "parts": [{"what": _setup_kind(p["what"]), "tokens": p["tokens"]} for p in a["setup"]["parts"]],
+                  "tools_defined": len(tools), "tools_used": sum(1 for x in tools if x["used"]),
+                  "unused_tool_tokens": a["setup"]["unused_tokens"],
+                  "mcp_tools_defined": sum(1 for x in tools if x["name"].lower().startswith("mcp"))},
+        "turns": [{"n": t["n"], "kind": t["kind"], "said_tokens": sum(e["tokens"] for e in t["events"]
+                                                                      if e["kind"] in ("typed", "command", "queued", "answer")),
+                   "added_by_agent_tokens": sum(e["tokens"] for e in t["events"]
+                                                if e["kind"] not in ("typed", "command", "queued", "answer")),
+                   "waited_s": round(t["waited_min"] * 60), "calls": len(t["calls"]),
+                   "confirm_only": "confirm-turn" in t["fixes"]} for t in a["turns"]],
+        "calls": [call(c) for c in s.calls] + [call(c) for h in s.helpers for c in h.calls],
+        "helpers": [{"calls": h["calls"], "turn": h["turn"], "tokens": h["tokens"]} for h in a["helpers"]],
+        "basic_fixes": [{"id": f["id"], "tokens": f["saving_tokens"]} for f in a["fixes"]],
+    }

{sessioncost-0.2.2 → sessioncost-0.3.1/sessioncost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sessioncost
-Version: 0.2.2
+Version: 0.3.1
 Summary: See how many tokens each turn of your coding-agent chat sends, why, and what to cut. Cost goes down with it.
 Author: kish21
 License-Expression: MIT
@@ -88,6 +88,20 @@ Report: ~/.sessioncost/reports/<session-id>.html
 Asking costs almost nothing: the agent runs the tool and shows its summary, and never reads the log or the report
 into the chat.
 
+## Updating
+
+| How you installed it | How to update |
+|---|---|
+| The one line above | Paste the same line again, then restart your agent. |
+| Claude Code plugin | **/plugin → Marketplaces → sessioncost → Update** (or type `/plugin marketplace update sessioncost`, then `/plugin update sessioncost@sessioncost`), then restart Claude Code. You can also turn on auto-update for this marketplace there. |
+| pip | `pip install -U sessioncost`, then `sessioncost setup`. |
+
+## Old reports
+
+Each chat keeps one report in `~/.sessioncost/reports/` (a few hundred KB each). When more than 10 older ones pile up,
+the summary says so. Type `/sessioncost clean` in a chat, or `sessioncost clean` in a terminal, to delete all of them
+except the latest. Nothing is ever deleted unless you ask.
+
 ## If something goes wrong
 
 - **`/sessioncost` does nothing:** restart the agent after installing.
@@ -124,6 +138,7 @@ sessioncost 3f2a9c1e           # one chat, by the first characters of its id
 sessioncost path/to/session.jsonl   # or an Antigravity .db
 sessioncost 3f2a9c1e --cursor-usage usage-events.csv   # a Cursor chat, with exact tokens from your export
 sessioncost setup              # add /sessioncost to your agents again
+sessioncost clean              # delete all saved reports except the latest
 ```
 
 Options: `--project <dir>` (another project folder), `--no-open` (write the report, do not open it), `--json`

{sessioncost-0.2.2 → sessioncost-0.3.1}/sessioncost.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ sessioncost/prices.json
 sessioncost/prices.py
 sessioncost/report.py
 sessioncost/report_template.html
+sessioncost/summary.py
 sessioncost.egg-info/PKG-INFO
 sessioncost.egg-info/SOURCES.txt
 sessioncost.egg-info/dependency_links.txt