# Repro-bounds probe refactor verification (forge lane: Refactor)

## Work

Refactored `_repro_bounds.py` — a minimal 24-line reproduction probe that
checks whether `chunker.chunk_text` produces any chunk whose genuine content
exceeds `max_tokens`.  After the bounds-overflow fix in `chunker.py` the probe
prints `No overflow found (unexpected).` and exits 0, but the probe itself had
not itself been refactored.

## Problem (code smell)

The original ran its entire probe at **module top level** and called
`sys.exit()` on import -- importing it (for a harness or monkeypatch) executed
and terminated the process.  Additional smells:

- No `if __name__ == "__main__"` guard (entry point + side effects at module scope).
- Inline per-chunk bounds check (`body = c.partition(...)[2] if ... else c`;
  `est = chunker.estimate_tokens(body)`; `if est > mt and body.strip()`) was
  duplicated across probes (fuzz, roundtrip, edge-sweep all inline the same
  pattern instead of calling a shared helper).
- Module-level mutable `any_overflow` boolean flag threaded through nested
  loops, coupling search logic to I/O.
- Hardcoded `cases` list baked into module scope with no named constant.

## Refactor

`_repro_bounds_refactored.py`:

- Extracted the inline bounds check into `_overlong_chunks(cs, mt)` -- a pure
  generator yielding `(index, est_tokens, body)` for every offending chunk.
  This reuses the same abstraction the roundtrip probe's `_overlong_chunks` and
  the fuzz probe's `_check_bounds` already converged on, reducing cross-probe
  duplication.
- Replaced the module-level `any_overflow` flag with `main() -> int` returning
  the exit code directly (no shared mutable state, no ordering coupling between
  search and print).
- Promoted the hardcoded case list to a named constant `CASES` -- decoupling
  the case catalogue from the control flow that consumes it.
- Guarded script entry with `if __name__ == "__main__": sys.exit(main())`.
  Import is now side-effect-free: it produces no output and does not call
  `sys.exit`.

## Evidence (measured, not claimed)

Both runs executed against the live chunker at
`/root/.hermes/wizard-outputs/forge/chunker.py`.

```
$ python3 _repro_bounds.py        (original, 24 lines)
No overflow found (unexpected).
EXIT=0

$ python3 _repro_bounds_refactored.py  (refactored, 73 lines incl. docstrings)
No overflow found (unexpected).
EXIT=0
```

Byte-for-byte output equivalence:

```
$ diff <(python3 _repro_bounds.py 2>&1) <(python3 _repro_bounds_refactored.py 2>&1) && echo "DIFF=0 (identical)"
DIFF=0 (identical)
$ cksum /tmp/orig_out.txt /tmp/ref_out.txt
3061662 32 /tmp/orig_out.txt
3061662 32 /tmp/ref_out.txt
```

py_compile:

```
$ python3 -m py_compile _repro_bounds_refactored.py && echo "PY_COMPILE_OK"
PY_COMPILE_OK
```

Verifier run (10 checks, all pass, exit 0):

```
$ python3 verify_repro_bounds_refactor.py; echo "=== VERIFIER EXIT=$? ==="
OK: py_compile passes
OK: identical output (exit 0): 'No overflow found (unexpected).'
OK: __main__ guard present
OK: named constant CASES present
OK: no 'global' statements
OK: module-level 'any_overflow' flag removed (state folded into main() return)
OK: _overlong_chunks defined and called by main()
OK: no bare sys.exit at module scope
OK: import is side-effect-free (no probe output at import)
OK: _overlong_chunks yields 1 result(s) under patched estimator

=== Verification: 10/10 checks passed ===
```

## Non-tautology proof (smell absence is real)

The verifier's `_code_only()` strips the module docstring and comment-only
lines before smell checks -- the refactored docstring *names* the patterns it
removes (`any_overflow`, `CASES`), which would be false positives otherwise.

- Refactored module compiles (py_compile exit 0).
- Original and refactored produce byte-identical stdout+stderr (32 bytes,
  cksum `3061662`) and identical exit code 0.
- Import is side-effect-free: importing the module produces no output and does
  not terminate the process.
- AST scan confirms no top-level assignment to `any_overflow` and no bare
  `sys.exit` at module scope (only inside `main` / `__main__`).
- `_overlong_chunks` is a genuine search, not a hard-coded empty iterator:
  patching `chunker.estimate_tokens` to `lambda s: 10**9` causes it to yield
  results (1 result on a 130-char string), proving the generator filters and
  yields based on real token-estimate logic.

## Metrics (smell counts, before -> after)

| smell                          | original | refactored |
|--------------------------------|----------|------------|
| import-time side effects       | yes      | none       |
| `__main__` guard               | absent   | present    |
| module-level mutable flag      | `any_overflow` | 0      |
| bare `sys.exit` at module scope| yes      | 0          |
| duplicated bounds-check pattern| inline   | extracted `_overlong_chunks` |
| magic case list                | inline   | named `CASES` |
| byte-identical output          | --       | 32 bytes, cksum 3061662 |

## Verdict

Behavior-preserving and measurably equivalent: 5 repro cases, identical output
(32 bytes), exit 0.  The probe's import-time side effects are eliminated, the
inline bounds check is extracted into a reusable generator, the mutable flag is
folded into `main()`'s return value, and the case list is promoted to a named
constant.  All 10 verifier checks pass (exit 0).

## Post-check CHECK

```
python3 /root/troupe-standup/wizard-work/forge/verify_repro_bounds_refactor.py
```