haid 0.0.1__tar.gz

haid-0.0.1/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: haid
+Version: 0.0.1
+Summary: How Am I Doing — local-only self-audit & coaching for Claude Code sessions
+Author-email: dv-hart <jhart@datavine.us>
+License: MIT
+Project-URL: Homepage, https://github.com/dv-hart/haid
+Project-URL: Repository, https://github.com/dv-hart/haid
+Project-URL: Issues, https://github.com/dv-hart/haid/issues
+Keywords: claude-code,self-audit,coaching,llm,agent,telemetry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# How Am I Doing (HAID)
+
+*A self-audit and coaching layer for Claude Code sessions.*
+
+HAID reads your own Claude Code session transcripts, builds a graph of what
+happened, and produces annotated, **coaching-oriented** reports. The aim is less
+"here is your bill" and more "here is where you and the agent diverged, why, and
+what to change."
+
+**Nothing leaves your machine** unless you explicitly choose to submit aggregate
+metrics.
+
+> Status: **Phase 1 complete; the full scoring stack now runs on real sessions** — the
+> deterministic pipeline runs end to end on real transcripts (163 tests, stdlib-only, no model
+> in the loop):
+> - **Session parsing** (`src/haid/session/`) — forest-aware JSONL parsing: dedup,
+>   branch/rewind classification, subagent stitching, overflow resolution, SQLite cache.
+> - **Session graph** (`src/haid/graph/`) — L0 spine + L1 action/IO graph
+>   (reads/produces/edits from `structuredPatch`), signatures, per-timeline scoping.
+> - **Waste metrics** (`src/haid/metrics/`) — `rereads`, `retries`, `retouched`,
+>   `unused_context`: one rule each, run at **session and window scope**, as benchmarkable
+>   token-rates placed against a per-scope baseline.
+> - **Analysis window** (`src/haid/window.py`) — the multi-session unit metrics run over
+>   (a project over a timeframe, default 30 days).
+> - **Scoring** (`src/haid/scoring/`) — the relative achievement/cost value scorer
+>   (difficulty + cleanliness placement, volume, normalized-token cost, value combiner),
+>   calibration-validated. Built ahead of the earlier phases.
+>
+> - **`haid metrics`** (`src/haid/metrics/{json_out,view}.py` + CLI) — the measured substrate:
+>   four waste metrics at **session and window scope**, each placed against a per-scope
+>   baseline, as a Markdown inspection view + a JSON hand-off to the later "why" passes.
+> - **Bridge** (`src/haid/bridge/`) — reconstructs an analysis window's net code diff from the
+>   **transcript alone** (replay, no git) plus its normalized-token cost, so `haid bridge` and
+>   `haid value --project/--session` now run the **full scoring stack on real sessions**
+>   (previously the scorer only ran on supplied/calibration diffs).
+>
+> All validated on real transcripts (163 tests). The user-facing **report and visualization are
+> the final product**, composing this substrate with the Phase-2/3 why-analysis and the value
+> score. Next: the diagnosis router, episode segmentation (Phase 2), and the visualization
+> (Phase 1.5). See [plans/roadmap.md](plans/roadmap.md) and [plans/phase1-build.md](plans/phase1-build.md).
+
+## What this is not
+
+Not another token counter. Raw usage accounting is already well covered
+([ccusage](https://github.com/ryoppippi/ccusage) and similar). The entire value
+lives one layer up, in **diagnosis and coaching** — telling you not what you
+spent but how to get better. A tool that confidently misdiagnoses is worse than
+nothing, because people act on it, so trustworthiness of the diagnosis is the
+central design constraint throughout. See
+[docs/trust-discipline.md](docs/trust-discipline.md).
+
+## The one big idea: the session graph
+
+Underneath everything is one data structure: a graph of the session(s). Turns
+and tool-calls are nodes; edges capture *responds-to*, *reads*, and *produces*
+relationships. The two headline features are just two operations on this one
+graph:
+
+- **"Why did you do X?"** → a backwards traversal from X to its trigger.
+- **"Where did the tokens go?"** → a weighting over the same nodes.
+
+Build the graph once; get both views from it. Design in
+[docs/session-graph-design.md](docs/session-graph-design.md).
+
+## Two orthogonal analysis passes
+
+1. **User-anchored pass** — catches *misalignment*. Works backwards from user
+   messages; **corrections are ground truth** ("no, I meant…", "that's wrong").
+2. **Signature-scanning pass** — catches *silent inefficiency*. Scans for
+   objective, reasoning-free waste signatures (redundant re-reads, retry loops,
+   re-touched lines, unused context).
+
+The two are orthogonal: one finds where the agent did the *wrong thing*, the
+other where it did the *right thing wastefully*. See
+[docs/architecture.md](docs/architecture.md).
+
+## Documentation map
+
+| Doc | What's in it |
+|-----|--------------|
+| [docs/vision.md](docs/vision.md) | The full concept, goals, and the canonical test case |
+| [docs/architecture.md](docs/architecture.md) | The two-pass method and how the pieces fit |
+| [docs/session-graph-design.md](docs/session-graph-design.md) | Node/edge taxonomy, episodes, the two core operations |
+| [docs/detectors.md](docs/detectors.md) | Detector catalog + waste metrics as graph queries |
+| [docs/intent-taxonomy.md](docs/intent-taxonomy.md) | Two-axis message classification + purpose timeline + drift |
+| [docs/scoring-rubric.md](docs/scoring-rubric.md) | Achievement vs. cost — the **relative** value verdict (revised; see ladder/playbook) |
+| [docs/difficulty-ladder.md](docs/difficulty-ladder.md) | The validated difficulty scorer (reference ladder + placement) |
+| [docs/cleanliness-ladder.md](docs/cleanliness-ladder.md) | The cleanliness/parsimony scorer (reference ladder + placement) |
+| [docs/axis-calibration-playbook.md](docs/axis-calibration-playbook.md) | Self-contained recipe to calibrate a new scoring axis (worked example: cleanliness; originality calibrated then dropped) |
+| [docs/calibration-pilot-1.md](docs/calibration-pilot-1.md) | Pilot report: why mined review-signals don't validate difficulty |
+| [docs/visualization.md](docs/visualization.md) | The time-layered bus diagram (left-in/right-out, bundled) |
+| [docs/claude-code-data-format.md](docs/claude-code-data-format.md) | **Verified** Claude Code on-disk data reference |
+| [docs/data-inventory.md](docs/data-inventory.md) | Field catalog from 38 real sessions: what's auto-taggable vs. inferred |
+| [docs/data-structure-report.md](docs/data-structure-report.md) | Real annotated records → the graph they produce (Tier 1 & Tier 2 walkthrough) |
+| [docs/trust-discipline.md](docs/trust-discipline.md) | Cite-or-unknown, hedging, no-traceable-origin |
+| [docs/tooling-landscape.md](docs/tooling-landscape.md) | Existing tools and what to build on |
+| [docs/decisions/](docs/decisions/) | Architecture Decision Records (ADRs) |
+| [plans/roadmap.md](plans/roadmap.md) | Phased delivery plan |
+| [plans/mvp.md](plans/mvp.md) | The minimum thing that tests the core risk |
+| [plans/phase1-build.md](plans/phase1-build.md) | The concrete Phase-1 build sequence + progress |
+| [plans/open-questions.md](plans/open-questions.md) | Decisions to make / behaviors to verify early |
+
+## Repository layout
+
+```
+HAID/
+├── README.md                 # you are here
+├── docs/                     # design & reference documentation
+│   └── decisions/            # ADRs
+├── plans/                    # roadmap, MVP spec, open questions
+├── research/                 # raw research reports (inputs to the docs)
+├── calibration/              # the scoring-axis calibration harness (experiment code)
+├── src/haid/                 # implementation
+│   ├── session/              #   Phase-1 parse: forest model, subagents, overflow, cache
+│   ├── graph/                #   L0 spine + L1 IO graph (incl. Bash read/write parsing)
+│   ├── metrics/              #   the four waste metrics + baseline + `haid metrics` emitter
+│   ├── window.py             #   the multi-session analysis window
+│   ├── scoring/              #   relative value scorer (difficulty/cleanliness/volume/cost/value)
+│   └── bridge/               #   transcript→(diff, usage) reconstruction (the bridge)
+├── tests/                    # session/ graph/ metrics/ scoring/ bridge/ suites (+ fixtures/)
+└── scripts/                  # build_metric_baselines.py + CLI helpers
+```

haid-0.0.1/README.md

@@ -0,0 +1,122 @@
+# How Am I Doing (HAID)
+
+*A self-audit and coaching layer for Claude Code sessions.*
+
+HAID reads your own Claude Code session transcripts, builds a graph of what
+happened, and produces annotated, **coaching-oriented** reports. The aim is less
+"here is your bill" and more "here is where you and the agent diverged, why, and
+what to change."
+
+**Nothing leaves your machine** unless you explicitly choose to submit aggregate
+metrics.
+
+> Status: **Phase 1 complete; the full scoring stack now runs on real sessions** — the
+> deterministic pipeline runs end to end on real transcripts (163 tests, stdlib-only, no model
+> in the loop):
+> - **Session parsing** (`src/haid/session/`) — forest-aware JSONL parsing: dedup,
+>   branch/rewind classification, subagent stitching, overflow resolution, SQLite cache.
+> - **Session graph** (`src/haid/graph/`) — L0 spine + L1 action/IO graph
+>   (reads/produces/edits from `structuredPatch`), signatures, per-timeline scoping.
+> - **Waste metrics** (`src/haid/metrics/`) — `rereads`, `retries`, `retouched`,
+>   `unused_context`: one rule each, run at **session and window scope**, as benchmarkable
+>   token-rates placed against a per-scope baseline.
+> - **Analysis window** (`src/haid/window.py`) — the multi-session unit metrics run over
+>   (a project over a timeframe, default 30 days).
+> - **Scoring** (`src/haid/scoring/`) — the relative achievement/cost value scorer
+>   (difficulty + cleanliness placement, volume, normalized-token cost, value combiner),
+>   calibration-validated. Built ahead of the earlier phases.
+>
+> - **`haid metrics`** (`src/haid/metrics/{json_out,view}.py` + CLI) — the measured substrate:
+>   four waste metrics at **session and window scope**, each placed against a per-scope
+>   baseline, as a Markdown inspection view + a JSON hand-off to the later "why" passes.
+> - **Bridge** (`src/haid/bridge/`) — reconstructs an analysis window's net code diff from the
+>   **transcript alone** (replay, no git) plus its normalized-token cost, so `haid bridge` and
+>   `haid value --project/--session` now run the **full scoring stack on real sessions**
+>   (previously the scorer only ran on supplied/calibration diffs).
+>
+> All validated on real transcripts (163 tests). The user-facing **report and visualization are
+> the final product**, composing this substrate with the Phase-2/3 why-analysis and the value
+> score. Next: the diagnosis router, episode segmentation (Phase 2), and the visualization
+> (Phase 1.5). See [plans/roadmap.md](plans/roadmap.md) and [plans/phase1-build.md](plans/phase1-build.md).
+
+## What this is not
+
+Not another token counter. Raw usage accounting is already well covered
+([ccusage](https://github.com/ryoppippi/ccusage) and similar). The entire value
+lives one layer up, in **diagnosis and coaching** — telling you not what you
+spent but how to get better. A tool that confidently misdiagnoses is worse than
+nothing, because people act on it, so trustworthiness of the diagnosis is the
+central design constraint throughout. See
+[docs/trust-discipline.md](docs/trust-discipline.md).
+
+## The one big idea: the session graph
+
+Underneath everything is one data structure: a graph of the session(s). Turns
+and tool-calls are nodes; edges capture *responds-to*, *reads*, and *produces*
+relationships. The two headline features are just two operations on this one
+graph:
+
+- **"Why did you do X?"** → a backwards traversal from X to its trigger.
+- **"Where did the tokens go?"** → a weighting over the same nodes.
+
+Build the graph once; get both views from it. Design in
+[docs/session-graph-design.md](docs/session-graph-design.md).
+
+## Two orthogonal analysis passes
+
+1. **User-anchored pass** — catches *misalignment*. Works backwards from user
+   messages; **corrections are ground truth** ("no, I meant…", "that's wrong").
+2. **Signature-scanning pass** — catches *silent inefficiency*. Scans for
+   objective, reasoning-free waste signatures (redundant re-reads, retry loops,
+   re-touched lines, unused context).
+
+The two are orthogonal: one finds where the agent did the *wrong thing*, the
+other where it did the *right thing wastefully*. See
+[docs/architecture.md](docs/architecture.md).
+
+## Documentation map
+
+| Doc | What's in it |
+|-----|--------------|
+| [docs/vision.md](docs/vision.md) | The full concept, goals, and the canonical test case |
+| [docs/architecture.md](docs/architecture.md) | The two-pass method and how the pieces fit |
+| [docs/session-graph-design.md](docs/session-graph-design.md) | Node/edge taxonomy, episodes, the two core operations |
+| [docs/detectors.md](docs/detectors.md) | Detector catalog + waste metrics as graph queries |
+| [docs/intent-taxonomy.md](docs/intent-taxonomy.md) | Two-axis message classification + purpose timeline + drift |
+| [docs/scoring-rubric.md](docs/scoring-rubric.md) | Achievement vs. cost — the **relative** value verdict (revised; see ladder/playbook) |
+| [docs/difficulty-ladder.md](docs/difficulty-ladder.md) | The validated difficulty scorer (reference ladder + placement) |
+| [docs/cleanliness-ladder.md](docs/cleanliness-ladder.md) | The cleanliness/parsimony scorer (reference ladder + placement) |
+| [docs/axis-calibration-playbook.md](docs/axis-calibration-playbook.md) | Self-contained recipe to calibrate a new scoring axis (worked example: cleanliness; originality calibrated then dropped) |
+| [docs/calibration-pilot-1.md](docs/calibration-pilot-1.md) | Pilot report: why mined review-signals don't validate difficulty |
+| [docs/visualization.md](docs/visualization.md) | The time-layered bus diagram (left-in/right-out, bundled) |
+| [docs/claude-code-data-format.md](docs/claude-code-data-format.md) | **Verified** Claude Code on-disk data reference |
+| [docs/data-inventory.md](docs/data-inventory.md) | Field catalog from 38 real sessions: what's auto-taggable vs. inferred |
+| [docs/data-structure-report.md](docs/data-structure-report.md) | Real annotated records → the graph they produce (Tier 1 & Tier 2 walkthrough) |
+| [docs/trust-discipline.md](docs/trust-discipline.md) | Cite-or-unknown, hedging, no-traceable-origin |
+| [docs/tooling-landscape.md](docs/tooling-landscape.md) | Existing tools and what to build on |
+| [docs/decisions/](docs/decisions/) | Architecture Decision Records (ADRs) |
+| [plans/roadmap.md](plans/roadmap.md) | Phased delivery plan |
+| [plans/mvp.md](plans/mvp.md) | The minimum thing that tests the core risk |
+| [plans/phase1-build.md](plans/phase1-build.md) | The concrete Phase-1 build sequence + progress |
+| [plans/open-questions.md](plans/open-questions.md) | Decisions to make / behaviors to verify early |
+
+## Repository layout
+
+```
+HAID/
+├── README.md                 # you are here
+├── docs/                     # design & reference documentation
+│   └── decisions/            # ADRs
+├── plans/                    # roadmap, MVP spec, open questions
+├── research/                 # raw research reports (inputs to the docs)
+├── calibration/              # the scoring-axis calibration harness (experiment code)
+├── src/haid/                 # implementation
+│   ├── session/              #   Phase-1 parse: forest model, subagents, overflow, cache
+│   ├── graph/                #   L0 spine + L1 IO graph (incl. Bash read/write parsing)
+│   ├── metrics/              #   the four waste metrics + baseline + `haid metrics` emitter
+│   ├── window.py             #   the multi-session analysis window
+│   ├── scoring/              #   relative value scorer (difficulty/cleanliness/volume/cost/value)
+│   └── bridge/               #   transcript→(diff, usage) reconstruction (the bridge)
+├── tests/                    # session/ graph/ metrics/ scoring/ bridge/ suites (+ fixtures/)
+└── scripts/                  # build_metric_baselines.py + CLI helpers
+```

haid-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "haid"
+version = "0.0.1"
+description = "How Am I Doing — local-only self-audit & coaching for Claude Code sessions"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "dv-hart", email = "jhart@datavine.us" }]
+keywords = ["claude-code", "self-audit", "coaching", "llm", "agent", "telemetry"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = []  # stdlib only — model judgment is delegated to the host agent (see scoring/compare.py)
+
+[project.urls]
+Homepage = "https://github.com/dv-hart/haid"
+Repository = "https://github.com/dv-hart/haid"
+Issues = "https://github.com/dv-hart/haid/issues"
+
+[project.scripts]
+haid = "haid.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+haid = ["data/*.json", "data/anchor_diffs/*.diff"]

haid-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

haid-0.0.1/src/haid/__init__.py

@@ -0,0 +1,9 @@
+"""HAID — "How Am I Doing": local-only self-audit & coaching for Claude Code sessions.
+
+This package is the product code (stdlib only). The scoring subpackage places a session
+diff against fixed reference ladders to produce relative achievement scores; the model
+judgment those placements need is delegated to the host agent (Claude Code subagents),
+never an in-process API call — see haid.scoring.compare.
+"""
+
+__version__ = "0.0.1"

haid-0.0.1/src/haid/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

haid-0.0.1/src/haid/bridge/__init__.py

@@ -0,0 +1,172 @@
+"""The bridge: window → (diff, usage) — the join between the real-session pipeline and the
+scoring stack.
+
+The scorer (volume / difficulty / cleanliness / value) was built and validated against
+calibration diffs; the session pipeline (session → graph → metrics) ingests real transcripts.
+This package connects them: given an analysis window it produces the two inputs the scorer
+needs — a reconstructed unified **diff** and a normalized-token **cost** — so `haid value` runs
+on real work.
+
+Design (recorded in the project notes, decided after measuring the gap):
+  - **Replay-primary, no git.** The diff is reconstructed from the transcript (see
+    `reconstruct`). The bash-write-to-source gap was measured at ~0–1% on real projects; what
+    little it misses is detected and FLAGGED, never silently dropped.
+  - **Grain-agnostic core.** `window_inputs` slices the whole window; the same engine will slice
+    by episode once episodes exist (Phase 2 — episode↔PR alignment is explicitly TBD, not v1).
+
+Stdlib only; no model.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from .reconstruct import FileRecon, ReconResult, reconstruct
+from .usage import extract_cost
+
+__all__ = ["BridgeResult", "window_inputs", "episode_inputs", "reconstruct", "extract_cost",
+           "FileRecon", "ReconResult"]
+
+_ABS = re.compile(r"^(?:/|[A-Za-z]:[\\/]|\\\\)")   # posix root, drive letter, or UNC
+
+
+def _is_external(file_id: str) -> bool:
+    """A file id that isn't repo-relative — temp files, other repos, /etc — is not part of the
+    project work product and must not enter the scored diff. (build.py makes ids repo-relative
+    only when the path is under the session cwd; everything else stays absolute.)"""
+    return bool(_ABS.match(file_id))
+
+
+@dataclass
+class BridgeResult:
+    diff: str                                    # reconstructed unified diff (scorer input)
+    cost: object                                 # cost.CostResult (scorer denominator)
+    files: list = field(default_factory=list)    # per-file FileRecon (kept for inspection)
+    caveats: list = field(default_factory=list)  # honesty surface — no silent gaps
+
+    def summary(self) -> str:
+        changed = [f for f in self.files if f.changed]
+        incomplete = [f for f in self.files if not f.complete]
+        lines = [f"bridge: {len(changed)} changed file(s) reconstructed, "
+                 f"{len(incomplete)} flagged incomplete",
+                 self.cost.summary()]
+        if self.caveats:
+            lines.append("caveats:")
+            lines.extend(f"  {c}" for c in self.caveats)
+        return "\n".join(lines)
+
+
+def window_inputs(view, sessions) -> BridgeResult:
+    """Build the scorer inputs (diff, cost) for a whole analysis window.
+
+    `view` is a metrics.WindowView (its `active_stream` gives the active-branch tool calls in
+    order); `sessions` are the loaded Session objects (for token usage + edit content).
+    """
+    from ..graph.model import is_write
+
+    tur_by_id = _tur_index(sessions)
+    writes = []
+    excluded = 0
+    for _sid, tc in view.active_stream:
+        if not is_write(tc):
+            continue
+        fid = tc.target_file_id
+        if not fid:
+            continue
+        if _is_external(fid):
+            excluded += 1
+            continue
+        tur = tur_by_id.get(tc.id, {})
+        writes.append((fid, tc.tool, tur, tc.write_op, tc.write_content, tc.derived_write))
+
+    recon = reconstruct(writes, baselines=_baselines(sessions))
+    recon.excluded_external = excluded
+
+    caveats = list(recon.caveats)
+    if excluded:
+        caveats.append(f"{excluded} write(s) to files outside the project tree "
+                       "(temp / other repos) excluded from the diff")
+    subagent_writes = _subagent_write_count(sessions)
+    if subagent_writes:
+        caveats.append(f"{subagent_writes} subagent file-write call(s) are not yet folded into "
+                       "the diff (subagent edit stitching is deferred)")
+
+    return BridgeResult(diff=recon.diff, cost=extract_cost(sessions),
+                        files=recon.files, caveats=caveats)
+
+
+def episode_inputs(episode_sessions) -> BridgeResult:
+    """Build the scorer inputs (diff, cost) for ONE episode = its subset of whole sessions.
+
+    Because an episode is a set of *whole sessions* (grain decision 2026-06-08), this is just
+    `window_inputs` over that subset — no new slicing engine. Two things fall out for free:
+      - **episode-relative diff baseline**: `_baselines` takes the earliest captured `originalFile`
+        across these sessions only, which is each file's state as it ENTERED the episode (i.e.
+        after any earlier episodes touched it), so the diff is the episode's own delta;
+      - **clean cost**: `extract_cost` sums these sessions' per-context-window costs — no entangled
+        sub-session token split (the whole reason the session is the atomic floor).
+    """
+    from ..window import build_view
+    sub_view = build_view(episode_sessions)
+    return window_inputs(sub_view, episode_sessions)
+
+
+def _tur_index(sessions) -> dict:
+    """tool_use id -> toolUseResult dict, across main + subagent records of every session.
+
+    Pairing key is the tool_use_id inside the result's tool_result block (verified on real
+    data — there is no top-level sourceToolUseID)."""
+    out: dict[str, dict] = {}
+    for s in sessions:
+        recs = list(s.parse.records) + [r for sa in s.subagents for r in sa.parse.records]
+        for r in recs:
+            tur = r.raw.get("toolUseResult")
+            if not isinstance(tur, dict):
+                continue
+            c = r.content
+            if not isinstance(c, list):
+                continue
+            for b in c:
+                if isinstance(b, dict) and b.get("type") == "tool_result" and b.get("tool_use_id"):
+                    out[b["tool_use_id"]] = tur
+                    break
+    return out
+
+
+def _baselines(sessions) -> dict:
+    """file_id -> the file's content as it ENTERED the window: the earliest captured
+    `originalFile` for that file across all records (any branch, main + subagents).
+
+    Claude Code omits originalFile on some edits (e.g. large files), so the first edit we see
+    in the active stream may lack it even though an earlier touch captured it. Sourcing the
+    earliest one window-wide gives buffer-mode reconstruction a correct seed; files that never
+    captured it fall back to hunks mode in reconstruct()."""
+    from ..graph.build import _file_id
+
+    by_first_ts = sorted(sessions, key=lambda s: min(
+        (r.timestamp for r in s.parse.records if r.timestamp), default=""))
+    out: dict[str, str] = {}
+    for s in by_first_ts:
+        cwd = next((r.raw.get("cwd") for r in s.parse.records if r.raw.get("cwd")), None)
+        for r in list(s.parse.records) + [rr for sa in s.subagents for rr in sa.parse.records]:
+            tur = r.raw.get("toolUseResult")
+            if not isinstance(tur, dict) or tur.get("originalFile") is None:
+                continue
+            path = tur.get("filePath") or (tur.get("file") or {}).get("filePath")
+            fid = _file_id(path, cwd)
+            if fid and fid not in out:
+                out[fid] = tur["originalFile"]
+    return out
+
+
+def _subagent_write_count(sessions) -> int:
+    from ..graph.model import is_write
+    from ..graph.build import build_graph
+    n = 0
+    for s in sessions:
+        for sa in s.subagents:
+            g = build_graph(sa.parse.records)
+            n += sum(1 for tc in g.toolcalls.values()
+                     if is_write(tc) and tc.target_file_id and not _is_external(tc.target_file_id))
+    return n