hades-cli 0.2.0__tar.gz → 0.2.2__tar.gz

hades_cli-0.2.2/CONTEXT.md

@@ -0,0 +1,17 @@
+# hades
+
+A local, zero-config observer over AI coding sessions across tools (Claude Code, Codex, Gemini, Cowork, Cursor, Antigravity, OpenClaw). It reads each tool's transcript files, indexes them into a local SQLite DB, and surfaces state — never launches or orchestrates sessions.
+
+## Language
+
+**Source**:
+A per-tool adapter (`BaseSource` subclass) that discovers a tool's transcript files on disk and parses each one into a `Session`. One source per external tool.
+_Avoid_: Scanner, adapter, plugin (reserved for the future plugin-API vision in the v3 roadmap).
+
+**Session**:
+The indexed record of one AI coding conversation — one transcript file (or, for Claude, one file within a possibly-resumed chain) reduced to its metadata: tool, project, timing, status, token/cost totals. Not the transcript content itself, which stays on disk at `raw_path`.
+_Avoid_: Conversation, chat, transcript (transcript is the raw file; Session is the indexed record of it).
+
+**Token category**:
+One of the four buckets Anthropic's (and Anthropic-shaped) `usage` block reports per turn: input tokens (fresh, uncached), output tokens (generated), cache-write tokens (`cache_creation_input_tokens`), cache-read tokens (`cache_read_input_tokens`). This is the finest-grained "what did the tokens go to" the transcript data actually supports — it is *not* a breakdown by content type (system prompt vs. tool call vs. tool result), which the usage API doesn't report per-block and which hades does not attempt to estimate.
+_Avoid_: Token type, usage breakdown (breakdown is the aggregate view across categories; category is one bucket within it).

{hades_cli-0.2.0 → hades_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hades-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: A local CLI for viewing, searching, and managing AI coding sessions across Claude Code, Codex, Gemini, and Cowork.
 Project-URL: Homepage, https://github.com/mnghn07/hades
 Project-URL: Repository, https://github.com/mnghn07/hades

{hades_cli-0.2.0 → hades_cli-0.2.2}/ROADMAP.md

@@ -33,13 +33,19 @@ Attention list becomes actionable instead of read-only. (Dropped `hades resume`
 
 - **More sources** — OpenCode, Copilot CLI, Aider still open. Each is ~80 lines given the `BaseSource` ABC; this is where the architecture pays off.
   - ~~**Cursor**~~ — done: `hades/sources/cursor.py` reads `~/.cursor/projects/*/agent-transcripts/*/*.jsonl` (the CLI agent's own transcripts, not the IDE's chat storage, which lives in a separate VSCode-style SQLite store and wasn't targeted). No `cwd` or per-turn timestamps in the format — `project_path` is decoded from the dash-encoded project dir name (same ambiguity as Claude's decoder for literal hyphens/dots), `last_active_at` uses file mtime (exact — each turn is appended live), `started_at` uses an embedded `<timestamp>` tag on the first user turn when present (~60% of turns have one) else file birthtime. No token/cost data in the format. "Running" status not yet wired into `process_checker._classify` — the live process name for the Cursor CLI agent is unconfirmed, so cursor sessions stay idle/ended. Verified against 428 real transcripts on a dev machine.
-- ~~**Per-session token count**~~ — done: `models.Session.token_count`, populated for Claude (summed input/output/cache tokens from each turn's `usage` block) and shown in `list`/`stats` (table + `--json`). Codex/gemini/cowork report 0 — no local sample data to confirm their usage field shape yet.
-- ~~**$ cost column**~~ — done: `hades/pricing.py` prices each turn by its own `usage.model` (prefix-matched against a small `$/1M` table for current Claude models; cache write/read derived as 1.25x/0.1x of input price per Anthropic's published multipliers). `models.Session.cost_usd` populated for Claude, summed per session, shown in `list`/`stats` (table + `--json`). Unrecognized models price at $0 rather than guessing. Still open: live-ticking token/cost in `watch`, and token/cost parsing for codex/gemini/cowork once their usage format is confirmed.
+  - ~~**Antigravity**~~ and ~~**OpenClaw**~~ — done (2026-08-10): `hades/sources/antigravity.py` and `hades/sources/openclaw.py`, wired into `sources/__init__.py` and `transcript.py`. Codex source extended with token count and cost extraction in the same pass.
+- ~~**Per-session token count**~~ — done: `models.Session.token_count`, populated for Claude (summed input/output/cache tokens from each turn's `usage` block) and shown in `list`/`stats` (table + `--json`). Codex now extracts usage too (2026-08-10); gemini/cowork still report 0 — no local sample data to confirm their usage field shape yet.
+- ~~**$ cost column**~~ — done: `hades/pricing.py` prices each turn by its own `usage.model` (prefix-matched against a small `$/1M` table for current Claude models; cache write/read derived as 1.25x/0.1x of input price per Anthropic's published multipliers). `models.Session.cost_usd` populated for Claude, summed per session, shown in `list`/`stats` (table + `--json`). Unrecognized models price at $0 rather than guessing. Still open: live-ticking token/cost in `watch`, and token/cost parsing for gemini/cowork once their usage format is confirmed.
+- ~~**Per-tool enable/disable**~~ — done (2026-08-10): `hades setup` and `hades tools` commands (`src/hades/commands/tools.py`) let a user toggle which source scanners run; `config.py` persists the enabled-tools set, `indexer.py` and `transcript.py` respect it. Not originally scoped in this roadmap — added to let users opt out of scanning tools they don't use rather than eating the scan cost for every source unconditionally.
+- ~~**Reindex/backfill mechanism**~~ — done (2026-08-31): per-source `parser_version` int (`sources/base.py`), self-healed on every `refresh_index()` pass regardless of mtime, plus a manual `hades reindex [--tool X] [--session ID]` escape hatch (`indexer.py`, `commands/reindex.py`). Also folds in archived sessions, previously invisible to any reparse path since their file moves out of `discover_root`. `ClaudeSource.PARSER_VERSION` bumped to 2 to backfill the 119 pre-existing sessions stuck at `cost_usd=0`. See [#5](https://github.com/mnghn07/hades/issues/5).
 - **Homebrew tap** — after PyPI validation (per PRD).
 
 ## v3 — The ambitious version
 
-- **`hades serve`** — localhost dashboard (sniffly-style) reading the same SQLite DB. The CLI stays the primary interface; the dashboard is a view, not a second product.
+- **Token/cost breakdown** (in progress) — narrowed from the full dashboard idea below during grilling on [#1](https://github.com/mnghn07/hades/issues/1): category-level (input/output/cache-write/cache-read) breakdown by tool and project, delivered as `hades stats --breakdown` (CLI) and a single-purpose `hades serve` page — not the general dashboard. ADR-0001 (breakdown stored at index time) and ADR-0002 (stdlib `http.server`, no framework) settle the storage/serving approach; `docs/CONTEXT.md` has the glossary.
+  - ~~**`hades serve` dashboard**~~ — done (2026-08-31), closes [#4](https://github.com/mnghn07/hades/issues/4): the four category columns (`input_tokens`/`output_tokens`/`cache_write_tokens`/`cache_read_tokens`) added to `Session`/schema per ADR-0001, populated by Claude/Codex/Cowork/OpenClaw (Gemini/Cursor/Antigravity have no usage data to extract, same as `token_count` today); each source's `PARSER_VERSION` bumped so the reindex self-heal mechanism backfills existing history for free. `hades serve` (`commands/serve.py`) is a stdlib `ThreadingHTTPServer` serving one static page (`static/serve.html`) plus `/api/summary` and `/api/daily`, both scoped by a `?from=&to=` date range. Sniffly-style multi-page structure (overview / `#/tool/{name}` / `#/project/{name}`), a validated categorical palette and real bar-chart mark specs (dataviz skill), grouped-column token chart + stacked-column cost chart, all resolving #1's open "does v1 need a time-range/trend view" question — yes. Design exploration captured as `docs/prototypes/serve-dashboard.PROTOTYPE.html`.
+  - **`hades stats --breakdown` CLI** — still open, [#3](https://github.com/mnghn07/hades/issues/3) (CLI layout design not yet done).
+- **`hades serve` (general dashboard)** — the original sniffly-style ambition below (attention feed, session list, live watch-style updates) stays explicitly out of scope for now; the existing CLI (`list`/`attention`/`watch`) already covers those views adequately. Revisit only if the narrower token/cost page above proves the dashboard surface is worth widening.
 - **Daemon mode** — `watch` decoupled from a terminal pane; notifications fire even with no terminal open.
 - **Plugin API** — a source is a pip entry point; the community adds tools without touching core.
 - **Multi-machine (only if demanded)** — sync the SQLite *index*, never transcripts. The everything-stays-local promise is a selling point; don't spend it cheaply.

hades_cli-0.2.2/docs/adr/0001-token-category-breakdown-precomputed-at-index-time.md

@@ -0,0 +1,7 @@
+# Token category breakdown is precomputed at index time, not re-parsed on demand
+
+Status: accepted
+
+Per-session token category counts (input/output/cache-write/cache-read — see `CONTEXT.md`) will be extracted by each `Source` and stored as columns on the indexed `Session` row, the same way `token_count` and `cost_usd` already are — not recomputed by re-reading raw transcripts each time `stats`/`serve` runs.
+
+We considered computing it on demand instead: no schema migration, always fresh. Rejected because it doesn't scale with transcript count/size, requires `raw_path` to remain valid indefinitely, and breaks the precedent every other derived Session field already follows (parse once at scan time, query the index after). A future need to re-derive from raw data (e.g. per-model breakdown) can still read `raw_path` — this ADR only settles where the *category* breakdown lives.

hades_cli-0.2.2/docs/adr/0002-hades-serve-uses-stdlib-http-server.md

@@ -0,0 +1,7 @@
+# `hades serve` uses stdlib `http.server`, not a web framework
+
+Status: accepted
+
+`hades serve` starts a foreground localhost HTTP server (stdlib `http.server`) that serves one static HTML/JS page plus a couple of JSON endpoints reading the SQLite index. No Flask/FastAPI/etc. dependency is added.
+
+We considered a micro-framework for nicer routing/templating. Rejected: the surface is one page and two read-only endpoints against local data — a framework buys nothing at this size and adds a dependency (plus its own attack surface) to a tool whose value proposition is staying lightweight and local-only (`pyproject.toml` carries no web dependency today; `typer`/`rich`/`sqlite-utils` are all it needs). Revisit only if `serve` grows enough routes/state that hand-rolled dispatch becomes the harder path.

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)
 
 __commit_id__ = commit_id = None

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/cli.py

@@ -140,6 +140,23 @@ def watch_cmd(
     cmd_watch(notify=notify)
 
 
+@app.command("reindex", help="Force reparse of sessions, bypassing the mtime/parser-version self-heal check.")
+def reindex_cmd(
+    tool: Optional[str] = typer.Option(None, "--tool", "-t", help="Only reindex sessions from this tool"),
+    session_id: Optional[str] = typer.Option(None, "--session", help="Only reindex this session ID"),
+):
+    from hades.commands.reindex import cmd_reindex
+    cmd_reindex(tool=tool, session_id=session_id)
+
+
+@app.command("serve", help="Run a localhost dashboard showing the token/cost breakdown by tool and project.")
+def serve_cmd(
+    port: Optional[int] = typer.Option(None, "--port", "-p", help="Port to listen on (default: config serve_port)"),
+):
+    from hades.commands.serve import cmd_serve
+    cmd_serve(port=port)
+
+
 @app.command("setup", help="Show which sources are detected on this machine and enabled for scanning.")
 def setup_cmd():
     from hades.commands.tools import cmd_setup

hades_cli-0.2.2/src/hades/commands/reindex.py

@@ -0,0 +1,10 @@
+from hades.db import get_db
+from hades.indexer import force_reindex
+
+from hades.console import console
+
+
+def cmd_reindex(tool: str | None, session_id: str | None) -> None:
+    db = get_db()
+    count = force_reindex(db, tool=tool, session_id=session_id)
+    console.print(f"[green]Reindexed[/green] {count} session(s)")

hades_cli-0.2.2/src/hades/commands/serve.py

@@ -0,0 +1,117 @@
+import json
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+from hades import pricing
+from hades.config import get_config
+from hades.db import get_db
+
+from hades.console import console
+
+STATIC_DIR = Path(__file__).parent.parent / "static"
+
+
+def _date_range(query: dict) -> tuple[str, str] | None:
+    frm, to = query.get("from", [None])[0], query.get("to", [None])[0]
+    if not frm or not to:
+        return None
+    return frm, to
+
+
+def _summary_rows(db, frm: str, to: str) -> list[dict]:
+    rows = db.execute(
+        """SELECT tool, project_path,
+             COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+             COALESCE(SUM(cache_write_tokens), 0), COALESCE(SUM(cache_read_tokens), 0),
+             COALESCE(SUM(cost_usd), 0.0)
+           FROM sessions
+           WHERE is_archived IS NOT 1 AND date(last_active_at) BETWEEN ? AND ?
+           GROUP BY tool, project_path""",
+        [frm, to],
+    ).fetchall()
+    return [
+        {
+            "tool": tool, "project": project,
+            "input": inp, "output": out, "cache_write": cw, "cache_read": cr,
+            "cost_usd": cost or 0.0,
+        }
+        for tool, project, inp, out, cw, cr, cost in rows
+    ]
+
+
+def _daily_rows(db, frm: str, to: str) -> list[dict]:
+    rows = db.execute(
+        """SELECT date(last_active_at) as day,
+             COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+             COALESCE(SUM(cache_write_tokens), 0), COALESCE(SUM(cache_read_tokens), 0),
+             COALESCE(SUM(cost_usd), 0.0)
+           FROM sessions
+           WHERE is_archived IS NOT 1 AND date(last_active_at) BETWEEN ? AND ?
+           GROUP BY day""",
+        [frm, to],
+    ).fetchall()
+    out = []
+    for day, inp, out_tok, cw, cr, cost in rows:
+        shares = pricing.category_cost_shares(inp, out_tok, cw, cr, cost or 0.0)
+        out.append({
+            "date": day,
+            "input": inp, "output": out_tok, "cache_write": cw, "cache_read": cr,
+            "input_cost": shares["input"], "output_cost": shares["output"],
+            "cache_write_cost": shares["cache_write"], "cache_read_cost": shares["cache_read"],
+        })
+    return out
+
+
+class _Handler(BaseHTTPRequestHandler):
+    def log_message(self, format, *args):  # pylint: disable=redefined-builtin
+        pass  # quiet by default; `hades serve` prints its own startup line
+
+    def _json(self, payload: dict, status: int = 200) -> None:
+        body = json.dumps(payload).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):  # pylint: disable=invalid-name
+        parsed = urlparse(self.path)
+        query = parse_qs(parsed.query)
+
+        if parsed.path == "/":
+            body = (STATIC_DIR / "serve.html").read_bytes()
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+
+        if parsed.path in ("/api/summary", "/api/daily"):
+            date_range = _date_range(query)
+            if date_range is None:
+                self._json({"error": "from and to query params are required (YYYY-MM-DD)"}, status=400)
+                return
+            frm, to = date_range
+            db = get_db()
+            if parsed.path == "/api/summary":
+                self._json({"rows": _summary_rows(db, frm, to)})
+            else:
+                self._json({"days": _daily_rows(db, frm, to)})
+            return
+
+        self.send_response(404)
+        self.end_headers()
+
+
+def cmd_serve(port: int | None, host: str = "127.0.0.1") -> None:
+    resolved_port = port if port is not None else get_config("serve_port")
+    server = ThreadingHTTPServer((host, resolved_port), _Handler)
+    console.print(f"[green]hades serve[/green] running at http://{host}:{resolved_port} — Ctrl+C to stop")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/config.py

@@ -12,6 +12,7 @@ CONFIG_PATH = Path(user_data_dir("hades")) / "config.json"
 
 DEFAULTS = {
     "wait_threshold_minutes": 3,
+    "serve_port": 8080,
 }
 
 # Which sources get scanned/indexed. Only Claude is on out of the box;

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/db.py

@@ -34,6 +34,11 @@ def _ensure_schema(db: sqlite_utils.Database) -> None:
             "waiting_since": str,
             "token_count": int,
             "cost_usd": float,
+            "parser_version": int,
+            "input_tokens": int,
+            "output_tokens": int,
+            "cache_write_tokens": int,
+            "cache_read_tokens": int,
         }, pk="id")
         db["sessions"].create_index(["raw_path"], unique=True)
     else:
@@ -43,7 +48,9 @@ def _ensure_schema(db: sqlite_utils.Database) -> None:
             ("human_messages", str), ("assistant_messages", str),
             ("file_mtime", float), ("is_archived", int),
             ("waiting_since", str), ("token_count", int),
-            ("cost_usd", float),
+            ("cost_usd", float), ("parser_version", int),
+            ("input_tokens", int), ("output_tokens", int),
+            ("cache_write_tokens", int), ("cache_read_tokens", int),
         ]:
             if col not in existing_cols:
                 db["sessions"].add_column(col, col_type)

hades_cli-0.2.2/src/hades/indexer.py

@@ -0,0 +1,173 @@
+from pathlib import Path
+
+import sqlite_utils
+
+from hades.config import get_enabled_tools
+from hades.sources import ALL_SOURCES
+
+
+def refresh_index(db: sqlite_utils.Database) -> None:
+    """Scan enabled sources, upsert changed/new/stale-parsed sessions, remove stale rows."""
+    enabled_tools = get_enabled_tools()
+    indexed_paths: set[str] = set()
+    discovered: dict[str, type] = {}
+
+    for source_cls in ALL_SOURCES:
+        if source_cls.name not in enabled_tools:
+            # Disabled tool: don't scan it, and don't touch its existing index
+            # rows either — same treatment as a source whose store isn't
+            # reachable right now (see _remove_stale below).
+            continue
+        if source_cls.discover_root() is None:
+            # Source store not found (unmounted disk, bad env override, tool not
+            # installed). Skip it entirely — including stale removal — so a
+            # temporarily missing store doesn't wipe its slice of the index.
+            continue
+        discovered[source_cls.name] = source_cls
+
+        for path in source_cls.list_files():
+            path_str = str(path)
+            indexed_paths.add(path_str)
+
+            try:
+                mtime = path.stat().st_mtime
+            except OSError:
+                continue
+
+            existing = db.execute(
+                "SELECT file_mtime, parser_version FROM sessions WHERE raw_path = ?", [path_str]
+            ).fetchone()
+
+            if existing and existing[0] == mtime and (existing[1] or 0) >= source_cls.PARSER_VERSION:
+                continue
+
+            _reparse_and_upsert(db, source_cls, path, mtime)
+
+    _reheal_archived(db, discovered)
+    _remove_stale(db, indexed_paths, set(discovered))
+    db.conn.commit()
+
+
+def force_reindex(db: sqlite_utils.Database, tool: str | None = None, session_id: str | None = None) -> int:
+    """Bypass the mtime/parser_version checks and reparse matching sessions now.
+
+    Escape hatch for `hades reindex` — the mtime/version check in refresh_index
+    self-heals the common case, but a source whose parser changed without a
+    version bump (or a one-off re-scrape request) needs a manual trigger.
+    """
+    source_map = {source_cls.name: source_cls for source_cls in ALL_SOURCES}
+
+    query = "SELECT id, tool, raw_path FROM sessions WHERE 1=1"
+    params: list[str] = []
+    if tool:
+        query += " AND tool = ?"
+        params.append(tool)
+    if session_id:
+        query += " AND id = ?"
+        params.append(session_id)
+
+    reindexed = 0
+    for _id, tool_name, raw_path in db.execute(query, params).fetchall():
+        source_cls = source_map.get(tool_name)
+        if source_cls is None:
+            continue
+        path = Path(raw_path)
+        if not path.exists():
+            continue
+        if _reparse_and_upsert(db, source_cls, path, path.stat().st_mtime) is not None:
+            reindexed += 1
+
+    db.conn.commit()
+    return reindexed
+
+
+def _reparse_and_upsert(db: sqlite_utils.Database, source_cls: type, path: Path, mtime: float) -> str | None:
+    """Parse `path` and upsert/refresh its row (and FTS entry). Returns the session id, or None."""
+    session = source_cls.parse_file(path)
+    if session is None:
+        return None
+
+    path_str = str(path)
+    human_text, assistant_text = source_cls.extract_messages(path)
+
+    row = {
+        "id": session.id,
+        "tool": session.tool,
+        "project_path": session.project_path,
+        "started_at": session.started_at.isoformat(),
+        "last_active_at": session.last_active_at.isoformat(),
+        "message_count": session.message_count,
+        "token_count": session.token_count,
+        "cost_usd": session.cost_usd,
+        "input_tokens": session.input_tokens,
+        "output_tokens": session.output_tokens,
+        "cache_write_tokens": session.cache_write_tokens,
+        "cache_read_tokens": session.cache_read_tokens,
+        "status": session.status,
+        "raw_path": path_str,
+        "title": session.title,
+        "file_mtime": mtime,
+        "human_messages": human_text,
+        "assistant_messages": assistant_text,
+        "parser_version": source_cls.PARSER_VERSION,
+    }
+
+    # A previous version may have stored this file under a different id
+    # (or this id under a different file). Clear both — including the
+    # FTS row, which would otherwise be orphaned — before upserting.
+    for (old_id,) in db.execute(
+        "SELECT id FROM sessions WHERE raw_path = ? AND id != ?",
+        [path_str, session.id],
+    ).fetchall():
+        db.execute("DELETE FROM sessions WHERE id = ?", [old_id])
+        db.execute("DELETE FROM sessions_fts WHERE id = ?", [old_id])
+    db["sessions"].upsert(row, pk="id")
+
+    db.execute("DELETE FROM sessions_fts WHERE id = ?", [session.id])
+    db.execute(
+        "INSERT INTO sessions_fts (id, human_messages, assistant_messages) VALUES (?, ?, ?)",
+        [session.id, human_text, assistant_text],
+    )
+    return session.id
+
+
+def _reheal_archived(db: sqlite_utils.Database, discovered: dict[str, type]) -> None:
+    """Reparse archived sessions whose parser_version is behind — they're never
+    visited by the live-file scan above since their file moved out of the
+    source's discover_root into the archive.
+    """
+    if "sessions" not in db.table_names():
+        return
+
+    for tool_name, source_cls in discovered.items():
+        rows = db.execute(
+            "SELECT raw_path, parser_version FROM sessions WHERE is_archived = 1 AND tool = ?", [tool_name]
+        ).fetchall()
+        for raw_path, parser_version in rows:
+            if (parser_version or 0) >= source_cls.PARSER_VERSION:
+                continue
+            path = Path(raw_path)
+            if not path.exists():
+                continue
+            _reparse_and_upsert(db, source_cls, path, path.stat().st_mtime)
+
+
+def _remove_stale(db: sqlite_utils.Database, indexed_paths: set[str], discovered_tools: set[str]) -> None:
+    """Delete index rows for session files that no longer exist on disk.
+
+    Only rows belonging to sources that were actually discovered this run are
+    considered — an unreachable store must not erase its history.
+    """
+    if "sessions" not in db.table_names() or not discovered_tools:
+        return
+
+    placeholders = ",".join("?" * len(discovered_tools))
+    db_rows = db.execute(
+        f"SELECT id, raw_path FROM sessions WHERE is_archived IS NOT 1 AND tool IN ({placeholders})",
+        list(discovered_tools),
+    ).fetchall()
+    stale_rows = [(session_id, path_str) for session_id, path_str in db_rows if path_str not in indexed_paths]
+
+    for session_id, path_str in stale_rows:
+        db.execute("DELETE FROM sessions WHERE raw_path = ?", [path_str])
+        db.execute("DELETE FROM sessions_fts WHERE id = ?", [session_id])

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/models.py

@@ -16,3 +16,7 @@ class Session:
     title: str | None
     token_count: int = 0
     cost_usd: float = 0.0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_write_tokens: int = 0
+    cache_read_tokens: int = 0

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/pricing.py

@@ -25,6 +25,33 @@ _PRICES: dict[str, tuple[float, float]] = {
 
 CACHE_WRITE_MULTIPLIER = 1.25
 CACHE_READ_MULTIPLIER = 0.1
+OUTPUT_MULTIPLIER = 5.0  # every priced model above uses a flat 5x input:output ratio
+
+
+def category_cost_shares(
+    input_tokens: int, output_tokens: int, cache_write_tokens: int, cache_read_tokens: int, total_cost_usd: float
+) -> dict[str, float]:
+    """Split an already-known total cost across the four token categories.
+
+    Sessions store one total cost_usd (priced per-turn by that turn's own
+    model), not a per-category dollar amount — so this apportions the total
+    by each category's token count weighted by its price multiplier relative
+    to input, rather than re-pricing per model (which would need per-day
+    model attribution we don't store).
+    # ponytail: approximation, not exact per-model pricing. Upgrade path: store
+    # per-category cost at index time (like cost_usd) if per-model precision
+    # ever matters here.
+    """
+    weighted = {
+        "input": input_tokens,
+        "output": output_tokens * OUTPUT_MULTIPLIER,
+        "cache_write": cache_write_tokens * CACHE_WRITE_MULTIPLIER,
+        "cache_read": cache_read_tokens * CACHE_READ_MULTIPLIER,
+    }
+    total_weight = sum(weighted.values())
+    if total_weight <= 0:
+        return dict.fromkeys(weighted, 0.0)
+    return {k: total_cost_usd * w / total_weight for k, w in weighted.items()}
 
 
 def price_per_mtok(model: str) -> tuple[float, float] | None:

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/sources/base.py

@@ -8,6 +8,9 @@ class BaseSource(ABC):
     name: str
     default_paths: list[Path]
     env_var: str
+    # Bump when parse_file/extract_messages logic changes so refresh_index
+    # reparses already-indexed files even though their mtime is unchanged.
+    PARSER_VERSION: int = 1
 
     @classmethod
     def discover_root(cls) -> Path | None:

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/sources/claude.py

@@ -3,13 +3,16 @@ from pathlib import Path
 
 from hades.models import Session
 from .base import BaseSource
-from .common import extract_cost, extract_token_count, parse_timestamps, read_jsonl_dicts
+from .common import extract_cost, extract_token_breakdown, extract_token_count, parse_timestamps, read_jsonl_dicts
 
 
 class ClaudeSource(BaseSource):
     name = "claude"
     env_var = "HADES_CLAUDE_PATH"
     default_paths = [Path("~/.claude/projects")]
+    # v2: backfills cost_usd for sessions indexed before that field existed.
+    # v3: backfills the four token-category columns (input/output/cache-write/cache-read).
+    PARSER_VERSION = 3
 
     @classmethod
     def list_files(cls) -> list[Path]:
@@ -33,6 +36,7 @@ class ClaudeSource(BaseSource):
         started_at = min(timestamps) if timestamps else datetime.now(timezone.utc)
         last_active_at = max(timestamps) if timestamps else started_at
         title = _extract_title(user_msgs)
+        breakdown = extract_token_breakdown(assistant_msgs)
 
         return Session(
             # Keyed by file stem, not the inner sessionId: resumed sessions
@@ -49,6 +53,10 @@ class ClaudeSource(BaseSource):
             title=title,
             token_count=extract_token_count(assistant_msgs),
             cost_usd=extract_cost(assistant_msgs),
+            input_tokens=breakdown["input"],
+            output_tokens=breakdown["output"],
+            cache_write_tokens=breakdown["cache_write"],
+            cache_read_tokens=breakdown["cache_read"],
         )
 
     @classmethod

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/sources/codex.py

@@ -11,6 +11,8 @@ class CodexSource(BaseSource):
     name = "codex"
     env_var = "HADES_CODEX_PATH"
     default_paths = [Path("~/.codex/sessions")]
+    # v2: backfills the four token-category columns (input/output/cache-write/cache-read).
+    PARSER_VERSION = 2
 
     @classmethod
     def list_files(cls) -> list[Path]:
@@ -28,6 +30,7 @@ class CodexSource(BaseSource):
         last_active_at = max(timestamps) if timestamps else started_at
 
         turns = [r for r in records if _turn_role(r) in ("user", "assistant")]
+        breakdown = _extract_token_breakdown(records)
 
         return Session(
             id=f"codex:{path.stem}",
@@ -41,6 +44,10 @@ class CodexSource(BaseSource):
             title=_extract_title(turns),
             token_count=_extract_token_count(records),
             cost_usd=_extract_cost(records),
+            input_tokens=breakdown["input"],
+            output_tokens=breakdown["output"],
+            cache_write_tokens=breakdown["cache_write"],
+            cache_read_tokens=breakdown["cache_read"],
         )
 
     @classmethod
@@ -123,6 +130,20 @@ def _extract_token_count(records: list[dict]) -> int:
     return usage.get("total_tokens", 0) or 0 if usage else 0
 
 
+def _extract_token_breakdown(records: list[dict]) -> dict[str, int]:
+    """The cumulative usage dict already carries all four categories — no
+    summing needed, same as _extract_cost."""
+    usage = _last_token_usage(records)
+    if not usage:
+        return {"input": 0, "output": 0, "cache_write": 0, "cache_read": 0}
+    return {
+        "input": usage.get("input_tokens", 0) or 0,
+        "output": usage.get("output_tokens", 0) or 0,
+        "cache_write": usage.get("cache_write_input_tokens", 0) or 0,
+        "cache_read": usage.get("cached_input_tokens", 0) or 0,
+    }
+
+
 def _extract_model(records: list[dict]) -> str | None:
     for r in records:
         if r.get("type") != "world_state":

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/sources/common.py

@@ -64,6 +64,22 @@ def extract_token_count(assistant_msgs: list[dict]) -> int:
     return total
 
 
+def extract_token_breakdown(assistant_msgs: list[dict]) -> dict[str, int]:
+    """Sum each of the four token categories across every assistant turn's
+    usage block. Shared by any source whose transcript format nests a
+    Claude-shaped message.usage block (Claude Code and Cowork both do)."""
+    totals = {"input": 0, "output": 0, "cache_write": 0, "cache_read": 0}
+    for m in assistant_msgs:
+        usage = m.get("message", {}).get("usage")
+        if not isinstance(usage, dict):
+            continue
+        totals["input"] += usage.get("input_tokens", 0) or 0
+        totals["output"] += usage.get("output_tokens", 0) or 0
+        totals["cache_write"] += usage.get("cache_creation_input_tokens", 0) or 0
+        totals["cache_read"] += usage.get("cache_read_input_tokens", 0) or 0
+    return totals
+
+
 def extract_cost(assistant_msgs: list[dict]) -> float:
     """Sum per-turn USD cost, priced by that turn's own model."""
     total = 0.0

{hades_cli-0.2.0 → hades_cli-0.2.2}/src/hades/sources/cowork.py

@@ -3,7 +3,9 @@ from pathlib import Path
 
 from hades.models import Session
 from .base import BaseSource
-from .common import extract_cost, extract_token_count, parse_timestamps, read_json_document, read_jsonl_dicts
+from .common import (
+    extract_cost, extract_token_breakdown, extract_token_count, parse_timestamps, read_json_document, read_jsonl_dicts,
+)
 
 
 class CoworkSource(BaseSource):
@@ -13,6 +15,8 @@ class CoworkSource(BaseSource):
         Path("~/Library/Application Support/Claude/local-agent-mode-sessions"),
         Path("~/.config/claude/local-agent-mode-sessions"),
     ]
+    # v2: backfills the four token-category columns (input/output/cache-write/cache-read).
+    PARSER_VERSION = 2
 
     @classmethod
     def list_files(cls) -> list[Path]:
@@ -40,6 +44,7 @@ class CoworkSource(BaseSource):
         # not a real host project path. The session's own title is the closest
         # thing to a project label, so it's used for both fields below.
         title = _read_metadata(path).get("title") or _extract_title(user_msgs)
+        breakdown = extract_token_breakdown(assistant_msgs)
 
         return Session(
             id=f"cowork:{path.parent.name}",
@@ -53,6 +58,10 @@ class CoworkSource(BaseSource):
             title=title,
             token_count=extract_token_count(assistant_msgs),
             cost_usd=extract_cost(assistant_msgs),
+            input_tokens=breakdown["input"],
+            output_tokens=breakdown["output"],
+            cache_write_tokens=breakdown["cache_write"],
+            cache_read_tokens=breakdown["cache_read"],
         )
 
     @classmethod