PyPI - cctrack - Versions diffs - 0.8.0__tar.gz → 0.9.0__tar.gz - Mend

cctrack 0.8.0tar.gz → 0.9.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

{cctrack-0.8.0 → cctrack-0.9.0}/CLAUDE.md RENAMED Viewed

@@ -33,13 +33,13 @@ This is a single-module CLI tool. All logic lives in `src/cctrack/__init__.py`:
 1. **Rate card** (`RATES`, `_an`/`_oa` row builders, `_family_matches`, `get_rates`, `calculate_cost`, `is_known_model`) - Anthropic and OpenAI prices. **Every model version needs its own row**: `_family_matches` lets a row absorb only the exact id, dated snapshots (`-20250514`, `-2025-08-07`) and non-version suffixes (`-codex`) — never a short-number minor version (`claude-opus-5` does NOT match `claude-opus-5-5`) or a size-tier word (`mini`, `nano`, `pro`, `max`, `luna`, `terra`, `sol`, `astra`). This is deliberate: prefix inheritance silently mispriced opus-4-8 (3×) and opus-5-5 (84%) before. Unknown models are flagged `?` and fall back to Sonnet (Claude) or GPT-5 (OpenAI) rates. `get_rates` takes the usage date (time-limited `intro` pricing) and the request's prompt size (`long_context` tiers: Haiku 5.5 >100K, several OpenAI models >272K). Re-verify against the official pricing pages when adding rows; don't infer a price from a neighbouring model.
 1a. **Energy model** (`ENERGY_WH_PER_MTOK`, `estimate_energy_wh`) - Opt-in (`--energy`) order-of-magnitude estimate keyed off each rate entry's `tier`. Deliberately NOT a function of price: both cache-write TTLs use one figure because a 1h write costs more money but the same compute.
-2. **File discovery** (`default_dirs`, `discover_files`) - Walks `~/.claude/projects/` and `~/.sandy/sandboxes/` for `.jsonl` files.
-2a. **Codex** (`discover_codex_files`, `parse_codex_lines`, `parse_codex_events`, `fetch_remote_codex`) - Reads `$CODEX_HOME` (default `~/.codex`) `sessions/` + `archived_sessions/` rollouts, incl. `.jsonl.zst` (stdlib `compression.zstd` on 3.14+, else the `zstd` CLI, else skipped and counted). Lines are `{timestamp, type, payload}`. Prefer `token_usage_record` items (per-response, dedup by `response_id` — forks replay parent history); fall back to legacy `event_msg`/`token_count` only before a file's first record, counting `last_token_usage` only when `total_token_usage.total_tokens` moved (it's re-emitted unchanged). **`input_tokens` includes `cached_input_tokens` and `cache_write_input_tokens`; `output_tokens` includes reasoning** — uncached input = input − cached − cache_write. Model/cwd from the latest `turn_context`; thread id + git branch from `session_meta`. Codex events carry `agent="codex"`.
-3. **Remote aggregation** (`fetch_remote_jsonl`, `parse_remote_events`, `fetch_remote_hook_data`, `parse_remote_hook_data`) - SSHs to hosts, cats all JSONL logs plus statusline hook data (statusline files, monthly summaries, session baselines) with file separators, parses locally.
+2. **File discovery** (`sandy_home`, `_sandy_print_state`, `sandbox_roots`, `default_dirs`, `discover_files`) - Claude transcripts from `~/.claude/projects/` plus each Sandy sandbox's `claude/projects/` (ONLY `projects/` — `claude/` also holds `history.jsonl`, job timelines, tool-audit logs). Sandbox roots come from `sandy --print-state` → `sandboxes[].path` (follows `$SANDY_HOME`), else `$SANDY_HOME/sandboxes/*` (default `~/.sandy`). Per sandy's host-side path contract each root has agent homes `claude/` (→ `~/.claude` in the sandbox) and `codex/` (→ `~/.codex`); everything else under a root is private. **Dot-entries** (`_is_sandbox_name`): skip `.rsync-from.*` (an in-progress `sandy --rsync-from` copy — its hook data was being summed twice) and `*.lock`; any other dot-dir is a REAL sandbox iff it holds `WORKSPACE.json` (a workspace like `~/.dotfiles` → sandbox `.dotfiles-<sha8>`). Sandy's own enumeration, hence `--print-state`, currently omits dot-named sandboxes, so they're always added by scanning `sandboxes/` directly. Tests are isolated from real sandboxes by `tests/conftest.py`.
+2a. **Codex** (`codex_homes`, `discover_codex_files`, `parse_codex_lines`, `parse_codex_events`, `fetch_remote_codex`) - Reads `$CODEX_HOME` (default `~/.codex`) and every sandbox's `codex/` (sandy never sets CODEX_HOME), `sessions/` + `archived_sessions/` rollouts, incl. `.jsonl.zst` (stdlib `compression.zstd` on 3.14+, else the `zstd` CLI, else skipped and counted). Lines are `{timestamp, type, payload}`. Prefer `token_usage_record` items (per-response, dedup by `response_id` — forks replay parent history); fall back to legacy `event_msg`/`token_count` only before a file's first record, counting `last_token_usage` only when `total_token_usage.total_tokens` moved (it's re-emitted unchanged). **`input_tokens` includes `cached_input_tokens` and `cache_write_input_tokens`; `output_tokens` includes reasoning** — uncached input = input − cached − cache_write. Model/cwd from the latest `turn_context`; thread id + git branch from `session_meta`. Codex events carry `agent="codex"`.
+3. **Remote aggregation** (`remote_sandbox_roots`, `fetch_remote_jsonl`, `parse_remote_events`, `fetch_remote_hook_data`, `parse_remote_hook_data`, `fetch_remote_codex`) - One SSH call per host finds its sandbox roots (same rules as locally, cached), then each fetch cats the host's own dirs plus the matching per-sandbox dirs with file separators and parses locally.
 3a. **Hook parsing** (`parse_hook_rows`, `compute_hook_deltas`) - The hook gives **cost only**. Its `input_tokens`/`output_tokens`/`cache_*` fields are context-window SNAPSHOTS (`input_tokens` ≈ `cache_read + cache_write`; `output_tokens` is just the last message's), not cumulative — never use them for token counts. `cost_usd` is a session-lifetime cumulative that is unreliable in two ways handled by `compute_hook_deltas`: (1) it can already be large the first time a session is observed (a long-running/unattended session that only rendered its statusline partway through), so the **first observation is a baseline that is NOT counted** — booking a session's pre-existing cumulative onto its first-seen day is what produced a bogus $3,370 day; (2) it **drops** on resume/compaction (or when parallel processes share one session id), so a drop **rebaselines without counting the new level** — otherwise a day's booked spend can exceed the counter's own peak, which is impossible for real money. Net rule: **book only observed upward increments**; a rolled-up baseline seeds `prev` so already-counted days aren't recounted.
 4. **JSONL parsing** (`parse_lines`, `parse_events`, `dedup_events`) - Extracts `assistant` events with token usage. Deduplicates by `requestId` across all of a host's files (last event wins) — resumed sessions (`--resume`/`--continue`) repeat events with the same `requestId` in new files. Events without `requestId` are never deduped.
 5. **Aggregation** (`aggregate`) - Buckets events into daily and monthly summaries with token counts and costs.
-6. **Output** (`print_report`) - Prints current month-to-date summary with projections, daily breakdown, and previous month summaries. Cost is composed **per source** (one source per machine): hook cost where a source has statusline coverage, accuracy-factor-adjusted JSONL cost otherwise, summed per date. The accuracy factor is measured per source over dates strictly after that source's hook install day.
+6. **Output** (`print_report`) - Prints current month-to-date summary with projections, daily breakdown, and previous month summaries. Cost is composed **per source** (one source per machine): hook cost where a source has statusline coverage, accuracy-factor-adjusted JSONL cost otherwise, summed per date. The accuracy factor is measured per source over dates strictly after that source's hook install day; when unmeasurable, `DEFAULT_ACCURACY_FACTOR` is **1.0** — the old 1.25 "logs undercount ~20-25%" was entirely rate-card error and inflated unmeasured days 25%.
 6a. **Explore** (`print_explore`, `--explore DATE`) - Drills into one day: dollar decomposition by token class, then by model / project / session / machine. Each JSONL event carries its `project` (from `cwd`), `session_id`, `source` (host) and `git_branch` for attribution. Per-session JSONL estimate is shown against the hook's authoritative per-session cost; a >15% day-total divergence is flagged so an inflated estimate (incomplete logs, unknown model) is distinguishable from real spend.
 Entry point: `cctrack:main` (registered in `pyproject.toml` as a console script).

{cctrack-0.8.0 → cctrack-0.9.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cctrack
-Version: 0.8.0
+Version: 0.9.0
 Summary: Claude Code cost tracker — scans JSONL logs and reports token usage + estimated cost
 Project-URL: Homepage, https://github.com/rappdw/cctrack
 Project-URL: Repository, https://github.com/rappdw/cctrack
@@ -50,7 +50,7 @@ cctrack --days 7
 cctrack --remote dgx macbook-air
 # Custom log directories
-cctrack --dirs ~/.claude/projects ~/.sandy/sandboxes
+cctrack --dirs ~/.claude/projects ~/old-machine/projects
 # Only one coding agent (default: all found)
 cctrack --agent claude
@@ -82,7 +82,7 @@ Daily breakdown:
 ## What it does
-1. Walks `~/.claude/projects/` and `~/.sandy/sandboxes/` for JSONL log files
+1. Walks `~/.claude/projects/` — and each [Sandy](#sandy-sandboxes) sandbox's `claude/projects/` — for Claude Code transcripts, and each Codex home for Codex rollouts
 2. Parses `assistant` events with token usage
 3. Deduplicates by `requestId` (last event wins, matching Claude Code's semantics)
 4. Calculates cost using Anthropic's published rates per model
@@ -90,7 +90,7 @@ Daily breakdown:
 ## Codex CLI
-cctrack also reads [Codex CLI](https://github.com/openai/codex) usage from `$CODEX_HOME` (default `~/.codex`) — `sessions/` and `archived_sessions/` — and with `--remote`, from each host. When both agents have spend, the month-to-date block and `--explore` show a per-agent split.
+cctrack also reads [Codex CLI](https://github.com/openai/codex) usage from `$CODEX_HOME` (default `~/.codex`) and from every [Sandy sandbox](#sandy-sandboxes)'s `codex/` — `sessions/` and `archived_sessions/` — and with `--remote`, from each host. When both agents have spend, the month-to-date block and `--explore` show a per-agent split.
 How it's counted (verified against the Codex source, not inferred):
@@ -101,6 +101,18 @@ How it's counted (verified against the Codex source, not inferred):
 Costs are at OpenAI's **API list prices**. If you use Codex through a ChatGPT plan, that's an API-equivalent value, not what you're billed — the same is true of Claude Code on a Claude subscription.
+## Sandy sandboxes
+cctrack finds every [Sandy](https://github.com/rappdw/sandy) sandbox on the machine (and on `--remote` hosts) and includes its Claude Code and Codex usage. It follows sandy's published host-side path contract:
+- **Finding sandboxes:** `sandy --print-state` (`sandboxes[].path`) when sandy is installed, which follows `$SANDY_HOME`; otherwise `$SANDY_HOME/sandboxes/*` (default `~/.sandy/sandboxes`).
+- **Per sandbox:** Claude Code transcripts from `claude/projects/`, statusline-hook data from `claude/cctrack/`, Codex rollouts from `codex/sessions/` and `codex/archived_sessions/`. Other files under `claude/` (`history.jsonl`, job timelines, tool-audit logs) aren't transcripts and are ignored.
+- **Never double counted:** the hidden `.rsync-from.<name>.<pid>/` copy that exists while `sandy --rsync-from` is pulling a sandbox in is skipped, as are `.lock` directories. A sandbox's Codex home is never shared with the host's `~/.codex`, and anything copied between hosts with `sandy --rsync` is deduplicated by request/response id.
+- **Dot-named sandboxes count:** a workspace named like a dotfile directory (e.g. `~/.dotfiles`) gets a sandbox whose name starts with a dot. Sandy's own listing currently omits these, so cctrack scans for them itself — any dot-directory holding `WORKSPACE.json` is a real sandbox.
+Orphaned sandboxes (workspace deleted, sandbox not yet removed) still count: their usage is real history.
 ## Explore a day
 When a day's cost looks wrong or surprisingly high, `--explore` breaks it down:

{cctrack-0.8.0 → cctrack-0.9.0}/README.md RENAMED Viewed

@@ -25,7 +25,7 @@ cctrack --days 7
 cctrack --remote dgx macbook-air
 # Custom log directories
-cctrack --dirs ~/.claude/projects ~/.sandy/sandboxes
+cctrack --dirs ~/.claude/projects ~/old-machine/projects
 # Only one coding agent (default: all found)
 cctrack --agent claude
@@ -57,7 +57,7 @@ Daily breakdown:
 ## What it does
-1. Walks `~/.claude/projects/` and `~/.sandy/sandboxes/` for JSONL log files
+1. Walks `~/.claude/projects/` — and each [Sandy](#sandy-sandboxes) sandbox's `claude/projects/` — for Claude Code transcripts, and each Codex home for Codex rollouts
 2. Parses `assistant` events with token usage
 3. Deduplicates by `requestId` (last event wins, matching Claude Code's semantics)
 4. Calculates cost using Anthropic's published rates per model
@@ -65,7 +65,7 @@ Daily breakdown:
 ## Codex CLI
-cctrack also reads [Codex CLI](https://github.com/openai/codex) usage from `$CODEX_HOME` (default `~/.codex`) — `sessions/` and `archived_sessions/` — and with `--remote`, from each host. When both agents have spend, the month-to-date block and `--explore` show a per-agent split.
+cctrack also reads [Codex CLI](https://github.com/openai/codex) usage from `$CODEX_HOME` (default `~/.codex`) and from every [Sandy sandbox](#sandy-sandboxes)'s `codex/` — `sessions/` and `archived_sessions/` — and with `--remote`, from each host. When both agents have spend, the month-to-date block and `--explore` show a per-agent split.
 How it's counted (verified against the Codex source, not inferred):
@@ -76,6 +76,18 @@ How it's counted (verified against the Codex source, not inferred):
 Costs are at OpenAI's **API list prices**. If you use Codex through a ChatGPT plan, that's an API-equivalent value, not what you're billed — the same is true of Claude Code on a Claude subscription.
+## Sandy sandboxes
+cctrack finds every [Sandy](https://github.com/rappdw/sandy) sandbox on the machine (and on `--remote` hosts) and includes its Claude Code and Codex usage. It follows sandy's published host-side path contract:
+- **Finding sandboxes:** `sandy --print-state` (`sandboxes[].path`) when sandy is installed, which follows `$SANDY_HOME`; otherwise `$SANDY_HOME/sandboxes/*` (default `~/.sandy/sandboxes`).
+- **Per sandbox:** Claude Code transcripts from `claude/projects/`, statusline-hook data from `claude/cctrack/`, Codex rollouts from `codex/sessions/` and `codex/archived_sessions/`. Other files under `claude/` (`history.jsonl`, job timelines, tool-audit logs) aren't transcripts and are ignored.
+- **Never double counted:** the hidden `.rsync-from.<name>.<pid>/` copy that exists while `sandy --rsync-from` is pulling a sandbox in is skipped, as are `.lock` directories. A sandbox's Codex home is never shared with the host's `~/.codex`, and anything copied between hosts with `sandy --rsync` is deduplicated by request/response id.
+- **Dot-named sandboxes count:** a workspace named like a dotfile directory (e.g. `~/.dotfiles`) gets a sandbox whose name starts with a dot. Sandy's own listing currently omits these, so cctrack scans for them itself — any dot-directory holding `WORKSPACE.json` is a real sandbox.
+Orphaned sandboxes (workspace deleted, sandbox not yet removed) still count: their usage is real history.
 ## Explore a day
 When a day's cost looks wrong or surprisingly high, `--explore` breaks it down:

{cctrack-0.8.0 → cctrack-0.9.0}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "cctrack"
-version = "0.8.0"
+version = "0.9.0"
 description = "Claude Code cost tracker — scans JSONL logs and reports token usage + estimated cost"
 readme = "README.md"
 license = "MIT"

{cctrack-0.8.0 → cctrack-0.9.0}/src/cctrack/__init__.py RENAMED Viewed

@@ -281,12 +281,83 @@ def format_energy(wh: float) -> str:
 # ── File discovery ──────────────────────────────────────────────────────
+# Sandy sandboxes (https://github.com/rappdw/sandy). Per sandy's host-side path
+# contract, each sandbox root holds one directory per agent home — claude/
+# (mounted at ~/.claude inside the sandbox) and codex/ (~/.codex). Everything
+# else under a sandbox root is private. Roots are found via `sandy
+# --print-state` (sandboxes[].path, which follows $SANDY_HOME); without sandy on
+# PATH we fall back to $SANDY_HOME/sandboxes/* (default ~/.sandy). Dot-entries
+# are never sandboxes: an in-progress `sandy --rsync-from` pull lives in a
+# hidden .rsync-from.<name>.<pid>/ copy, and counting it would double the
+# sandbox's spend.
+def sandy_home() -> Path:
+    return Path(os.environ.get("SANDY_HOME") or (Path.home() / ".sandy"))
+def _sandy_print_state() -> list[str] | None:
+    """sandboxes[].path from `sandy --print-state`, or None if unavailable."""
+    import shutil
+    if not shutil.which("sandy"):
+        return None
+    try:
+        r = subprocess.run(["sandy", "--print-state"], capture_output=True,
+                           text=True, timeout=30)
+        if r.returncode != 0:
+            return None
+        state = json.loads(r.stdout)
+    except (OSError, subprocess.TimeoutExpired, json.JSONDecodeError, ValueError):
+        return None
+    boxes = state.get("sandboxes") if isinstance(state, dict) else None
+    if not isinstance(boxes, list):
+        return None
+    return [b["path"] for b in boxes if isinstance(b, dict) and b.get("path")]
+def _is_sandbox_name(name: str, has_workspace_json: bool | None) -> bool:
+    """Which entries of sandboxes/ are real sandboxes. A sandbox is named
+    <workspace basename>-<sha8> and nothing strips a leading dot, so a workspace
+    like ~/.dotfiles gets a REAL sandbox ".dotfiles-1a2b3c4d". Among dot-entries:
+    .rsync-from.* is an in-progress copy of another sandbox (counting it double
+    counts); *.lock dirs hold only a pid; any other dot-dir is a sandbox iff it
+    holds WORKSPACE.json (written at every launch since sandy 0.10.1).
+    `has_workspace_json` None means "unknown" (trust the source)."""
+    if name in (".", ".."):
+        return False
+    if not name.startswith("."):
+        return True
+    if name.startswith(".rsync-from.") or name.endswith(".lock"):
+        return False
+    return has_workspace_json is not False
+def sandbox_roots() -> list[Path]:
+    """Root directory of every Sandy sandbox on this machine.
+    Uses `sandy --print-state` when available, else every entry of
+    $SANDY_HOME/sandboxes/. Dot-named sandboxes are always added by scanning
+    sandboxes/ directly: sandy's own enumeration (and so --print-state) skips
+    them today, which would silently drop their usage."""
+    base = sandy_home() / "sandboxes"
+    entries = sorted(p for p in base.iterdir() if p.is_dir()) if base.is_dir() else []
+    paths = _sandy_print_state()
+    candidates = [Path(p) for p in paths] if paths is not None else list(entries)
+    candidates += [p for p in entries if p.name.startswith(".")]
+    roots = {p for p in candidates
+             if _is_sandbox_name(p.name, (p / "WORKSPACE.json").is_file()
+                                 if p.name.startswith(".") else None)}
+    return sorted(roots)
 def default_dirs() -> list[str]:
-    home = Path.home()
-    dirs = [str(home / ".claude" / "projects")]
-    sandy = home / ".sandy" / "sandboxes"
-    if sandy.exists():
-        dirs.append(str(sandy))
+    """Claude Code transcript dirs: the host's ~/.claude/projects plus each
+    sandbox's claude/projects. Only projects/ holds transcripts — claude/ also
+    has history.jsonl, job timelines and tool-audit logs, which aren't."""
+    dirs = [str(Path.home() / ".claude" / "projects")]
+    for root in sandbox_roots():
+        proj = root / "claude" / "projects"
+        if proj.is_dir():
+            dirs.append(str(proj))
     return dirs
@@ -304,14 +375,75 @@ def discover_files(dirs: list[str]) -> list[str]:
 # ── Remote host support ────────────────────────────────────────────────
-REMOTE_DIRS = "~/.claude/projects ~/.sandy/sandboxes"
+_STATE_END = "___CCTRACK_SANDY_STATE_END___"
+_remote_roots_cache: dict[str, list[str]] = {}
+def remote_sandbox_roots(host: str) -> list[str]:
+    """Sandy sandbox roots on a remote host, found the same way as locally:
+    `sandy --print-state` if the host has sandy, else the shell glob of
+    $SANDY_HOME/sandboxes/*/, plus dot-named sandboxes (dot-dirs holding
+    WORKSPACE.json), filtered by _is_sandbox_name. One SSH call, cached."""
+    if host in _remote_roots_cache:
+        return _remote_roots_cache[host]
+    remote_cmd = (
+        "command -v sandy >/dev/null 2>&1 && sandy --print-state 2>/dev/null; "
+        f"echo '{_STATE_END}'; "
+        'B="${SANDY_HOME:-$HOME/.sandy}/sandboxes"; '
+        'ls -1d "$B"/*/ 2>/dev/null; '
+        f"echo '{_STATE_END}'; "
+        'for d in "$B"/.*/; do [ -f "$d/WORKSPACE.json" ] && echo "$d"; done 2>/dev/null; true'
+    )
+    cmd = ["ssh", "-o", "ConnectTimeout=10", "-o", "BatchMode=yes", host, remote_cmd]
+    try:
+        out = subprocess.run(cmd, capture_output=True, text=True, timeout=60).stdout or ""
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        out = ""
+    if not isinstance(out, str):
+        out = ""
+    state_part, _, rest = out.partition(_STATE_END)
+    glob_part, _, dot_part = rest.partition(_STATE_END)
+    paths = None
+    try:
+        state = json.loads(state_part) if state_part.strip() else None
+        boxes = state.get("sandboxes") if isinstance(state, dict) else None
+        if isinstance(boxes, list):
+            paths = [b["path"] for b in boxes if isinstance(b, dict) and b.get("path")]
+    except (json.JSONDecodeError, ValueError):
+        paths = None
+    if paths is None:
+        paths = [l.strip() for l in glob_part.splitlines() if l.strip()]
+    # Dot-dirs listed here were confirmed to hold WORKSPACE.json remotely.
+    dot_paths = [l.strip() for l in dot_part.splitlines() if l.strip()]
+    roots = set()
+    for p in paths:
+        p = p.rstrip("/")
+        name = p.rsplit("/", 1)[-1]
+        if _is_sandbox_name(name, None if not name.startswith(".") else
+                            any(d.rstrip("/") == p for d in dot_paths)):
+            roots.add(p)
+    for d in dot_paths:
+        d = d.rstrip("/")
+        if _is_sandbox_name(d.rsplit("/", 1)[-1], True):
+            roots.add(d)
+    roots = sorted(roots)
+    _remote_roots_cache[host] = roots
+    return roots
+def _q(path: str) -> str:
+    import shlex
+    return shlex.quote(path)
 def fetch_remote_jsonl(host: str) -> str:
-    """SSH to host and cat all JSONL files from default dirs. Returns raw output."""
+    """SSH to host and cat Claude transcripts: ~/.claude/projects plus each
+    sandbox's claude/projects. Returns raw output."""
+    dirs = " ".join(['"$HOME/.claude/projects"']
+                    + [_q(f"{r}/claude/projects") for r in remote_sandbox_roots(host)])
     cmd = [
         "ssh", "-o", "ConnectTimeout=10", "-o", "BatchMode=yes", host,
-        f"find {REMOTE_DIRS} -name '*.jsonl' -exec echo '___CCTRACK_FILE_SEP___' \\; -exec cat {{}} \\; 2>/dev/null"
+        f"find {dirs} -name '*.jsonl' -exec echo '___CCTRACK_FILE_SEP___' \\; -exec cat {{}} \\; 2>/dev/null"
     ]
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
@@ -350,18 +482,20 @@ BASELINE_FILE_SEP = "___CCTRACK_BASELINE_FILE___"
 # Hook data locations on remote hosts: the host's own cctrack dir plus any
 # Sandy sandbox equivalents (mirrors discover_hook_data_dirs).
-REMOTE_HOOK_DIRS = "~/.claude/cctrack ~/.sandy/sandboxes"
 def fetch_remote_hook_data(host: str) -> str:
-    """SSH to host and cat all statusline JSONL + monthly summary files.
+    """SSH to host and cat all statusline JSONL + monthly summary files from
+    ~/.claude/cctrack and each sandbox's claude/cctrack.
     Returns raw output with file-type separators."""
+    hook_dirs = " ".join(['"$HOME/.claude/cctrack"']
+                         + [_q(f"{r}/claude/cctrack") for r in remote_sandbox_roots(host)])
     remote_cmd = (
-        f"find {REMOTE_HOOK_DIRS} -name 'statusline*.jsonl' "
+        f"find {hook_dirs} -name 'statusline*.jsonl' "
         f"-exec echo '{HOOK_FILE_SEP}' \\; -exec cat {{}} \\; 2>/dev/null; "
-        f"find {REMOTE_HOOK_DIRS} -name 'monthly-*.json' "
+        f"find {hook_dirs} -name 'monthly-*.json' "
         f"-exec echo '{MONTHLY_FILE_SEP}' \\; -exec cat {{}} \\; 2>/dev/null; "
-        f"find {REMOTE_HOOK_DIRS} -name 'session-baselines.json' "
+        f"find {hook_dirs} -name 'session-baselines.json' "
         f"-exec echo '{BASELINE_FILE_SEP}' \\; -exec cat {{}} \\; 2>/dev/null; "
         f"true"
     )
@@ -510,17 +644,15 @@ def cctrack_dir() -> Path:
 def discover_hook_data_dirs() -> list[Path]:
-    """Return all directories that may contain cctrack hook data.
-    Includes the host's ~/.claude/cctrack and any Sandy sandbox equivalents
-    at ~/.sandy/sandboxes/*/claude/cctrack."""
+    """Return all directories that may contain cctrack hook data: the host's
+    ~/.claude/cctrack and each Sandy sandbox's claude/cctrack."""
     dirs = []
     if CCTRACK_DIR.exists():
         dirs.append(CCTRACK_DIR)
-    sandy = Path.home() / ".sandy" / "sandboxes"
-    if sandy.exists():
-        for candidate in sandy.glob("*/claude/cctrack"):
-            if candidate.is_dir() and candidate not in dirs:
-                dirs.append(candidate)
+    for root in sandbox_roots():
+        candidate = root / "claude" / "cctrack"
+        if candidate.is_dir() and candidate not in dirs:
+            dirs.append(candidate)
     return dirs
@@ -710,7 +842,12 @@ if cctrack_dir.exists():
         print("ssh command not found", file=sys.stderr)
-DEFAULT_ACCURACY_FACTOR = 1.25
+# Ratio of hook (Claude Code's own) cost to JSONL-priced cost, used only when
+# it can't be measured from overlapping days. It was once 1.25 on the belief
+# that logs undercount ~20-25%; that gap was entirely rate-card error, and with
+# correct prices measured ratios sit at 0.99-1.02x. A stale 1.25 inflated every
+# unmeasured day by a quarter.
+DEFAULT_ACCURACY_FACTOR = 1.0
 def prompt_hook_install() -> None:
@@ -867,14 +1004,36 @@ def codex_home() -> Path:
     return Path(os.environ.get("CODEX_HOME") or (Path.home() / ".codex"))
-def discover_codex_files(home: Path | None = None) -> list[str]:
-    """Rollout files (plain and .zst) under sessions/ and archived_sessions/.
+def codex_homes() -> list[Path]:
+    """The host's Codex home plus each Sandy sandbox's codex/ (sandy mounts it
+    at ~/.codex inside the sandbox and never sets CODEX_HOME). A sandbox only
+    has codex/ once Codex has run in it. Deduplicated by real path, in case
+    CODEX_HOME points into a sandbox."""
+    homes, seen = [], set()
+    for h in [codex_home()] + [r / "codex" for r in sandbox_roots()]:
+        if not h.is_dir():
+            continue
+        key = h.resolve()
+        if key not in seen:
+            seen.add(key)
+            homes.append(h)
+    return homes
+def discover_codex_files(home: Path | list[Path] | None = None) -> list[str]:
+    """Rollout files (plain and .zst) under sessions/ and archived_sessions/ of
+    one Codex home, a list of them, or (default) every home on this machine.
     When both a plain file and its .zst sibling exist, the plain one wins
     (Codex materialises a .zst back to plain when it appends)."""
-    home = home or codex_home()
+    if home is None:
+        homes = codex_homes()
+    elif isinstance(home, (list, tuple)):
+        homes = list(home)
+    else:
+        homes = [home]
     found: dict[str, str] = {}
-    for sub in ("sessions", "archived_sessions"):
-        root = home / sub
+    for sub, h in ((sub, h) for h in homes for sub in ("sessions", "archived_sessions")):
+        root = h / sub
         if not root.exists():
             continue
         for f in root.rglob("rollout-*.jsonl*"):
@@ -1031,14 +1190,15 @@ REMOTE_CODEX_SEP = "___CCTRACK_CODEX_FILE___"
 def fetch_remote_codex(host: str) -> str:
-    """SSH to host and stream its Codex rollouts (decompressing .zst remotely
-    when the host has `zstd`)."""
+    """SSH to host and stream its Codex rollouts — its own Codex home plus each
+    sandbox's codex/ — decompressing .zst remotely when the host has `zstd`."""
+    homes = ['"${CODEX_HOME:-$HOME/.codex}"'] + [_q(f"{r}/codex") for r in remote_sandbox_roots(host)]
+    dirs = " ".join(f"{h}/sessions {h}/archived_sessions" for h in homes)
     remote_cmd = (
-        'CH="${CODEX_HOME:-$HOME/.codex}"; '
-        f'find "$CH/sessions" "$CH/archived_sessions" -name "rollout-*.jsonl" '
+        f'find {dirs} -name "rollout-*.jsonl" '
         f"-exec echo '{REMOTE_CODEX_SEP}' \\; -exec cat {{}} \\; 2>/dev/null; "
         'if command -v zstd >/dev/null 2>&1; then '
-        f'find "$CH/sessions" "$CH/archived_sessions" -name "rollout-*.jsonl.zst" '
+        f'find {dirs} -name "rollout-*.jsonl.zst" '
         f"-exec echo '{REMOTE_CODEX_SEP}' \\; -exec zstd -dc {{}} \\; 2>/dev/null; fi; true"
     )
     cmd = ["ssh", "-o", "ConnectTimeout=10", "-o", "BatchMode=yes", host, remote_cmd]
@@ -1636,8 +1796,16 @@ def print_report(daily: dict, monthly: dict, days: int | None = None,
         return s
     # Header
-    print("cctrack — Claude Code Cost Report")
-    print("══════════════════════════════════")
+    agents_present = {src.get("agent", "claude") for src in sources
+                      if src["daily"] or src["hook_daily"]}
+    if agents_present == {"codex"}:
+        title = "cctrack — Codex Cost Report"
+    elif "codex" in agents_present:
+        title = "cctrack — Claude Code + Codex Cost Report"
+    else:
+        title = "cctrack — Claude Code Cost Report"
+    print(title)
+    print("═" * len(title))
     print()
     # Current month-to-date
@@ -1699,7 +1867,7 @@ def print_report(daily: dict, monthly: dict, days: int | None = None,
             print(f"  Sessions:       {mtd_sessions:>15}")
         if hooks_exist and est_days > 0:
-            factor_source = "measured" if factor_is_measured else "estimated ~20-25%"
+            factor_source = "measured" if factor_is_measured else "default"
             cost_note = f" ({accuracy_factor:.2f}x adjustment, {factor_source})"
             if auth_days > 0:
                 cost_note = f" ({auth_days}d authoritative, {est_days}d adjusted {accuracy_factor:.2f}x)"
@@ -1777,7 +1945,7 @@ def print_report(daily: dict, monthly: dict, days: int | None = None,
             if factor_is_measured:
                 print(f"  ~ = estimated (JSONL-derived, {accuracy_factor:.1f}x undercount measured from hook data)")
             else:
-                print("  ~ = estimated (JSONL-derived, may undercount by ~20-25%)")
+                print("  ~ = estimated (JSONL-derived; no hook overlap yet to measure accuracy)")
     # Previous months summary
     prev_months = [m for m in sorted_months if m != current_month]
@@ -2128,7 +2296,7 @@ def main():
     )
     parser.add_argument(
         "--dirs", nargs="+", default=None,
-        help="Custom log directories to scan (default: ~/.claude/projects and ~/.sandy/sandboxes)"
+        help="Custom Claude transcript directories to scan (default: ~/.claude/projects plus each Sandy sandbox's claude/projects)"
     )
     parser.add_argument(
         "--remote", nargs="+", default=None, metavar="HOST",

cctrack-0.9.0/tests/conftest.py ADDED Viewed

@@ -0,0 +1,25 @@
+"""Shared test isolation.
+cctrack discovers Sandy sandboxes by running `sandy --print-state` and by
+reading $SANDY_HOME. Tests must never touch a developer's real sandboxes, so by
+default the sandy probe returns "unavailable" and SANDY_HOME points at an empty
+temp dir. Tests that exercise the probe itself use the `real_sandy_probe` marker.
+"""
+import pytest
+import cctrack
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers", "real_sandy_probe: don't stub cctrack._sandy_print_state")
+@pytest.fixture(autouse=True)
+def _isolate_sandy(request, monkeypatch, tmp_path):
+    monkeypatch.setenv("SANDY_HOME", str(tmp_path / "no-sandy"))
+    if not request.node.get_closest_marker("real_sandy_probe"):
+        monkeypatch.setattr(cctrack, "_sandy_print_state", lambda: None)
+    cctrack._remote_roots_cache.clear()
+    yield
+    cctrack._remote_roots_cache.clear()

{cctrack-0.8.0 → cctrack-0.9.0}/tests/test_hook_reporting.py RENAMED Viewed

@@ -1180,7 +1180,8 @@ def test_adjusted_cost_with_measured_factor(capsys):
 def test_adjusted_cost_without_overlap_uses_default(capsys):
-    """Without overlap, uses default 1.25x factor for adjustment."""
+    """Without overlap, the default factor applies. It is 1.0: with correct
+    prices, logs and Claude Code's own cost agree (measured 0.99-1.02x)."""
     fake_now = datetime(2026, 4, 17, 12, 0, 0, tzinfo=timezone.utc)
     daily = {
@@ -1200,12 +1201,13 @@ def test_adjusted_cost_without_overlap_uses_default(capsys):
                              hook_install_date="2026-04-15")
     out = capsys.readouterr().out
-    # MTD: adjusted(4*1.25 + 4*1.25) + hook(5) = 10 + 5 = 15.00
-    assert "15.00" in out
-    # Tilde on estimated days
+    # MTD: estimated(4 + 4) + hook(5) = 13.00 — no unmeasured inflation
+    assert cctrack.DEFAULT_ACCURACY_FACTOR == 1.0
+    assert "13.00" in out
+    # Tilde on estimated days, and the legend says why
     assert "~" in out
-    # Legend mentions 20-25%
-    assert "20-25%" in out
+    assert "no hook overlap" in out
+    assert "20-25%" not in out
 # ── Previous month accuracy estimation ─────────────────────────────────
@@ -1215,7 +1217,7 @@ def test_previous_month_estimated_actual(capsys):
     fake_now = datetime(2026, 4, 17, 12, 0, 0, tzinfo=timezone.utc)
     daily = {
-        "2026-04-15": make_bucket(input=1000, cost=4.00),
+        "2026-04-16": make_bucket(input=1000, cost=4.00),
         "2026-03-20": make_bucket(input=2000, cost=8.00),
         "2026-03-21": make_bucket(input=1500, cost=6.00),
     }
@@ -1224,7 +1226,9 @@ def test_previous_month_estimated_actual(capsys):
         "2026-03": make_bucket(input=3500, cost=14.00),
     }
     hook_daily = {
-        "2026-04-15": {"cost": 5.00, "sessions": 1},  # 1.25x factor
+        # post-install overlap → a MEASURED 1.25x factor (the install day
+        # itself is excluded from measurement)
+        "2026-04-16": {"cost": 5.00, "sessions": 1},
     }
     with patch("cctrack.datetime") as mock_dt:
@@ -1235,7 +1239,7 @@ def test_previous_month_estimated_actual(capsys):
                              hook_install_date="2026-04-15")
     out = capsys.readouterr().out
-    # Previous month cost is JSONL-only: (8+6)*1.25 = 17.50 (adjusted per day)
+    # Previous month cost is JSONL-only: (8+6) × measured 1.25 = 17.50
     assert "Previous months:" in out
     assert "17.50" in out
     assert "~" in out
@@ -1468,8 +1472,10 @@ def test_discover_hook_data_dirs_host_only():
             assert len(dirs) == 1
-def test_discover_hook_data_dirs_with_sandy():
-    """Finds both host and Sandy sandbox cctrack dirs."""
+def test_discover_hook_data_dirs_with_sandy(monkeypatch):
+    """Finds both host and Sandy sandbox cctrack dirs.
+    With SANDY_HOME unset, sandboxes default to ~/.sandy/sandboxes."""
+    monkeypatch.delenv("SANDY_HOME", raising=False)
     with tempfile.TemporaryDirectory() as home:
         cctrack_dir = Path(home) / ".claude" / "cctrack"
         cctrack_dir.mkdir(parents=True)
@@ -1487,8 +1493,10 @@ def test_discover_hook_data_dirs_with_sandy():
             assert len(dirs) == 3
-def test_discover_hook_data_dirs_sandy_only():
-    """Finds Sandy sandbox dirs even when host dir doesn't exist."""
+def test_discover_hook_data_dirs_sandy_only(monkeypatch):
+    """Finds Sandy sandbox dirs even when host dir doesn't exist.
+    With SANDY_HOME unset, sandboxes default to ~/.sandy/sandboxes."""
+    monkeypatch.delenv("SANDY_HOME", raising=False)
     with tempfile.TemporaryDirectory() as home:
         cctrack_dir = Path(home) / ".claude" / "cctrack"
         # Don't create host dir

cctrack-0.9.0/tests/test_sandy.py ADDED Viewed

@@ -0,0 +1,298 @@
+"""Tests for Sandy sandbox discovery (Claude transcripts, hook data, Codex).
+Layout per sandy's published host-side path contract: each sandbox root holds
+one directory per agent home — claude/ (~/.claude inside the sandbox) and
+codex/ (~/.codex). Roots come from `sandy --print-state` (sandboxes[].path,
+which follows $SANDY_HOME) or, without sandy, $SANDY_HOME/sandboxes/*. A
+dot-entry such as .rsync-from.<name>.<pid>/ is an in-progress `sandy
+--rsync-from` copy and must never be counted.
+"""
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from unittest.mock import patch
+import pytest
+import cctrack
+# ── Fixture builders ────────────────────────────────────────────────────
+def _w(path: Path, rows: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(json.dumps(r) for r in rows) + "\n")
+def _rollout(thread, rid, inp, model="gpt-5.4"):
+    """A one-response Codex rollout. Requests stay under 272K tokens so they
+    bill at the standard gpt-5.4 rate ($2.50/M input)."""
+    return [
+        {"timestamp": "2026-10-12T09:00:00.000Z", "type": "session_meta",
+         "payload": {"id": thread, "cwd": f"/w/{thread}"}},
+        {"timestamp": "2026-10-12T09:00:01.000Z", "type": "turn_context",
+         "payload": {"model": model, "cwd": f"/w/{thread}"}},
+        {"timestamp": "2026-10-12T09:00:02.000Z", "type": "token_usage_record",
+         "payload": {"thread_id": thread, "response_id": rid,
+                     "usage": {"input_tokens": inp, "cached_input_tokens": 0,
+                               "cache_write_input_tokens": 0, "output_tokens": 0,
+                               "reasoning_output_tokens": 0, "total_tokens": inp}}},
+    ]
+def _claude(rid, sid):
+    return [{"type": "assistant", "requestId": rid, "sessionId": sid,
+             "timestamp": "2026-10-12T09:00:00.000Z", "cwd": "/w/x",
+             "message": {"model": "claude-opus-5",
+                         "usage": {"input_tokens": 200_000, "output_tokens": 0}}}]
+def _hook(cost):
+    return [{"_ts": "2026-10-12T09:00:00+00:00", "session_id": "s1", "cost_usd": 0},
+            {"_ts": "2026-10-12T10:00:00+00:00", "session_id": "s1", "cost_usd": cost}]
+@pytest.fixture
+def fake_host(tmp_path, monkeypatch):
+    """A host with its own ~/.codex, two sandboxes (one named with a space),
+    an in-progress rsync copy, and non-transcript files under claude/."""
+    home = tmp_path / "home"
+    sb = home / ".sandy" / "sandboxes"
+    _w(home / ".codex/sessions/2026/10/12/rollout-a.jsonl", _rollout("host", "r-host", 100_000))
+    _w(sb / "web/codex/sessions/2026/10/12/rollout-b.jsonl", _rollout("web", "r-web", 200_000))
+    _w(sb / "my box/codex/archived_sessions/rollout-c.jsonl", _rollout("mybox", "r-mybox", 40_000))
+    _w(sb / "web/claude/projects/p/s.jsonl", _claude("req-web", "cw"))
+    _w(sb / "web/claude/cctrack/statusline-2026-10-12.jsonl", _hook(5.0))
+    # Not transcripts — shaped like them on purpose, so only path scoping can
+    # keep them out (real ones have other shapes).
+    _w(sb / "web/claude/history.jsonl", _claude("req-hist", "ch"))
+    _w(sb / "web/claude/jobs/j1/timeline.jsonl", _claude("req-job", "cj"))
+    # In-progress `sandy --rsync-from` pull: a hidden full copy. Distinct ids,
+    # so only dot-entry skipping (not dedup) keeps it out.
+    ghost = sb / ".rsync-from.web.4242"
+    _w(ghost / "codex/sessions/2026/10/12/rollout-z.jsonl", _rollout("ghost", "r-ghost", 250_000))
+    _w(ghost / "claude/projects/p/s.jsonl", _claude("req-ghost", "cg"))
+    _w(ghost / "claude/cctrack/statusline-2026-10-12.jsonl", _hook(5.0))
+    (sb / ".web.lock").mkdir()
+    # A copy also carries WORKSPACE.json, so only its NAME can exclude it.
+    (ghost / "WORKSPACE.json").write_text("{}")
+    # A REAL sandbox for a workspace named like a dotfile dir (~/.dotfiles).
+    # sandy's own enumeration (and --print-state) currently misses these.
+    dot = sb / ".dotfiles-1a2b3c4d"
+    (dot).mkdir()
+    (dot / "WORKSPACE.json").write_text("{}")
+    _w(dot / "codex/sessions/2026/10/12/rollout-d.jsonl", _rollout("dotfiles", "r-dot", 80_000))
+    lock = sb / "..dotfiles-1a2b3c4d.lock"
+    lock.mkdir()
+    (lock / "WORKSPACE.json").write_text("{}")   # even so: a lock is never a sandbox
+    # A dot-dir that isn't a sandbox (no WORKSPACE.json) — must be ignored.
+    _w(sb / ".scratch/codex/sessions/2026/10/12/rollout-s.jsonl", _rollout("stray", "r-stray", 123_000))
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: home))
+    monkeypatch.delenv("SANDY_HOME", raising=False)
+    monkeypatch.delenv("CODEX_HOME", raising=False)
+    monkeypatch.setattr(cctrack, "CCTRACK_DIR", home / ".claude" / "cctrack")
+    return home
+def _cost(events):
+    return round(sum(v["cost"] for v in cctrack.aggregate(events)[0].values()), 6)
+# host 100K + web 200K + "my box" 40K + .dotfiles 80K tokens of gpt-5.4 input at $2.50/M
+CODEX_EXPECTED = (100_000 + 200_000 + 40_000 + 80_000) * 2.50 / 1e6
+CODEX_THREADS = ["dotfiles", "host", "mybox", "web"]
+ROOT_NAMES = [".dotfiles-1a2b3c4d", "my box", "web"]
+# 200K tokens of claude-opus-5 input at $5/M
+CLAUDE_EXPECTED = 200_000 * 5.00 / 1e6
+# ── Sandbox roots ───────────────────────────────────────────────────────
+def test_roots_fallback_dot_entry_rules(fake_host):
+    """Skips the rsync copy, lock dirs and dot-dirs without WORKSPACE.json;
+    keeps a real dot-named sandbox."""
+    assert [p.name for p in cctrack.sandbox_roots()] == ROOT_NAMES
+def test_dot_named_sandbox_found_even_with_print_state(fake_host, monkeypatch):
+    """sandy --print-state currently omits dot-named sandboxes (a sandy bug);
+    cctrack adds them by scanning sandboxes/ itself."""
+    sb = fake_host / ".sandy" / "sandboxes"
+    monkeypatch.setattr(cctrack, "_sandy_print_state",
+                        lambda: [str(sb / "web"), str(sb / "my box")])
+    assert [p.name for p in cctrack.sandbox_roots()] == ROOT_NAMES
+@pytest.mark.parametrize("name,ws,expected", [
+    ("web-1a2b3c4d", None, True),
+    (".dotfiles-1a2b3c4d", True, True),
+    (".dotfiles-1a2b3c4d", False, False),       # dot-dir without WORKSPACE.json
+    (".rsync-from.web-1a2b3c4d.4242", True, False),
+    ("..dotfiles-1a2b3c4d.lock", True, False),
+    (".web-1a2b3c4d.lock", False, False),
+    (".", True, False), ("..", True, False),
+])
+def test_is_sandbox_name(name, ws, expected):
+    assert cctrack._is_sandbox_name(name, ws) is expected
+def test_roots_follow_sandy_home(tmp_path, monkeypatch):
+    sh = tmp_path / "elsewhere"
+    (sh / "sandboxes" / "relocated").mkdir(parents=True)
+    monkeypatch.setenv("SANDY_HOME", str(sh))
+    assert [p.name for p in cctrack.sandbox_roots()] == ["relocated"]
+def test_roots_prefer_print_state(tmp_path, monkeypatch):
+    a, hidden = tmp_path / "a", tmp_path / ".rsync-from.a.1"
+    monkeypatch.setattr(cctrack, "_sandy_print_state", lambda: [str(a), str(hidden)])
+    assert cctrack.sandbox_roots() == [a]
+def test_no_sandy_no_sandboxes(tmp_path):
+    # conftest points SANDY_HOME at an empty temp dir and stubs the probe
+    assert cctrack.sandbox_roots() == []
+@pytest.mark.real_sandy_probe
+def test_print_state_probe_parses_paths():
+    out = json.dumps({"sandboxes": [{"name": "a", "path": "/s/a", "agents": ["codex"]},
+                                    {"name": "b", "path": "/s/b"}, {"name": "nopath"}]})
+    done = subprocess.CompletedProcess(["sandy"], 0, stdout=out, stderr="")
+    with patch("shutil.which", return_value="/usr/bin/sandy"), \
+         patch("subprocess.run", return_value=done) as run:
+        assert cctrack._sandy_print_state() == ["/s/a", "/s/b"]
+        assert run.call_args[0][0] == ["sandy", "--print-state"]
+@pytest.mark.real_sandy_probe
+@pytest.mark.parametrize("which,result", [
+    (None, None),                                                              # no sandy
+    ("/usr/bin/sandy", subprocess.CompletedProcess([], 1, stdout="", stderr="x")),  # failed
+    ("/usr/bin/sandy", subprocess.CompletedProcess([], 0, stdout="not json", stderr="")),
+    ("/usr/bin/sandy", subprocess.CompletedProcess([], 0, stdout='{"other": 1}', stderr="")),
+])
+def test_print_state_probe_unavailable(which, result):
+    with patch("shutil.which", return_value=which), \
+         patch("subprocess.run", return_value=result):
+        assert cctrack._sandy_print_state() is None
+# ── Local discovery ─────────────────────────────────────────────────────
+def test_codex_found_in_every_sandbox(fake_host):
+    events, skipped = cctrack.parse_codex_events(cctrack.discover_codex_files())
+    assert skipped == 0
+    assert sorted(e["session_id"] for e in events) == CODEX_THREADS
+    assert _cost(events) == pytest.approx(CODEX_EXPECTED)
+def test_claude_scan_scoped_to_projects(fake_host):
+    """history.jsonl / jobs timelines / codex rollouts aren't transcripts."""
+    dirs = cctrack.default_dirs()
+    assert all(d.endswith("projects") for d in dirs)
+    events = cctrack.parse_events(cctrack.discover_files(dirs))
+    assert [e["_request_id"] for e in events] == ["req-web"]
+    assert _cost(events) == pytest.approx(CLAUDE_EXPECTED)
+def test_rsync_copy_hook_data_not_double_counted(fake_host):
+    """Regression: hook data in a hidden .rsync-from copy was summed again
+    ($10 reported for $5 of real spend)."""
+    dirs = cctrack.discover_hook_data_dirs()
+    assert not any(".rsync-from" in str(d) for d in dirs)
+    events = []
+    for d in dirs:
+        events += cctrack.compute_hook_deltas(cctrack.parse_hook_rows(d),
+                                              cctrack.load_session_baselines(d))
+    assert cctrack.aggregate_hook_data(events)["2026-10-12"]["cost"] == pytest.approx(5.0)
+def test_codex_homes_dedup_by_real_path(fake_host, monkeypatch):
+    """If CODEX_HOME points into a sandbox, that home isn't read twice."""
+    monkeypatch.setenv("CODEX_HOME", str(fake_host / ".sandy/sandboxes/web/codex"))
+    homes = [h.resolve() for h in cctrack.codex_homes()]
+    assert len(homes) == len(set(homes))
+def test_sandbox_without_codex_is_fine(fake_host):
+    shutil.rmtree(fake_host / ".sandy/sandboxes/my box/codex")
+    events, _ = cctrack.parse_codex_events(cctrack.discover_codex_files())
+    assert sorted(e["session_id"] for e in events) == ["dotfiles", "host", "web"]
+# ── Remote discovery ────────────────────────────────────────────────────
+def _remote_out(state: str, glob_lines: list[str],
+                dot_lines: list[str] = ()) -> subprocess.CompletedProcess:
+    out = (f"{state}\n{cctrack._STATE_END}\n" + "\n".join(glob_lines) + "\n"
+           f"{cctrack._STATE_END}\n" + "\n".join(dot_lines) + "\n")
+    return subprocess.CompletedProcess(["ssh"], 0, stdout=out, stderr="")
+def test_remote_roots_prefer_print_state():
+    state = json.dumps({"sandboxes": [{"path": "/h/.sandy/sandboxes/a"},
+                                      {"path": "/h/.sandy/sandboxes/.rsync-from.a.9"}]})
+    with patch("subprocess.run", return_value=_remote_out(state, ["/h/.sandy/sandboxes/zzz/"])):
+        assert cctrack.remote_sandbox_roots("h") == ["/h/.sandy/sandboxes/a"]
+def test_remote_roots_glob_fallback_and_cache():
+    out = _remote_out("", ["/h/.sandy/sandboxes/a/", "/h/.sandy/sandboxes/b c/"])
+    with patch("subprocess.run", return_value=out) as run:
+        assert cctrack.remote_sandbox_roots("h") == ["/h/.sandy/sandboxes/a",
+                                                     "/h/.sandy/sandboxes/b c"]
+        cctrack.remote_sandbox_roots("h")
+        assert run.call_count == 1          # one SSH round trip per host
+def test_remote_roots_add_dot_named_sandboxes():
+    """Dot-dirs the remote confirmed hold WORKSPACE.json are added, except
+    rsync copies and locks."""
+    state = json.dumps({"sandboxes": [{"path": "/h/.sandy/sandboxes/a"}]})
+    dots = ["/h/.sandy/sandboxes/.dotfiles-1a2b3c4d/",
+            "/h/.sandy/sandboxes/.rsync-from.a.9/",
+            "/h/.sandy/sandboxes/..dotfiles-1a2b3c4d.lock/",
+            "/h/.sandy/sandboxes/./"]
+    with patch("subprocess.run", return_value=_remote_out(state, [], dots)):
+        assert cctrack.remote_sandbox_roots("h") == ["/h/.sandy/sandboxes/.dotfiles-1a2b3c4d",
+                                                     "/h/.sandy/sandboxes/a"]
+def test_remote_roots_unreachable_host():
+    with patch("subprocess.run", side_effect=subprocess.TimeoutExpired("ssh", 60)):
+        assert cctrack.remote_sandbox_roots("h") == []
+@pytest.mark.skipif(not shutil.which("bash") or not shutil.which("find"),
+                    reason="needs bash and find")
+def test_remote_commands_run_in_a_real_shell(fake_host):
+    """End-to-end: the exact remote commands, executed by a real shell against
+    the fake host (ssh swapped for local bash), find every sandbox — including
+    one whose name has a space — and skip the rsync copy and non-transcripts."""
+    real_run = subprocess.run
+    def via_bash(cmd, **kw):
+        if cmd and cmd[0] == "ssh":
+            env = {**os.environ, "HOME": str(fake_host)}
+            env.pop("SANDY_HOME", None)
+            env.pop("CODEX_HOME", None)
+            # no `sandy` on this PATH, so the glob fallback is exercised
+            env["PATH"] = "/usr/bin:/bin"
+            return real_run(["bash", "-c", cmd[-1]], **{**kw, "env": env})
+        return real_run(cmd, **kw)
+    with patch("subprocess.run", side_effect=via_bash), patch("sys.stderr"):
+        roots = cctrack.remote_sandbox_roots("fake")
+        codex = cctrack.parse_remote_codex_events("fake")
+        claude = cctrack.parse_remote_events("fake")
+        rows, _, _ = cctrack.parse_remote_hook_data("fake")
+    assert [r.rsplit("/", 1)[-1] for r in roots] == ROOT_NAMES
+    assert sorted(e["session_id"] for e in codex) == CODEX_THREADS
+    assert _cost(codex) == pytest.approx(CODEX_EXPECTED)
+    assert [e["_request_id"] for e in claude] == ["req-web"]
+    hook = cctrack.aggregate_hook_data(cctrack.compute_hook_deltas(rows))
+    assert hook["2026-10-12"]["cost"] == pytest.approx(5.0)