scrollback 0.1.1__tar.gz → 0.2.0__tar.gz

{scrollback-0.1.1 → scrollback-0.2.0}/CHANGELOG.md

@@ -6,6 +6,36 @@ follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-06-30
+
+### Added
+
+- **Cache & reasoning token accounting.** Sessions now carry
+  `tokens_cache_read`, `tokens_cache_write`, and `tokens_reasoning` in
+  addition to input/output/cost. In agentic sessions cache reads often
+  dominate total token volume, so this makes scrollback's usage numbers
+  reconcilable with the agents' own reports:
+  - **opencode** reads the corresponding SQLite columns (tolerant of older
+    databases that lack them).
+  - **Claude Code** now reports usage at all — summed per-turn from each
+    assistant message's `usage` block (previously blank).
+  - **Codex** parses token-count records where the rollout format includes
+    them (best-effort; `None` when absent).
+  - **Aider** has no token data on disk and stays `None`.
+- `stats` shows a `cache` (read/write) line and a `reasoning` line; the web
+  transcript header shows a cache figure; Markdown/HTML/JSON exports include
+  a usage summary.
+
+## [0.1.2] - 2026-06-30
+
+### Added
+
+- `scrollback uninstall`: removes the artifacts scrollback created (Desktop
+  launcher, macOS `.app`, optional search index, launcher log) with a
+  confirmation prompt (`--yes` / `--dry-run`). It never touches agent data
+  and never self-removes the package; it prints the right `pip`/`pipx
+  uninstall` command instead.
+
 ## [0.1.1] - 2026-06-30
 
 ### Fixed
@@ -90,6 +120,8 @@ export it from a CLI and a local web app.
 - Negative pagination arguments are rejected; clearer errors for unknown
   sources, failed exports, and unavailable data sources.
 
-[Unreleased]: https://github.com/a-attia/scrollback/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/a-attia/scrollback/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/a-attia/scrollback/compare/v0.1.2...v0.2.0
+[0.1.2]: https://github.com/a-attia/scrollback/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/a-attia/scrollback/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/a-attia/scrollback/releases/tag/v0.1.0

{scrollback-0.1.1 → scrollback-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrollback
-Version: 0.1.1
+Version: 0.2.0
 Summary: Navigate, search, copy, and export your AI coding-agent sessions (opencode, Claude Code, ...) from one local, read-only tool.
 Project-URL: Homepage, https://github.com/a-attia/scrollback
 Project-URL: Repository, https://github.com/a-attia/scrollback
@@ -73,13 +73,13 @@ modifies, locks for writing, or uploads your data.
 You can use it two ways. From the **command line**, list, search, and export
 your sessions in a single scriptable tool:
 
-![scrollback listing recent sessions in the terminal.](https://raw.githubusercontent.com/a-attia/scrollback/v0.1.1/assets/screenshots/cli.png)
+![scrollback listing recent sessions in the terminal.](https://raw.githubusercontent.com/a-attia/scrollback/v0.2.0/assets/screenshots/cli.png)
 
 Or open the **local web app** to read a transcript in full — with rendered
 Markdown, syntax-highlighted code, and typeset LaTeX math:
 
 ![The scrollback web app showing a session list beside a transcript with
-rendered Markdown, highlighted code, and typeset equations.](https://raw.githubusercontent.com/a-attia/scrollback/v0.1.1/assets/screenshots/web.png)
+rendered Markdown, highlighted code, and typeset equations.](https://raw.githubusercontent.com/a-attia/scrollback/v0.2.0/assets/screenshots/web.png)
 
 Both views read the same on-disk session stores, so you can jump between
 them freely. (The screenshots above use synthetic demo data.)
@@ -235,6 +235,16 @@ busiest projects. `resume` prints the command to continue a session in its
 own agent (for example `opencode --session <id>` or `claude --resume <id>`),
 with a `cd` into the session's project directory.
 
+**A note on token figures.** Where the source records it, scrollback reports
+tokens in four buckets — *input*, *output*, *cache read*, and *cache write* —
+because they mean different things and are priced very differently. In
+agentic sessions the conversation context is re-sent every turn but served
+from the prompt cache, so **cache reads usually dominate total volume** while
+costing a fraction of fresh input. "Total tokens" is therefore not one
+number; the cost figure (when available) is the most faithful summary of
+consumption. Sources that don't record a given figure show it as blank
+rather than a misleading zero.
+
 ## The web app
 
 `scrollback web` starts a local, read-only browser UI — FastAPI plus a
@@ -299,6 +309,13 @@ window closes. All of this behaviour is decided in Python, so the launcher
 scripts stay free of OS-specific assumptions and ship inside the package
 for `pip install` users.
 
+To clean up, `scrollback uninstall` removes the artifacts scrollback
+created — the launchers, the macOS `.app`, the optional search index, and the
+launcher log — after a confirmation (`--yes` to skip it, `--dry-run` to
+preview). It never touches your agent data, and it does not remove the Python
+package itself: it prints the right `pip`/`pipx uninstall` command to finish
+the job (a program can't reliably uninstall the package it is running from).
+
 ## Fast search (optional index)
 
 By default, search is a lexical scan over your live data: zero setup,

{scrollback-0.1.1 → scrollback-0.2.0}/README.md

@@ -14,13 +14,13 @@ modifies, locks for writing, or uploads your data.
 You can use it two ways. From the **command line**, list, search, and export
 your sessions in a single scriptable tool:
 
-![scrollback listing recent sessions in the terminal.](https://raw.githubusercontent.com/a-attia/scrollback/v0.1.1/assets/screenshots/cli.png)
+![scrollback listing recent sessions in the terminal.](https://raw.githubusercontent.com/a-attia/scrollback/v0.2.0/assets/screenshots/cli.png)
 
 Or open the **local web app** to read a transcript in full — with rendered
 Markdown, syntax-highlighted code, and typeset LaTeX math:
 
 ![The scrollback web app showing a session list beside a transcript with
-rendered Markdown, highlighted code, and typeset equations.](https://raw.githubusercontent.com/a-attia/scrollback/v0.1.1/assets/screenshots/web.png)
+rendered Markdown, highlighted code, and typeset equations.](https://raw.githubusercontent.com/a-attia/scrollback/v0.2.0/assets/screenshots/web.png)
 
 Both views read the same on-disk session stores, so you can jump between
 them freely. (The screenshots above use synthetic demo data.)
@@ -176,6 +176,16 @@ busiest projects. `resume` prints the command to continue a session in its
 own agent (for example `opencode --session <id>` or `claude --resume <id>`),
 with a `cd` into the session's project directory.
 
+**A note on token figures.** Where the source records it, scrollback reports
+tokens in four buckets — *input*, *output*, *cache read*, and *cache write* —
+because they mean different things and are priced very differently. In
+agentic sessions the conversation context is re-sent every turn but served
+from the prompt cache, so **cache reads usually dominate total volume** while
+costing a fraction of fresh input. "Total tokens" is therefore not one
+number; the cost figure (when available) is the most faithful summary of
+consumption. Sources that don't record a given figure show it as blank
+rather than a misleading zero.
+
 ## The web app
 
 `scrollback web` starts a local, read-only browser UI — FastAPI plus a
@@ -240,6 +250,13 @@ window closes. All of this behaviour is decided in Python, so the launcher
 scripts stay free of OS-specific assumptions and ship inside the package
 for `pip install` users.
 
+To clean up, `scrollback uninstall` removes the artifacts scrollback
+created — the launchers, the macOS `.app`, the optional search index, and the
+launcher log — after a confirmation (`--yes` to skip it, `--dry-run` to
+preview). It never touches your agent data, and it does not remove the Python
+package itself: it prints the right `pip`/`pipx uninstall` command to finish
+the job (a program can't reliably uninstall the package it is running from).
+
 ## Fast search (optional index)
 
 By default, search is a lexical scan over your live data: zero setup,

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/__init__.py

@@ -5,4 +5,4 @@ coding agents (opencode, Claude Code, ...) through a common adapter
 interface and lets you list, view, search, and export those sessions.
 """
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/cli.py

@@ -211,6 +211,9 @@ def cmd_stats(args: argparse.Namespace) -> int:
             "total_messages": st.total_messages,
             "total_tokens_input": st.total_tokens_input,
             "total_tokens_output": st.total_tokens_output,
+            "total_tokens_cache_read": st.total_tokens_cache_read,
+            "total_tokens_cache_write": st.total_tokens_cache_write,
+            "total_tokens_reasoning": st.total_tokens_reasoning,
             "total_cost": st.total_cost,
             "oldest": st.oldest.isoformat() if st.oldest else None,
             "newest": st.newest.isoformat() if st.newest else None,
@@ -228,6 +231,11 @@ def cmd_stats(args: argparse.Namespace) -> int:
     if st.total_tokens_input or st.total_tokens_output:
         print(f"tokens:   {_fmt_tokens(st.total_tokens_input)} in / "
               f"{_fmt_tokens(st.total_tokens_output)} out")
+    if st.total_tokens_cache_read or st.total_tokens_cache_write:
+        print(f"cache:    {_fmt_tokens(st.total_tokens_cache_read)} read / "
+              f"{_fmt_tokens(st.total_tokens_cache_write)} write")
+    if st.total_tokens_reasoning:
+        print(f"reasoning:{_fmt_tokens(st.total_tokens_reasoning)} tokens")
     if st.total_cost:
         print(f"cost:     ${st.total_cost:.2f}")
     print()
@@ -339,6 +347,9 @@ def cmd_list(args: argparse.Namespace) -> int:
                 "cost": s.cost,
                 "tokens_input": s.tokens_input,
                 "tokens_output": s.tokens_output,
+                "tokens_cache_read": s.tokens_cache_read,
+                "tokens_cache_write": s.tokens_cache_write,
+                "tokens_reasoning": s.tokens_reasoning,
                 "parent_id": s.parent_id,
                 "children": [row(c) for c in s.children],
             }
@@ -844,6 +855,72 @@ def cmd_install_launcher(args: argparse.Namespace) -> int:
     return 0
 
 
+def _detect_install_tool() -> str:
+    """Best-effort guess of how scrollback was installed, for the hint.
+
+    Returns the command the user should run to remove the package itself.
+    We never run it: a process cannot reliably uninstall the package it is
+    executing from, and the right tool (pip / pipx / conda) depends on how
+    it was installed.
+    """
+    exe = (sys.executable or "").replace("\\", "/")
+    if "/pipx/" in exe or "/.local/pipx/" in exe:
+        return "pipx uninstall scrollback"
+    return "pip uninstall scrollback"
+
+
+def cmd_uninstall(args: argparse.Namespace) -> int:
+    """Remove scrollback-created artifacts; explain how to remove the package.
+
+    Removes only files scrollback itself created (launchers, the macOS .app,
+    the optional search index, the launcher log). It never touches your agent
+    data, and it never tries to uninstall the Python package -- that is left
+    to pip/pipx, with the exact command printed at the end.
+    """
+    from . import fts, launcher_install
+
+    targets: list = list(launcher_install.installed_artifacts())
+    index_path = fts.default_index_path()
+    if index_path.exists():
+        targets.append(index_path)
+
+    if not targets:
+        _eprint("no scrollback-created artifacts found.")
+        _eprint(f"to remove the package itself, run:\n    {_detect_install_tool()}")
+        return 0
+
+    label = "would remove" if args.dry_run else "about to remove"
+    _eprint(f"{label}:")
+    for p in targets:
+        _eprint(f"  {p}")
+
+    if args.dry_run:
+        return 0
+
+    if not args.yes:
+        try:
+            reply = input("remove these? [y/N] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            reply = ""
+        if reply not in ("y", "yes"):
+            _eprint("aborted; nothing removed.")
+            return 1
+
+    removed, failed = 0, 0
+    for p in targets:
+        try:
+            launcher_install.remove_path(p)
+            _eprint(f"removed {p}")
+            removed += 1
+        except OSError as exc:
+            _eprint(f"could not remove {p}: {exc}")
+            failed += 1
+
+    _eprint(f"\nremoved {removed} item(s)" + (f", {failed} failed" if failed else ""))
+    _eprint(f"to remove the package itself, run:\n    {_detect_install_tool()}")
+    return 1 if failed else 0
+
+
 class _AppBridge:
     """JS<->Python API exposed to the pywebview window.
 
@@ -1093,6 +1170,20 @@ def build_parser() -> argparse.ArgumentParser:
                          "falls back to the Desktop launcher elsewhere)")
     sp.set_defaults(func=cmd_install_launcher)
 
+    # uninstall
+    sp = sub.add_parser(
+        "uninstall",
+        help="remove scrollback-created artifacts (launchers, app, index)",
+        description="Remove files scrollback created (Desktop launcher, macOS "
+                    ".app, search index, launcher log). Your agent data is never "
+                    "touched. The Python package itself is removed with pip/pipx "
+                    "-- the exact command is printed at the end.",
+    )
+    sp.add_argument("-y", "--yes", action="store_true", help="skip the confirmation prompt")
+    sp.add_argument("--dry-run", action="store_true",
+                    help="show what would be removed, then exit")
+    sp.set_defaults(func=cmd_uninstall)
+
     return p
 
 

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/export.py

@@ -26,6 +26,35 @@ def _fmt_dt(dt: datetime | None) -> str:
     return dt.strftime("%Y-%m-%d %H:%M:%S %Z").strip() if dt else "?"
 
 
+def _fmt_tokens(n: int | None) -> str:
+    if not n:
+        return "0"
+    if n < 1000:
+        return str(n)
+    if n < 1_000_000:
+        return f"{n / 1e3:.1f}k"
+    return f"{n / 1e6:.1f}M"
+
+
+def _usage_summary(session: Session) -> str:
+    """A compact one-line usage string, or '' when the source reports none."""
+    s = session
+    if not any((s.tokens_input, s.tokens_output, s.tokens_cache_read,
+                s.tokens_cache_write, s.tokens_reasoning, s.cost)):
+        return ""
+    bits = []
+    if s.tokens_input or s.tokens_output:
+        bits.append(f"{_fmt_tokens(s.tokens_input)} in / {_fmt_tokens(s.tokens_output)} out")
+    if s.tokens_cache_read or s.tokens_cache_write:
+        bits.append(f"cache {_fmt_tokens(s.tokens_cache_read)} read / "
+                    f"{_fmt_tokens(s.tokens_cache_write)} write")
+    if s.tokens_reasoning:
+        bits.append(f"{_fmt_tokens(s.tokens_reasoning)} reasoning")
+    if s.cost:
+        bits.append(f"${s.cost:.2f}")
+    return "; ".join(bits)
+
+
 # -- markdown --------------------------------------------------------------
 
 
@@ -50,6 +79,9 @@ def to_markdown(session: Session, *, include_reasoning: bool = True,
     lines.append(f"- **Created**: {_fmt_dt(session.created)}")
     lines.append(f"- **Updated**: {_fmt_dt(session.updated)}")
     lines.append(f"- **Messages**: {len(session.messages)}")
+    usage = _usage_summary(session)
+    if usage:
+        lines.append(f"- **Usage**: {usage}")
     lines.append("")
     lines.append("---")
     lines.append("")
@@ -211,6 +243,9 @@ def to_html(session: Session, *, include_reasoning: bool = True,
         meta_bits.append(f"model: {session.model}")
     meta_bits.append(f"created: {_fmt_dt(session.created)}")
     meta_bits.append(f"messages: {len(session.messages)}")
+    usage = _usage_summary(session)
+    if usage:
+        meta_bits.append(f"usage: {usage}")
     meta = " &middot; ".join(_html.escape(b) for b in meta_bits)
 
     body_parts: list[str] = []

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/launcher_install.py

@@ -207,3 +207,43 @@ def _install_linux(dest: Path | None) -> list[Path]:
     _write(sh, _read_bundled("scrollback.sh"), executable=True)
     created.append(sh)
     return created
+
+
+# -- uninstall: locate + remove the artifacts install creates --------------
+
+def installed_artifacts() -> list[Path]:
+    """Return the launcher/app/log paths scrollback may have created.
+
+    Covers the default install locations on every platform (a custom
+    ``--dest`` is not tracked, so those must be removed by hand). Only paths
+    that currently exist are returned. Never includes the user's agent data.
+    """
+    home = Path.home()
+    candidates: list[Path] = []
+
+    if sys.platform == "darwin":
+        candidates += [
+            _desktop_dir() / "scrollback.command",
+            home / "Applications" / "scrollback.app",
+            home / "Library" / "Logs" / "scrollback-launcher.log",
+        ]
+    elif sys.platform == "win32":
+        candidates += [_desktop_dir() / "scrollback.bat"]
+    else:
+        apps = Path(os.environ.get("XDG_DATA_HOME", home / ".local" / "share")) / "applications"
+        candidates += [
+            apps / "scrollback.desktop",
+            _desktop_dir() / "scrollback.sh",
+        ]
+
+    return [p for p in candidates if p.exists()]
+
+
+def remove_path(path: Path) -> None:
+    """Delete a file or directory (used to remove a .app bundle)."""
+    import shutil
+
+    if path.is_dir() and not path.is_symlink():
+        shutil.rmtree(path)
+    else:
+        path.unlink()

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/models.py

@@ -111,10 +111,17 @@ class Session:
     agent: str | None = None
     parent_id: str | None = None
     message_count: int | None = None
-    # Usage accounting (opencode tracks these; None when unknown).
+    # Usage accounting (None when the source does not report a given figure).
+    # `tokens_input` / `tokens_output` are fresh (uncached) prompt + generated
+    # tokens; the cache figures track prompt-cache reuse (large in agentic
+    # sessions and priced very differently); `tokens_reasoning` is the portion
+    # of output spent on hidden reasoning, where the source distinguishes it.
     cost: float | None = None
     tokens_input: int | None = None
     tokens_output: int | None = None
+    tokens_cache_read: int | None = None
+    tokens_cache_write: int | None = None
+    tokens_reasoning: int | None = None
     # Children populated when subagent folding is enabled.
     children: tuple["Session", ...] = ()
     messages: tuple[Message, ...] = ()

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/serialize.py

@@ -36,6 +36,9 @@ def session_summary(s: Session) -> dict[str, Any]:
         "cost": s.cost,
         "tokens_input": s.tokens_input,
         "tokens_output": s.tokens_output,
+        "tokens_cache_read": s.tokens_cache_read,
+        "tokens_cache_write": s.tokens_cache_write,
+        "tokens_reasoning": s.tokens_reasoning,
         "git_branch": (s.raw or {}).get("git_branch"),
         "children": [session_summary(c) for c in s.children],
     }

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/sources/claudecode.py

@@ -228,6 +228,7 @@ class ClaudeCodeSource(Source):
                 message_count=meta["msg_count"],
                 children=children,
                 raw={"path": str(f), "git_branch": meta["git_branch"]},
+                **_usage_from_meta(meta),
             )
 
     def _subagent_summary(self, parent_path: Path, sub_path: Path) -> Session:
@@ -252,6 +253,7 @@ class ClaudeCodeSource(Source):
             parent_id=parent_id,
             message_count=(sm or {}).get("msg_count", 0),
             raw={"path": str(sub_path)},
+            **_usage_from_meta(sm or {}),
         )
 
     # -- single session -----------------------------------------------------
@@ -338,6 +340,7 @@ class ClaudeCodeSource(Source):
             message_count=meta["msg_count"],
             messages=(),
             raw={"path": str(path), "git_branch": meta["git_branch"]},
+            **_usage_from_meta(meta),
         )
 
     def load_messages(
@@ -411,6 +414,10 @@ def _scan_metadata(path: Path) -> dict[str, Any] | None:
     first_user_text: str | None = None
     msg_count = 0
     seen = False
+    # Usage accumulators. Claude Code records per-turn `usage` on assistant
+    # messages; summing across turns matches the agent's own session totals.
+    tok_in = tok_out = tok_cache_read = tok_cache_write = 0
+    any_usage = False
 
     for obj in _iter_lines(path):
         seen = True
@@ -439,6 +446,14 @@ def _scan_metadata(path: Path) -> dict[str, Any] | None:
                 mv = m.get("model")
                 if mv and mv != "<synthetic>":
                     model = mv
+            if isinstance(m, dict):
+                u = m.get("usage")
+                if isinstance(u, dict):
+                    any_usage = True
+                    tok_in += _int(u.get("input_tokens"))
+                    tok_out += _int(u.get("output_tokens"))
+                    tok_cache_read += _int(u.get("cache_read_input_tokens"))
+                    tok_cache_write += _int(u.get("cache_creation_input_tokens"))
             if (
                 first_user_text is None
                 and t == "user"
@@ -458,6 +473,27 @@ def _scan_metadata(path: Path) -> dict[str, Any] | None:
         "first_ts": first_ts,
         "last_ts": last_ts,
         "msg_count": msg_count,
+        # Only report usage when the transcript actually carried any, so
+        # sessions with no usage records stay None (not a misleading 0).
+        "tokens_input": tok_in if any_usage else None,
+        "tokens_output": tok_out if any_usage else None,
+        "tokens_cache_read": tok_cache_read if any_usage else None,
+        "tokens_cache_write": tok_cache_write if any_usage else None,
+    }
+
+
+def _int(v: Any) -> int:
+    """Coerce a usage value to int, treating missing/garbage as 0."""
+    return v if isinstance(v, int) else 0
+
+
+def _usage_from_meta(meta: dict[str, Any]) -> dict[str, Any]:
+    """Pull the usage fields out of a scan-metadata dict (all may be None)."""
+    return {
+        "tokens_input": meta.get("tokens_input"),
+        "tokens_output": meta.get("tokens_output"),
+        "tokens_cache_read": meta.get("tokens_cache_read"),
+        "tokens_cache_write": meta.get("tokens_cache_write"),
     }
 
 
@@ -560,6 +596,7 @@ def _parse_session(
         message_count=len(messages),
         messages=tuple(messages),
         raw={"path": str(path), "git_branch": meta["git_branch"]},
+        **_usage_from_meta(meta),
     )
 
 

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/sources/codex.py

@@ -118,6 +118,7 @@ class CodexSource(Source):
                 model=meta["model"],
                 message_count=meta["msg_count"],
                 raw={"path": str(f)},
+                **_usage_from_meta(meta),
             )
 
     # -- single session -----------------------------------------------------
@@ -141,12 +142,23 @@ class CodexSource(Source):
             message_count=len(messages),
             messages=tuple(messages),
             raw={"path": str(path)},
+            **_usage_from_meta(meta),
         )
 
 
 # -- parsing helpers -------------------------------------------------------
 
 
+def _usage_from_meta(meta: dict[str, Any]) -> dict[str, Any]:
+    """Pull usage fields out of a scan-metadata dict (all may be None)."""
+    return {
+        "tokens_input": meta.get("tokens_input"),
+        "tokens_output": meta.get("tokens_output"),
+        "tokens_cache_read": meta.get("tokens_cache_read"),
+        "tokens_cache_write": meta.get("tokens_cache_write"),
+    }
+
+
 def _iter_lines(path: Path) -> Iterator[dict[str, Any]]:
     try:
         with path.open("r", encoding="utf-8", errors="replace") as fh:
@@ -198,6 +210,7 @@ def _scan_meta(path: Path) -> dict[str, Any] | None:
     last_ts: str | int | None = None
     msg_count = 0
     seen = False
+    usage: dict[str, int] | None = None
 
     for obj in _iter_lines(path):
         seen = True
@@ -219,6 +232,12 @@ def _scan_meta(path: Path) -> dict[str, Any] | None:
                 txt = _record_text(p).strip()
                 if txt and not txt.startswith("<"):
                     title = " ".join(txt.split())[:60]
+        # Best-effort usage: Codex emits token counts on some record types
+        # (e.g. a `token_count` event). Take the LAST cumulative reading we
+        # see. Absent in older/other formats -> usage stays None.
+        latest = _token_usage(obj, p)
+        if latest is not None:
+            usage = latest
 
     if not seen:
         return None
@@ -231,6 +250,52 @@ def _scan_meta(path: Path) -> dict[str, Any] | None:
         "first_ts": first_ts,
         "last_ts": last_ts,
         "msg_count": msg_count,
+        "tokens_input": (usage or {}).get("input"),
+        "tokens_output": (usage or {}).get("output"),
+        "tokens_cache_read": (usage or {}).get("cache_read"),
+        "tokens_cache_write": (usage or {}).get("cache_write"),
+    }
+
+
+def _token_usage(obj: dict[str, Any], payload: dict[str, Any]) -> dict[str, int] | None:
+    """Best-effort extraction of a token-usage reading from a Codex record.
+
+    Codex's rollout format has changed across versions; this looks for a
+    `token_count` / `usage` object in a few known shapes and returns a
+    normalized {input, output, cache_read, cache_write} dict, or None. It is
+    intentionally forgiving: unknown shapes yield None rather than raising.
+    """
+    src = None
+    # A record whose own type is token_count/usage carries the fields inline.
+    if payload.get("type") in ("token_count", "usage"):
+        src = payload
+    else:
+        for cand in (payload.get("token_count"), payload.get("usage"),
+                     obj.get("token_count"), obj.get("usage")):
+            if isinstance(cand, dict):
+                src = cand
+                break
+    if src is None:
+        return None
+    # Some versions nest the counts under an "info"/"total"/"last" object.
+    for nest in ("info", "total", "last"):
+        if isinstance(src.get(nest), dict):
+            src = src[nest]
+            break
+
+    def g(*keys: str) -> int:
+        for k in keys:
+            v = src.get(k)
+            if isinstance(v, int):
+                return v
+        return 0
+
+    read = g("cached_input_tokens", "cache_read_input_tokens", "cache_read")
+    return {
+        "input": g("input_tokens", "input", "prompt_tokens"),
+        "output": g("output_tokens", "output", "completion_tokens"),
+        "cache_read": read,
+        "cache_write": g("cache_creation_input_tokens", "cache_write"),
     }
 
 

{scrollback-0.1.1 → scrollback-0.2.0}/src/scrollback/sources/opencode.py

@@ -80,12 +80,13 @@ class OpenCodeSource(Source):
         return self._list_sessions()
 
     def _list_sessions(self) -> Iterator[Session]:
+        # `SELECT s.*` + `_col` keeps us tolerant of schema drift: newer usage
+        # columns (cache/reasoning) are read when present and default to None
+        # on older opencode databases that lack them.
         with self._connect() as conn:
             rows = conn.execute(
                 """
-                SELECT s.id, s.title, s.directory, s.time_created,
-                       s.time_updated, s.model, s.agent, s.parent_id,
-                       s.cost, s.tokens_input, s.tokens_output,
+                SELECT s.*,
                        (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id)
                            AS msg_count
                 FROM session s
@@ -104,9 +105,7 @@ class OpenCodeSource(Source):
                 agent=r["agent"],
                 parent_id=r["parent_id"],
                 message_count=r["msg_count"],
-                cost=r["cost"],
-                tokens_input=r["tokens_input"],
-                tokens_output=r["tokens_output"],
+                **_usage_from_row(r),
             )
 
     # -- single session -----------------------------------------------------
@@ -175,10 +174,8 @@ class OpenCodeSource(Source):
             agent=srow["agent"],
             parent_id=srow["parent_id"],
             message_count=message_count,
-            cost=_col(srow, "cost"),
-            tokens_input=_col(srow, "tokens_input"),
-            tokens_output=_col(srow, "tokens_output"),
             messages=messages,
+            **_usage_from_row(srow),
         )
 
     # -- windowed loading ---------------------------------------------------
@@ -271,6 +268,18 @@ def _col(row: sqlite3.Row, key: str) -> Any:
         return None
 
 
+def _usage_from_row(row: sqlite3.Row) -> dict[str, Any]:
+    """Extract the usage fields from a session row (missing columns -> None)."""
+    return {
+        "cost": _col(row, "cost"),
+        "tokens_input": _col(row, "tokens_input"),
+        "tokens_output": _col(row, "tokens_output"),
+        "tokens_cache_read": _col(row, "tokens_cache_read"),
+        "tokens_cache_write": _col(row, "tokens_cache_write"),
+        "tokens_reasoning": _col(row, "tokens_reasoning"),
+    }
+
+
 def _loads(s: str | None) -> dict[str, Any]:
     if not s:
         return {}