@surlymochan/evalid 0.4.1 → 0.5.1

package/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project are documented here. Detailed notes live in
 
 ## [Unreleased]
 
+## [0.5.1] - 2026-11-07
+
+### Added
+- **Per-process read cache for the review gates (issue #5, P1-2 follow-up to #34)**: one gate run used to read the same source file several times — I6c for symbols, implementation sources and test review, J6 for spec alignment and then test follow once per changed code file. Both gates now read through a per-process cache keyed by the P1-3 stat anchor (size, mtime_ns, inode): each unchanged file is read from disk once per run and served from memory on later reads, while a changed file is re-read instead of served stale (a mid-read change is retried once, like the seal's `read_with_anchor`). J6 keeps its self-contained copy of the cache and does not import tdd_lib. Both proofs report `read_cache` (`disk_reads` / `cache_hits`) so the skipped re-reads are observable. No verdict logic changed; the token acceptance still needs a benchmark-environment rerun — no performance numbers are claimed here.
+- **Stat-anchored gate verification (issue #5, P1-3)**: the TDD seal now records a stat anchor (size, mtime_ns, inode) per sealed file alongside its sha256 — tree anchors and snapshot-copy anchors in the proof's snapshot scope, bound into the proof like the scope itself. Proof validation (I6b) and the CR review seal partition (J6) stat-check first and re-read + re-hash only files whose anchor moved, instead of re-reading every sealed file on every gate pass; proofs sealed before the anchors existed fall back to the full re-read. Validation reports `reread_files` / `reread_count` and the seal partition reports `stat_checked`, so the skipped re-reads are observable. The token acceptance (median tokens incl. cache ≤ 2.0M) still needs a benchmark-environment rerun — no performance numbers are claimed here.
+
+### Changed
+- **Bench harness runs all four SWE-bench arms at high thinking effort**: `run_pi()` in `bench/swebench/harness/arms.py` and `bench/swebench/harness/pi_shim.sh` now set `--effort high` at both pi call sites, so the workflow remains the only variable across arms. The archived DeepSeek tables were recorded with the settings of their time and are not affected.
+
+## [0.5.0] - 2026-11-06
+
+### Added
+- **CR review seal partition (issue #5, P1-2)**: the J6 review proof (`cr/review-0.json`) now splits the changed files into `sealed_unchanged` (bytes still identical to the green TDD proof's sealed hashes) and `seal_drifted`, with a `reread_count`. The yolo skill's verify-consistency guidance uses the partition so the review pass re-reads only drifted files instead of everything the gate already verified. Reporting only — verdicts are unchanged, and without a green seal the partition is `null` and everything is re-read.
+- **Bench Verified set extended to 15 instances (issue #5, P2-2)**: `bench/swebench/instances.json` grows from 12 to 15, adding sympy-15599, sympy-19040 and sympy-24213, and a structural validation of the instance set (`bench/swebench/test_instances.py`) now runs in CI. Gold-patch checks for the three new instances stay pending the benchmark environment.
+- **Bench report aggregates median (IQR) (issue #5, P2-1)**: `bench/swebench/report.py` now aggregates per-arm wall-clock, token and cost results with q1/median/q3 and presents them as median (IQR); reps isolation and the aggregation itself are pinned by `bench/swebench/test_reps_report.py`. Live multi-rep runs stay pending the benchmark environment.
+- **P0-2 acceptance pinned against saved pre-fix patches (issue #5, P0-2)**: regression tests in `bench/swebench/test_diff_filter.py` run the saved pre-fix patches through the evidence filter (`specs/`, `.xflow/`, `.as-xflow/` excluded from solution patches). The saved 9.7 MB evidence-laden patch filters down to 4.3 KB, and every saved patch lands under the 200 KB acceptance line.
+
 ## [0.4.1] - 2026-11-06
 
 ### Fixed

package/RELEASE_NOTES.md

@@ -1,5 +1,31 @@
 # Release Notes
 
+## 0.5.1 - Gates stop re-reading unchanged files; bench arms run at high effort
+
+Patch release. Two gate cost improvements from the issue #5 backlog, both pinned by tests rather than by a live run, plus a bench-harness change.
+
+**Stat-anchored gate verification (#34, issue #5 P1-3).** The TDD seal now records a stat anchor (size, mtime_ns, inode) per sealed file alongside its sha256. Proof validation (I6b) and the CR review seal partition (J6) stat-check first and re-read + re-hash only files whose anchor moved, instead of re-reading every sealed file on every gate pass; proofs sealed before the anchors existed fall back to the full re-read. Validation reports `reread_files` / `reread_count` and the seal partition reports `stat_checked`, so the skipped re-reads are observable. Test evidence (local): `test/tdd-proof.test.js` 22/22 — 4 new, including unchanged tree validating with `reread_count` 0 and anchor-less proofs still verifying by full re-read; `test/cr-review.test.js` 14/14 — 2 new, including anchors accepting unchanged files (`stat_checked` 2) and an edited file re-read and drifted (`stat_checked` 1, `reread_count` 1).
+
+**Per-process read cache for the review gates (#35, issue #5 P1-2 follow-up).** Both gates now read through a per-process cache keyed by the P1-3 stat anchor: each unchanged file is read from disk once per run and served from memory on later reads, while a changed file is re-read instead of served stale (a mid-read change is retried once). This removes the repeated re-reads inside one gate run — I6c reading the same source file for symbols, implementation sources and test review, and J6's test follow re-reading every test file once per changed code file. Both proofs report `read_cache` (`disk_reads` / `cache_hits`). No verdict logic changed. Test evidence (local): `test/tdd-proof.test.js` 24/24 — 2 new, including a cache unit test (3 reads → 1 disk read + 2 hits) and the quality-review proof reporting `read_cache` {disk_reads: 2, cache_hits: 2}; `test/cr-review.test.js` 16/16 — 2 new, including one gate run reading each unchanged file from disk once ({disk_reads: 3, cache_hits: 1}) and a test file shared by two code files read from disk once ({disk_reads: 4, cache_hits: 3}).
+
+**Bench arms run at high thinking effort (#36).** Both pi call sites in the SWE-bench harness (`harness/arms.py` `run_pi()` and `harness/pi_shim.sh`) now set `--effort high`, so all four arms run MiniMax at the same high thinking effort and the workflow remains the only variable. The archived DeepSeek tables were recorded with the settings of their time and are not affected.
+
+Acceptance debt, stated plainly: the live-run acceptance for P1-2 and P1-3 — the wall-clock/token lines from issue #5, including median tokens incl. cache ≤ 2.0M — is still pending the benchmark environment, which is being rebuilt. No bench numbers are claimed in this release; what shipped is the mechanism and the tests that pin its behaviour.
+
+## 0.5.0 - Review re-reads only drifted files; the bench set grows to 15
+
+Minor release. One product change — the CR review now spends its re-reads only where the seal says bytes moved — plus three bench-hygiene landings from the issue #5 backlog, each pinned by tests rather than by a live run.
+
+**Review re-reads only drifted files (#32, issue #5 P1-2).** The J6 review proof (`cr/review-0.json`) now carries a seal partition: every changed file is classified `sealed_unchanged` (bytes still identical to the green TDD proof's sealed hashes) or `seal_drifted`, with a `reread_count`. The yolo verify-consistency guidance consumes the partition, so the review pass re-reads only the drifted files instead of everything the gate already verified. This is reporting only — verdicts are unchanged, and without a green seal the partition is `null` and everything is re-read, exactly as before.
+
+**The Verified bench set grows from 12 to 15 instances (#30, issue #5 P2-2).** `bench/swebench/instances.json` adds sympy-15599, sympy-19040 and sympy-24213, and a structural validation of the instance set (`bench/swebench/test_instances.py`) now runs in CI, so a malformed instance entry fails the build instead of a bench run. Gold-patch checks for the three new instances are pending the benchmark environment.
+
+**Bench reports now aggregate as median (IQR) (#31, issue #5 P2-1).** `bench/swebench/report.py` aggregates per-arm wall-clock, token and cost results with q1/median/q3 and presents them in median (IQR) form. Reps isolation — repeat runs of the same cell never share grading state — and the aggregation itself are pinned by `bench/swebench/test_reps_report.py`.
+
+**P0-2 acceptance is now pinned by regression tests (#29, issue #5 P0-2).** The evidence exclusion itself landed earlier (solution patches drop `specs/`, `.xflow/` and `.as-xflow/`); what was missing was a test that would notice if it regressed. `bench/swebench/test_diff_filter.py` now runs the saved pre-fix patches through the filter: the saved 9.7 MB evidence-laden patch comes out at 4.3 KB, and every saved patch lands under the 200 KB acceptance line.
+
+Acceptance debt, stated plainly: the live-run acceptance for P1-2, P2-1 and P2-2 — multi-rep bench runs on the restored environment, including the wall-clock/token lines from issue #5 and gold checks for the new instances — is still pending the benchmark environment. No performance numbers are claimed in this release; what shipped is the reporting, the larger instance set, and the tests that pin their behaviour.
+
 ## 0.4.1 - Failed runs report phase costs; Node 24 test counts fail closed
 
 Patch release. Two fixes, both about the gate trusting evidence it had not actually read.

package/docs/launch-dossier.md

@@ -1,6 +1,6 @@
 # evalid Launch Dossier
 
-Generated: 2026-11-05T17:36:26.724Z
+Generated: 2026-11-06T19:58:36.504Z
 Mode: post_publish
 Verdict: conditionally ready: engine and adoption evidence are strong, registry publication remains required for a splash launch
 Launch ready: not yet
@@ -117,7 +117,7 @@ Evidence:
 - Adoption records: 1; status: pass
 - Goal audit: pass; goal: Keep evalid credible as an open-source agent delivery runtime: repo-owned workflow contracts, executable verification gates, durable project context, and honest benchmark evidence.
 - Package evidence: missing; source: registry_json
-- Package name/version: @surlymochan/evalid@0.4.1
+- Package name/version: @surlymochan/evalid@0.5.1
 
 ## Passing Evidence
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surlymochan/evalid",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Claimed != verified: a runtime verification layer for coding agents. It seals each test run and replays it from a clean snapshot, with a zero-judge gate pipeline (spec clarification, code review, TDD proof) and the xflow CLI.",
   "keywords": [
     "ai-agents",

package/xflow/atoms/i6b_tdd_proof_validate.py

@@ -91,11 +91,22 @@ def main():
         emit({'ok': False, 'verdict': 'proof_inconsistent', 'phase': args.phase}, 1)
 
     destination = tdd_lib.snapshot_dir(project, args.change_id, args.phase, args.attempt)
-    found = tdd_lib.snapshot_tree_hashes(destination)
-    if found is None or found != proof.get('file_hashes'):
-        emit({'ok': False, 'verdict': 'snapshot_mismatch', 'phase': args.phase}, 1)
-
     scope = proof.get('snapshot_scope')
+    copy_stats = scope.get('copy_stats') if isinstance(scope, dict) else None
+    reread_files: set[str] = set()
+    if isinstance(copy_stats, dict) and copy_stats:
+        # Stat-anchored check (issue #5, P1-3): the seal already hashed
+        # these bytes, so only copies whose stat moved are re-read.
+        checked = tdd_lib.verify_hashes_by_stat(destination, proof.get('file_hashes'), copy_stats)
+        reread_files.update(checked['reread'])
+        if checked['mismatched']:
+            emit({'ok': False, 'verdict': 'snapshot_mismatch', 'phase': args.phase, 'files': checked['mismatched']}, 1)
+    else:
+        found = tdd_lib.snapshot_tree_hashes(destination)
+        if found is None or found != proof.get('file_hashes'):
+            emit({'ok': False, 'verdict': 'snapshot_mismatch', 'phase': args.phase}, 1)
+        reread_files.update(proof.get('file_hashes', {}).keys())
+
     scoped = isinstance(scope, dict) and bool(proof.get('git_head'))
     try:
         if scoped:
@@ -130,12 +141,21 @@ def main():
 
     if args.phase in {'green', 'refactor', 'run'}:
         mismatched = []
-        for rel, digest in proof.get('file_hashes', {}).items():
-            if not tdd_lib.is_test_file(rel):
-                continue
-            path = project / rel
-            if not path.is_file() or tdd_lib.sha256_bytes(path.read_bytes()) != digest:
-                mismatched.append(rel)
+        test_hashes = {rel: digest for rel, digest in proof.get('file_hashes', {}).items()
+                       if tdd_lib.is_test_file(rel)}
+        file_stats = scope.get('file_stats') if isinstance(scope, dict) else None
+        if isinstance(file_stats, dict) and file_stats:
+            # Stat-anchored check (issue #5, P1-3): sealed test files whose
+            # anchor still matches are accepted without re-reading them.
+            checked = tdd_lib.verify_hashes_by_stat(project, test_hashes, file_stats)
+            reread_files.update(checked['reread'])
+            mismatched = checked['mismatched']
+        else:
+            for rel, digest in test_hashes.items():
+                path = project / rel
+                if not path.is_file() or tdd_lib.sha256_bytes(path.read_bytes()) != digest:
+                    mismatched.append(rel)
+            reread_files.update(test_hashes.keys())
         if scoped:
             # Test files outside the sealed scope were pinned to the recorded
             # HEAD at seal time; any that have drifted since are unsealed edits.
@@ -178,6 +198,8 @@ def main():
         'exit_code': proof['exit_code'],
         'phase': args.phase,
         'tdd_mode': mode,
+        'reread_files': sorted(reread_files),
+        'reread_count': len(reread_files),
     }, 0)
 
 if __name__ == '__main__':

package/xflow/atoms/i6c_tdd_quality_review.py

@@ -11,7 +11,10 @@ tdd_mode red-green (default) requires a failing red proof and a passing
 green proof. tdd_mode refactor instead requires the existing tests that
 touch the changed code to pass on the pre-change tree and the current tree,
 with no assertion lines removed. tdd_mode docs requires the diff to stay on
-non-code paths. A semantically wrong but plausible expected value is not
+non-code paths. File reads go through a per-process cache keyed by the
+P1-3 stat anchor (issue #5, P1-2 follow-up): the same unchanged file is
+read from disk once per run and served from memory on later reads; a
+changed file is re-read. A semantically wrong but plausible expected value is not
 decidable from the diff in general; gate v2 still catches three decidable
 shapes of it: expected values taken from the implementation's own constants
 (the expectation moves when the constant is edited), assertions inside
@@ -66,17 +69,21 @@ def read_json(path: Path) -> dict:
 
 
 def read_text(path: Path) -> str:
-    try:
-        return path.read_text(encoding="utf-8")
-    except OSError:
-        return ""
+    return _read_cache.read_text(path)
+
+
+# One cache per gate run (reset in main): the same source file is read
+# several times in one run — symbols, implementation sources, test
+# review — and the cache serves the repeats from memory while the stat
+# anchor still matches (issue #5, P1-2 follow-up to #34). See
+# tdd_lib.FileReadCache for the invalidation contract.
+_read_cache = tdd_lib.FileReadCache()
 
 
 def review_test_file(project_root: Path, relative_path: str, implementation_sources: list[str] | None = None) -> list[dict]:
     path = project_root / relative_path
-    try:
-        content = path.read_text(encoding="utf-8")
-    except OSError:
+    content = _read_cache.get(path)
+    if content is None:
         return [{"severity": "fail", "code": "test_unreadable", "path": relative_path}]
     findings = []
     for finding in tdd_lib.analyze_test(content, implementation_sources=implementation_sources):
@@ -226,6 +233,8 @@ def refactor_findings(project_root: Path, diff_ref: str, code_files: list[str],
 
 
 def main() -> None:
+    global _read_cache
+    _read_cache = tdd_lib.FileReadCache()
     parser = argparse.ArgumentParser()
     parser.add_argument("--project-root", default=".")
     parser.add_argument("--change-id", required=True)
@@ -344,6 +353,7 @@ def main() -> None:
         "changed_files": files,
         "code_files": code_files,
         "test_files": test_files,
+        "read_cache": _read_cache.stats(),
         "findings": findings,
         "recorded_at": datetime.now(timezone.utc).isoformat(),
     }
@@ -357,6 +367,7 @@ def main() -> None:
         "verdict": verdict,
         "tdd_mode": mode,
         "proof_file": str(proof_file),
+        "read_cache": _read_cache.stats(),
         "failures": sum(1 for finding in findings if finding.get("severity") == "fail"),
         "warnings": sum(1 for finding in findings if finding.get("severity") == "warn"),
         "failed_codes": [

package/xflow/atoms/j6_cr_review.py

@@ -26,16 +26,25 @@ Checks (findings are structured JSON, severity fail | warn):
    (--max-files / --max-lines, or status.json cr_max_files /
    cr_max_lines). Over budget is a warn with a split-the-spec
    recommendation; over 2x budget fails.
+5. Seal partition (reporting only, never a verdict input) - the proof
+   splits the changed files into those still byte-identical to the
+   green TDD seal (file_hashes in tdd/green-0.json) and those that
+   drifted or were never sealed. A review pass re-reads only the
+   drifted set; the sealed set is exactly what the TDD gate verified.
 
 Self-contained on purpose: this atom does not import tdd_lib so it can
 run standalone in a reviewed tree. The file/symbol/assertion semantics
-mirror tdd_lib so verdicts agree with I6c.
+mirror tdd_lib so verdicts agree with I6c. File reads go through a
+per-process cache keyed by the P1-3 stat anchor (issue #5, P1-2
+follow-up): the same unchanged file is read from disk once per run
+and served from memory on later reads; a changed file is re-read.
 
 The proof is written to specs/changes/<change_id>/cr/review-0.json; that
 directory is excluded from the reviewed diff.
 """
 import argparse
 import fnmatch
+import hashlib
 import json
 import os
 import re
@@ -113,10 +122,64 @@ def assertion_count(content: str) -> int:
 
 
 def read_text(path: Path) -> str:
-    try:
-        return path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return ""
+    return _read_cache.read_text(path)
+
+
+class FileReadCache:
+    """Per-process cache of file text, keyed by the stat anchor.
+
+    Local mirror of tdd_lib.FileReadCache (issue #5, P1-2 follow-up to
+    #34) — this atom stays self-contained and does not import tdd_lib.
+    One gate run reads the same source file several times: spec
+    alignment, then test follow (which re-reads every test file once
+    per changed code file). The first read stores the text under the
+    file's stat anchor (size, mtime_ns, inode, the P1-3 identity); a
+    later read whose anchor still matches is served from memory without
+    touching the bytes. Any anchor mismatch re-reads from disk, so the
+    cache can never serve stale content; a mid-read change is retried
+    once, so the stored anchor always describes the stored text.
+    Unreadable files are never cached and never counted as disk reads.
+    `stats()` reports {"disk_reads": n, "cache_hits": n} for the proof.
+    """
+
+    def __init__(self) -> None:
+        self._entries: dict[str, tuple[list, str]] = {}
+        self.disk_reads = 0
+        self.cache_hits = 0
+
+    def get(self, path: Path) -> str | None:
+        """Cached text for `path`, or None when it is unreadable."""
+        anchor = stat_anchor(path)
+        key = str(path)
+        entry = self._entries.get(key)
+        if anchor is not None and entry is not None and list(entry[0]) == list(anchor):
+            self.cache_hits += 1
+            return entry[1]
+        try:
+            data = path.read_bytes()
+            after = stat_anchor(path)
+            if anchor is not None and after is not None and list(after) != list(anchor):
+                data = path.read_bytes()
+                after = stat_anchor(path)
+        except OSError:
+            return None
+        self.disk_reads += 1
+        text = data.decode("utf-8", errors="replace")
+        if after is not None:
+            self._entries[key] = (after, text)
+        return text
+
+    def read_text(self, path: Path) -> str:
+        """Cached text for `path`, or "" when it is unreadable."""
+        text = self.get(path)
+        return "" if text is None else text
+
+    def stats(self) -> dict:
+        return {"disk_reads": self.disk_reads, "cache_hits": self.cache_hits}
+
+
+# One cache per gate run (reset in main).
+_read_cache = FileReadCache()
 
 
 def read_json(path: Path) -> dict:
@@ -200,6 +263,74 @@ def assertion_delta(project_root: Path, diff_ref: str, test_files: list, deleted
     return added, removed
 
 
+def stat_anchor(path: Path):
+    """[size, mtime_ns, inode] for a file, or None when it cannot be stat'ed.
+
+    Same anchor the TDD seal records in the green proof's snapshot scope
+    (issue #5, P1-3): a matching anchor means the sealed bytes are still
+    there without re-reading them. Kept local — this atom stays
+    self-contained and does not import tdd_lib.
+    """
+    try:
+        st = path.stat()
+    except OSError:
+        return None
+    if not path.is_file():
+        return None
+    return [st.st_size, st.st_mtime_ns, st.st_ino]
+
+
+def seal_partition(project_root: Path, change_dir: Path, files: list):
+    """Split changed files by whether they still match the green seal.
+
+    The green TDD proof (tdd/green-0.json) records the sha256 of every
+    file I6a sealed when the proof was produced (issue #5, P1-2). A
+    changed file whose current bytes still hash to the sealed value is
+    byte-for-byte what the TDD gate verified, so a review pass does not
+    need to re-read it; anything else — drifted after the seal, or never
+    sealed — must be re-read. Returns None when no usable green seal
+    exists (the review then re-reads everything).
+
+    When the green proof carries the seal-time stat anchors (snapshot
+    scope file_stats, issue #5 P1-3), a file whose anchor still matches
+    is accepted without hashing it at all; only anchor mismatches are
+    re-read and hashed. `stat_checked` counts the files accepted this
+    way; `reread_count` keeps its P1-2 meaning (files the review must
+    re-read) and is unchanged by the fast path. Proofs sealed before
+    the anchors existed fall back to hashing every file.
+    """
+    green = read_json(change_dir / "tdd" / "green-0.json")
+    hashes = green.get("file_hashes")
+    if not isinstance(hashes, dict) or not hashes:
+        return None
+    scope = green.get("snapshot_scope")
+    stats = scope.get("file_stats") if isinstance(scope, dict) else None
+    sealed, drifted = [], []
+    stat_checked = 0
+    for relative in files:
+        full = project_root / relative
+        anchor = stats.get(relative) if isinstance(stats, dict) else None
+        if anchor is not None:
+            current = stat_anchor(full)
+            if current is not None and list(current) == list(anchor):
+                stat_checked += 1
+                sealed.append(relative)
+                continue
+        digest = None
+        if full.is_file():
+            digest = hashlib.sha256(full.read_bytes()).hexdigest()
+        if digest is not None and hashes.get(relative) == digest:
+            sealed.append(relative)
+        else:
+            drifted.append(relative)
+    return {
+        "sealed_unchanged": sealed,
+        "seal_drifted": drifted,
+        "reread_count": len(drifted),
+        "stat_checked": stat_checked,
+    }
+
+
 def tokenize(text: str) -> set:
     tokens = set()
     for raw in re.findall(r"[A-Za-z_][A-Za-z0-9_]*", text):
@@ -248,6 +379,8 @@ def iter_repo_tests(project_root: Path) -> list:
 
 
 def main() -> None:
+    global _read_cache
+    _read_cache = FileReadCache()
     parser = argparse.ArgumentParser()
     parser.add_argument("--project-root", default=".")
     parser.add_argument("--change-id", required=True)
@@ -416,6 +549,8 @@ def main() -> None:
         "changed_files": all_files,
         "code_files": code_files,
         "test_files": test_files,
+        "read_cache": _read_cache.stats(),
+        "seal_partition": seal_partition(project_root, change_dir, all_files),
         "spec_aligned_files": aligned_files,
         "assertions": {"added": added_assertions, "removed": removed_assertions},
         "budget": budget,
@@ -432,6 +567,7 @@ def main() -> None:
         "ok": proof["ok"],
         "verdict": verdict,
         "proof_file": str(proof_file),
+        "read_cache": _read_cache.stats(),
         "failures": sum(1 for f in findings if f.get("severity") == "fail"),
         "warnings": sum(1 for f in findings if f.get("severity") == "warn"),
         "failed_codes": [f.get("code") for f in findings if f.get("severity") == "fail"],

package/xflow/atoms/tdd_lib.py

@@ -142,6 +142,126 @@ def sha256_bytes(data: bytes) -> str:
     return hashlib.sha256(data).hexdigest()
 
 
+def stat_anchor(path: Path) -> list | None:
+    """[size, mtime_ns, inode] for a file, or None when it cannot be stat'ed.
+
+    The anchor is the cheap identity a later gate stats first: when the
+    anchor still matches the one recorded at seal time, the bytes the seal
+    hashed cannot have changed without a same-size same-nanosecond rewrite
+    (the same heuristic git uses for its index). Any anchor mismatch falls
+    back to a full re-read and re-hash, so the check never weakens.
+    """
+    try:
+        st = path.stat()
+    except OSError:
+        return None
+    if not path.is_file():
+        return None
+    return [st.st_size, st.st_mtime_ns, st.st_ino]
+
+
+def read_with_anchor(path: Path) -> tuple[bytes, list | None]:
+    """Read a file and return the bytes plus the stat anchor they were read under.
+
+    Stats before and after the read; when the file changed mid-read the
+    read is retried once, so the returned anchor always describes the
+    returned bytes.
+    """
+    before = stat_anchor(path)
+    data = path.read_bytes()
+    after = stat_anchor(path)
+    if before is not None and after is not None and before != after:
+        data = path.read_bytes()
+        after = stat_anchor(path)
+    return data, after
+
+
+class FileReadCache:
+    """Per-process cache of file text, keyed by the stat anchor.
+
+    One gate run reads the same source file several times — symbols,
+    assertions, references (issue #5, P1-2 follow-up to #34). The first
+    read stores the text under the file's stat anchor (size, mtime_ns,
+    inode, the P1-3 identity); a later read whose anchor still matches
+    is served from memory without touching the bytes. Any anchor
+    mismatch — the file changed, or it was never read — re-reads from
+    disk, so the cache can never serve stale content; a mid-read change
+    is retried once, like read_with_anchor, so the stored anchor always
+    describes the stored text. Unreadable files are never cached and
+    never counted as disk reads.
+
+    `stats()` reports {"disk_reads": n, "cache_hits": n} so a proof can
+    show the skipped re-reads; the counts are per cache instance, and a
+    gate creates one instance per run.
+    """
+
+    def __init__(self) -> None:
+        self._entries: dict[str, tuple[list, str]] = {}
+        self.disk_reads = 0
+        self.cache_hits = 0
+
+    def get(self, path) -> str | None:
+        """Cached text for `path`, or None when it is unreadable."""
+        path = Path(path)
+        anchor = stat_anchor(path)
+        key = str(path)
+        entry = self._entries.get(key)
+        if anchor is not None and entry is not None and list(entry[0]) == list(anchor):
+            self.cache_hits += 1
+            return entry[1]
+        try:
+            data = path.read_bytes()
+            after = stat_anchor(path)
+            if anchor is not None and after is not None and list(after) != list(anchor):
+                data = path.read_bytes()
+                after = stat_anchor(path)
+        except OSError:
+            return None
+        self.disk_reads += 1
+        text = data.decode("utf-8", errors="replace")
+        if after is not None:
+            self._entries[key] = (after, text)
+        return text
+
+    def read_text(self, path) -> str:
+        """Cached text for `path`, or "" when it is unreadable."""
+        text = self.get(path)
+        return "" if text is None else text
+
+    def stats(self) -> dict:
+        return {"disk_reads": self.disk_reads, "cache_hits": self.cache_hits}
+
+
+def verify_hashes_by_stat(root: Path, hashes: dict, stats: dict | None) -> dict:
+    """Check recorded sha256 hashes, re-reading only files whose stat moved.
+
+    `stats` maps rel -> [size, mtime_ns, ino] recorded when the hash was
+    computed (issue #5, P1-3). A file whose current anchor matches is
+    accepted without reading its bytes; anything else — missing anchor,
+    stat mismatch, missing file — is re-read and hashed. Returns
+    {"mismatched": [...], "reread": [...], "stat_checked": n}.
+    """
+    mismatched: list[str] = []
+    reread: list[str] = []
+    stat_checked = 0
+    anchors = stats if isinstance(stats, dict) else {}
+    for rel, digest in hashes.items():
+        full = root / rel
+        anchor = anchors.get(rel)
+        if anchor is not None:
+            current = stat_anchor(full)
+            if current is not None and list(current) == list(anchor):
+                stat_checked += 1
+                continue
+        reread.append(rel)
+        if not full.is_file():
+            mismatched.append(rel)
+            continue
+        if sha256_bytes(full.read_bytes()) != digest:
+            mismatched.append(rel)
+    return {"mismatched": sorted(mismatched), "reread": sorted(reread), "stat_checked": stat_checked}
+
+
 # Optional binding fields join the payload only when present, so proofs
 # sealed before the field existed keep verifying byte-for-byte.
 OPTIONAL_BINDING_FIELDS = {"snapshot_scope"}
@@ -313,16 +433,23 @@ def write_snapshot(project_root: Path, change_id: str, phase: str, attempt: int,
             target.parent.mkdir(parents=True, exist_ok=True)
             target.write_bytes(data)
         return hashes, None
+    file_stats: dict[str, list] = {}
+    copy_stats: dict[str, list] = {}
     for rel in scope["files"]:
         full = project_root / rel
         if full.is_symlink() or not full.is_file():
             continue
-        data = full.read_bytes()
+        data, anchor = read_with_anchor(full)
+        if anchor is not None:
+            file_stats[rel] = anchor
         hashes[rel] = sha256_bytes(data)
         target = destination / rel
         target.parent.mkdir(parents=True, exist_ok=True)
         target.write_bytes(data)
-    scope = {**scope, "files": sorted(hashes)}
+        copy_anchor = stat_anchor(target)
+        if copy_anchor is not None:
+            copy_stats[rel] = copy_anchor
+    scope = {**scope, "files": sorted(hashes), "file_stats": file_stats, "copy_stats": copy_stats}
     return hashes, scope
 
 

package/xflow/yolo/SKILL.md

@@ -61,6 +61,14 @@ pass that writes the plan also writes the failing test, so `tdd-red` only
 runs and seals it — no second exploration pass, and the issue/branch
 ceremony no longer sits between planning and the red proof.
 
+In `verify-consistency`, run the deterministic gates first. The J6 proof
+(`specs/changes/${CHANGE_ID}/cr/review-0.json`) carries a `seal_partition`:
+files whose bytes still match the green proof's sealed hashes
+(`sealed_unchanged`) are exactly what the TDD gate verified — the review
+pass does not re-read them. Only `seal_drifted` files (changed after the
+green seal, or never sealed) get a fresh read. When `seal_partition` is
+null there is no green seal to trust, and the review re-reads everything.
+
 The workflow YAML is the canonical execution source for atom order, gates, and
 artifact checks. This skill only explains the contract.