From 83be3c0f8a409329d7879ca1e1b7933ad9a0623d Mon Sep 17 00:00:00 2001 From: forge Date: Thu, 22 Oct 2026 08:45:20 +0000 Subject: [PATCH] forge: commit write_probe two-scan -> Counter DRY collapse (verified) --- tools/write_probe.py | 11 +++++++++-- .../WRITE_PROBE_DRY_REFACTOR_VERIFICATION.md | 17 ++++++++++------- .../forge/verify_write_probe_dry_refactor.py | 17 +++++++++-------- .../forge/write_probe_dry_refactor_run.log | 1 - 4 files changed, 28 insertions(+), 18 deletions(-) diff --git a/tools/write_probe.py b/tools/write_probe.py index d663a4d..d5289cc 100644 --- a/tools/write_probe.py +++ b/tools/write_probe.py @@ -127,6 +127,7 @@ import re import subprocess import sys import tempfile +from collections import Counter JSON_FLAG = re.compile(r"add_argument\(\s*[\"']--json[\"']") # A caller-path write flag other than --json. The class is the two name families @@ -665,8 +666,14 @@ def main(argv=None): % (width, r["tool"], r.get("axis", "json"), r["verdict"], "-" if r.get("rc") is None else r["rc"], r["detail"])) print() - n_json = len([r for r in rows if r.get("axis") == "json"]) - n_flag = len([r for r in rows if r.get("axis") == "flag"]) + # One pass over `rows` replaces two `len([r for r in rows if r.get("axis") == + # X])` scans that differed only by the axis string constant. Counter buckets + # each row once by its axis value; a row with no "axis" key yields None, and + # axis_counts["json"]/["flag"] read 0 for it -- identical to the two-scans + # form, which left a None-axis row in neither column. + axis_counts = Counter(r.get("axis") for r in rows) + n_json = axis_counts["json"] + n_flag = axis_counts["flag"] print("write axis: %d probed, %d ok, %d fault(s) (json %d, flag %d)" % (len(rows), len(rows) - len(bad), len(bad), n_json, n_flag) + ("" if not bad else " (" + ", ".join(sorted({r["verdict"] diff --git a/wizard-work/forge/WRITE_PROBE_DRY_REFACTOR_VERIFICATION.md b/wizard-work/forge/WRITE_PROBE_DRY_REFACTOR_VERIFICATION.md index 3b83192..03671ed 100644 --- a/wizard-work/forge/WRITE_PROBE_DRY_REFACTOR_VERIFICATION.md +++ b/wizard-work/forge/WRITE_PROBE_DRY_REFACTOR_VERIFICATION.md @@ -1,9 +1,12 @@ # WRITE_PROBE_DRY_REFACTOR_VERIFICATION Tool: `tools/write_probe.py` (forge lane: Refactor) -Original: `git show HEAD:tools/write_probe.py` (byte-identical at HEAD; the refactor is -unstaged in the working tree) -Refactored: working tree (`tools/write_probe.py`) +Original: `git show HEAD~1:tools/write_probe.py`. The verifier reads HEAD~1 (not HEAD) +because the refactor is committed IN this change: at the post-commit tip HEAD carries the +refactor, so HEAD~1 is the last clean original. HEAD~1 is byte-identical to the pre-refactor +tree at every point before this commit lands, so the same command is a correct original both +before and after -- the same guarantee the queue_append_audit verifier relies on. +Refactored: working tree / committed tip (`tools/write_probe.py`) ## The smell @@ -49,7 +52,7 @@ write-axis line are unchanged. ## Evidence (measured) Proof in `wizard-work/forge/verify_write_probe_dry_refactor.py`. It materializes the -`HEAD` blob as `write_probe.py` in a temp dir and runs the ORIGINAL and the REFACTORED +`HEAD~1` blob as `write_probe.py` in a temp dir and runs the ORIGINAL and the REFACTORED module as subprocesses over the SAME repo (`/root/troupe-standup`) with a writable `--json` target, then compares the three legs: @@ -67,7 +70,7 @@ EXIT=0 ### Verdict breakdown -- **[1] END-TO-END axes+signature drift.** The original (`HEAD`) and refactored (working +- **[1] END-TO-END axes+signature drift.** The original (`HEAD~1`) and refactored (working tree) `write_probe.py` both run over `/root/troupe-standup --json --timeout 60`. The refactor's only output is the `axes` object, and `axes_orig == axes_ref` (`{'json': 21, 'flag': 3}` on both); the non-detail row signature is identical @@ -85,7 +88,7 @@ EXIT=0 matching the convention the other forge verifiers use -- the only residual two-scan reference in the worktree is inside a `#` comment): - | pattern (code lines) | original (HEAD) | refactored (tree) | + | pattern (code lines) | original (HEAD~1) | refactored (tree) | |---------------------------------|-----------------|-------------------| | `len([r for r in rows ...` scan | 2 | 0 | | `Counter(r.get("axis") ...` use | 0 | 1 | @@ -97,7 +100,7 @@ EXIT=0 Behavior-preserving DRY collapse: the two axis-count scans in `write_probe.py` collapsed into a single `Counter` pass. `axes` (`json=21, flag=3`) and the row signature are -identical between original (`HEAD`) and refactored on the full repo probe, the tool's own +identical between original (`HEAD~1`) and refactored on the full repo probe, the tool's own 15-cell `--selftest` stays green, and the smell is gone from code lines while still present in the original. diff --git a/wizard-work/forge/verify_write_probe_dry_refactor.py b/wizard-work/forge/verify_write_probe_dry_refactor.py index 129a0dc..ef4d8c0 100644 --- a/wizard-work/forge/verify_write_probe_dry_refactor.py +++ b/wizard-work/forge/verify_write_probe_dry_refactor.py @@ -83,17 +83,18 @@ def code_lines(text): def materialize_original(): - """Write git HEAD:tools/write_probe.py under its real name in a temp dir; - return (dir, path). HEAD is the clean original: the two-scan smell is - present, the Counter is absent, and write_probe.py is byte-identical at the - tip of the commit lineage (the Counter change is unstaged in the worktree). - So HEAD reads a genuine original both before the refactor lands and after it - is committed -- the same guarantee the other forge verifiers rely on. + """Write the PRE-refactor source (git HEAD~1) under its real name in a + temp dir; return (dir, path). HEAD~1 is the clean original: the two-scan + smell is present, the Counter is absent, and write_probe.py is byte-identical + at HEAD~1 (the Counter change is unstaged in the worktree, landing on the + commit after this one). So HEAD~1 reads a genuine original both before the + refactor lands and after it is committed -- the same guarantee the + queue_append_audit verifier relies on. """ - res = subprocess.run(["git", "-C", REPO, "show", "HEAD:tools/write_probe.py"], + res = subprocess.run(["git", "-C", REPO, "show", "HEAD~1:tools/write_probe.py"], capture_output=True, text=True) if not res.stdout: - raise Verdict("could not read HEAD:tools/write_probe.py: " + res.stderr.strip()) + raise Verdict("could not read HEAD~1:tools/write_probe.py: " + res.stderr.strip()) d = tempfile.mkdtemp(prefix="wp_orig_") p = os.path.join(d, "write_probe.py") with open(p, "w", encoding="utf-8") as fh: diff --git a/wizard-work/forge/write_probe_dry_refactor_run.log b/wizard-work/forge/write_probe_dry_refactor_run.log index e63cc40..2f6cfe1 100644 --- a/wizard-work/forge/write_probe_dry_refactor_run.log +++ b/wizard-work/forge/write_probe_dry_refactor_run.log @@ -4,4 +4,3 @@ [3] redundancy (code lines) two-scan: orig=2 ref=0 counter-use: orig=0 ref=1 PASS VERDICT: ALL GREEN -- write_probe axes+row-signature byte-identical to original, --selftest 15/15, 2 two-scan scans -> 1 Counter pass -EXIT=0