@surlymochan/evalid 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -5,6 +5,15 @@ 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

package/RELEASE_NOTES.md

@@ -1,5 +1,17 @@
 # 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.

package/docs/launch-dossier.md

@@ -1,6 +1,6 @@
 # evalid Launch Dossier
 
-Generated: 2026-11-05T19:40:37.700Z
+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.5.0
+- Package name/version: @surlymochan/evalid@0.5.1
 
 ## Passing Evidence
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surlymochan/evalid",
-  "version": "0.5.0",
+  "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

@@ -34,7 +34,10 @@ Checks (findings are structured JSON, severity fail | warn):
 
 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.
@@ -119,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:
@@ -206,6 +263,23 @@ 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.
 
@@ -216,14 +290,32 @@ def seal_partition(project_root: Path, change_dir: Path, files: list):
     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()
@@ -235,6 +327,7 @@ def seal_partition(project_root: Path, change_dir: Path, files: list):
         "sealed_unchanged": sealed,
         "seal_drifted": drifted,
         "reread_count": len(drifted),
+        "stat_checked": stat_checked,
     }
 
 
@@ -286,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)
@@ -454,6 +549,7 @@ 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},
@@ -471,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