Reject sponsor transactions that set rekeyTo or payment.closeRemainderTo,
validate transactions array elements are base64 strings, and fix the
manager address doc path to include the /v1 prefix.

f7bcb90 claimed "wrong_target was the only rule in the file without a mutation test; A to L
cover the rest". That was false, and nothing enforced it. Four table-hygiene rules had no
mutation -- `ambiguous`, `reused`, the UNCHECKED `kind` whitelist, and the audit-sheet clause of
the count check -- and mutation N reaches only the `isinstance(row, Live)` half of
`wrong_target`: delete the `row.target == cite.path` comparison and N still fails.

Five mutations close that, each proven by neutralising the rule it names and running the file:

  O  a citation that two rows answer         assert not result.ambiguous
  P  one row answering two citations         assert not result.reused
  Q  an UNCHECKED row of an invented kind    the `kind` whitelist
  R  an audit sheet that cites no line       assert in_audit_sheet
  S  a path-qualified citation answered by   row.target == cite.path
     a LIVE row about another file

Each neutralisation fails exactly its own test and nothing else: 31 tests in the file, 30 pass
and 1 fails, seven times over.

The whitelist was a bare `assert ... <= {...}` with no message. It now names the kinds it
refuses, so its failure says what is wrong.

The module docstring lists these mutations in prose, and prose cannot be checked clause by
clause. What can be checked is the count, so
test_the_mutations_are_a_contiguous_lettered_run asserts the letters run from `a` with none
missing and none repeated, and that the docstring states that number in words. Renaming mutation
A to T, and changing "Nineteen" to "Eighteen", each fail that test alone.

sdk/tests: 176 passed, 5 skipped -- 170 before these six tests -- with TRELYAN_REQUIRE_KAT=1,
TRELYAN_REQUIRE_GIT=1 and the Falcon library built from the vendored tree. Every skip is
reported; none is counted as a pass. The 28 errors in sdk/test_inscription.py are LocalNet
connection refusals, identical on HEAD.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

The docstring said the guard's two lines carry "two `.github/workflows/ci.yml` comments". The
next commit on this branch, 2c2daeb, added a third, so the count was stale one commit later and
nothing enforces it. It now names those comments without counting them.

It also said deleting the guard used to leave the suite green because "the skip branch is the
only one ever taken". Neither branch is taken: every environment the suite runs in can read the
object store, so `_unavailable` is never called at all. The claim around it -- that deleting the
two lines leaves the suite green while this test is absent -- is true and was reproduced; only
the stated mechanism was wrong.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

TRELYAN_REQUIRE_GIT is what makes four written claims true: this file's
docstring says twice that the environmental skips fail when it is set (the end
of check 4, and WHAT IS NOT CHECKED), and two .github/workflows/ci.yml comments
say a skipped check is not a pass. Nothing tested it -- deleting the two lines
in _unavailable that read the variable left the suite green, because every
environment the suite runs in can read the object store.

wrong_target was the only rule in the file without a mutation test; A to L cover
the rest. It is the only rule that reads the path a citation spells out, so an
exemption in a dated record could answer a path-qualified contract citation with
nothing else objecting.

Mutation M patches _blob_id_in_commit to a lookup that says the store cannot be
asked, then asserts through _must_fail_not_skip that the banner-to-blob check
FAILS with the variable set, and, as the negative control, that it raises
Skipped with the variable unset. _must_fail_not_skip now takes the exception the
check raises: pytest.fail raises Failed, which is not an AssertionError, so
pytest.raises(AssertionError) would not have caught it.

Mutation N plants a path-qualified citation in
contracts/COMPILE_REVIEW_2026-06-01.md and a dated UNCHECKED row for it, and
asserts test_every_citation_is_in_the_table fails with the rule's own message.

Evidence. Mutations were run in a mirror clone under the scratchpad, never in
this worktree; the environment was the suite's own (TRELYAN_REQUIRE_KAT=1,
TRELYAN_REQUIRE_GIT=1, FALCON_DET1024_LIB built from this tree's vendored src).

  mirror baseline                                   25 passed
  delete the two-line guard in _unavailable          1 failed (mutation M,
                                                     "the check SKIPPED where it
                                                     must fail"), 24 passed
  restored                                          25 passed
  delete the wrong_target rule in
  test_every_citation_is_in_the_table                1 failed (mutation N,
                                                     "DID NOT RAISE"), 24 passed
  restored                                          25 passed

In this worktree: full sdk suite 170 passed, 5 skipped -- the same five skips as
before this change (four algo-pqc-kit interop, one 3.10 argv premise), none of
them in this file. tests/test_app_id_references_are_coherent.py replayed: 30
passed. tests/test_signature_kat.py with the library built: 8 passed, 0 skipped.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

The comment justifying fetch-depth: 0 in the wire-format job said a depth-1
checkout would make the banner-to-blob check SKIP in every run. That job sets
TRELYAN_REQUIRE_GIT=1 on the step that runs pytest, and that variable turns an
object store that cannot be asked into a failure, so a depth-1 checkout would
fail the job instead of quietly skipping the check. The sentence now says that.

Evidence: a depth-1 clone of this branch, same environment as the job.

  TRELYAN_REQUIRE_GIT=1   3 failed, 22 passed
                          (test_the_recorded_blob_id_is_the_blob_the_banner_
                          commit_holds, and mutations K and L, each
                          "TRELYAN_REQUIRE_GIT=1, but cannot read
                          205d874:contracts/inscription.py from the object
                          store")
  variable unset          22 passed, 3 skipped
                          ("this is a shallow clone; it holds only the tip")

The other fetch-depth: 0 comment, in signature-kat, says only "same reason as
wire-format: the banner-to-blob read needs the history". That is what that job
does -- it also sets TRELYAN_REQUIRE_GIT=1, on the step that runs the whole
suite -- so it states no silent skip and needed no correction.

No behaviour changes here: the file still parses to the same ten jobs, with
wire-format keeping fetch-depth: 0 and TRELYAN_REQUIRE_GIT=1.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Check 7 (test_ci_can_reach_and_run_the_checks_in_this_file, and its
mutation M) read .github/workflows/ci.yml as text and asserted four
facts about it. It was defective three times running. The last version
matched its own needle inside a YAML comment, so commenting out the
setting it guarded still passed; it identified jobs by one hard-coded
spelling of `pytest tests`; and the comment it added to the wire-format
job -- "Runs on the schedule too, unlike every other job here" -- was
false. Reading the workflow: the Monday cron "23 6 * * 1" also runs
secret-scan, vendored-falcon-integrity, teal-matches-source and
required-merge-gates, which carry no `if: github.event_name !=
'schedule'`. Four other jobs, not none.

An unenforceable claim is removed, not re-armed with another control.
So:

* The check, its mutation, and everything only they used
  (PLANT_DOCS, CI_WORKFLOW, TRIGGER_PATHS, JOB_HEAD, RUNS_THE_SUITE,
  SCHEDULE_GUARD, _ci_text, _ci_jobs, _covered,
  _documents_this_file_names) are deleted. REQUIRE_GIT stays: it is
  check 4's skip-versus-fail switch, not part of check 7.
* The docstring sentences that asserted properties of ci.yml are gone.
  What replaces them says the opposite and is true: this file does not
  read the workflow, the two lists are kept in step by review, and a
  document that enters the scan later is outside the filters unless
  somebody lists it.
* wire-format goes back to `if: github.event_name != 'schedule'`, as on
  origin/main, and the false comment goes with it. Unguarding it was a
  CI-shape change argued for by check 7; with check 7 gone nothing
  argues for it.

What stays in ci.yml is what the citation test needs in order to run at
all: the root documents in both `paths` filters (a doc-only commit
triggered no job, which is how a wrong citation merged green), and
`fetch-depth: 0` plus TRELYAN_REQUIRE_GIT=1 in the two jobs that run
`pytest tests`, so check 4's object-store read runs instead of skipping.
Nothing asserts those; the comment above the filters now says so.

Evidence, all in a mirror copy under scratchpad/simplifyC-mirror, never
in the worktree, interpreter .venv/Scripts/python.exe with
TRELYAN_REQUIRE_KAT=1, TRELYAN_REQUIRE_GIT=1 and the Falcon DLL built
from the vendored third_party/falcon-det1024/src with MinGW gcc 16.1.0:

  baseline                                    23 passed, 0 skipped
  two lines inserted above _build_message     7 failed, incl.
                                              test_every_cited_line_still_holds_its_construct
  restored                                    23 passed
  `contracts/inscription.py:305` appended to  7 failed, incl.
  AUDIT_READINESS.md                          test_every_citation_is_in_the_table
                                              (54 extracted vs 52 listed)
  restored                                    23 passed
  one LIVE row deleted from the table         7 failed, incl.
                                              test_every_citation_is_in_the_table
  restored                                    23 passed
  `(L208)` deleted from AUDIT_READINESS.md    7 failed, incl.
                                              test_every_table_entry_is_still_cited
  restored                                    23 passed

Worktree: full sdk suite 168 passed, 5 skipped. The five skips are
pre-existing and environmental -- four for algo-pqc-kit not installed,
one for an interpreter that accepts -P. None is a citation check.
test_app_id_references_are_coherent.py: 30 passed, 0 skipped; no
literal 7xxxxxxxx app id was added to either edited file.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Review round 3 found that the control added by 0090c02 could be switched off by the
very document it polices. _blob_id_in_commit returned None for "no .git", "no git",
"shallow clone" AND "this repository does not hold that commit", and every caller
skipped on None. So the shortest path to green after a contract change was no longer
to overwrite CONTRACT_BLOB_AT's value under the existing key -- BANNER-1 catches that
-- but to change the KEY: point AUDIT_READINESS.md's banner at a hash nobody can
resolve and record the current blob under it. The blob-equality half then passes
because the pair is self-consistent, the object-store half skipped, and the scope
sheet named a revision that does not exist while the suite exited 0. test_mutation_k,
the self-test for that control, skipped in the same state, because pytest.skip raised
inside pytest.raises(AssertionError) propagates as Skipped, not as a failure.

_blob_id_in_commit now returns a BlobLookup that separates "the store cannot be asked"
from "the store was asked and this repository does not contain it". The first is
environmental and still skips; the second is chosen by the author of the document under
review and now FAILS. TRELYAN_REQUIRE_GIT=1 turns the environmental skip into a failure
too, and ci.yml sets it in both jobs that run `pytest tests` -- the same reasoning as the
grep in signature-kat: passing must require that the check RAN. Two new mutations,
test_mutation_l (a fabricated banner commit) and the hardened test_mutation_k, assert a
FAILURE rather than "not a pass", through a helper that refuses to let the check skip.

Three facts about ci.yml were stated in the docstring as settled and enforced by nothing:
that the five root documents are in both paths filters, that the suite jobs check out
with fetch-depth: 0, and (implicitly) that the checks are reachable at all. CI-1
(fetch-depth 0 -> 1) and CI-2 (the root documents removed) both survived the whole suite
at exit 0. test_ci_can_reach_and_run_the_checks_in_this_file reads the workflow as text --
no YAML dependency, as the four other tests that read it do -- and requires every document
a row, ROOT_COMPILE_DOCS or a mutation names to be in both filters, every `pytest tests`
job to carry fetch-depth: 0 and TRELYAN_REQUIRE_GIT=1, and one such job to run on the
schedule. test_mutation_m proves each of those four with a planted ci.yml.

The filters gained SECURITY.md, PUBLIC_CLAIMS_HARDENING_2026-06-01.md, PINNED_BUILD.md,
ROADMAP.md and LOCALNET_VALIDATION_2026-06-01.md, and wire-format no longer skips the
Monday schedule: the whole-tree sweep of check 6 reads files no paths list can enumerate,
and the schedule is the only thing that reaches those. required-merge-gates already counts
a job's success the same as its schedule-skip, so the gate set is unchanged.

Two prose corrections, both claims that were checkable and wrong. The bullet added by
0090c02 said the three files excluded from the scan hold no line citation "today"; that
is true of the two TARGETs and false of this file, which holds 114 by its own extractor,
several of them live present-tense claims about contract line numbers that nothing checks.
And the paragraph recording the superseded wording quoted "124 differing lines" for all
five documents; contracts/requirements.txt said "124 cosmetically-different lines", which
is why OLD_COUNT_FORM already refuses both.

Mutation proofs, each in a cp -r scratch copy against the whole sdk suite, KAT armed:
BANNER-2 (banner -> d0d0bee, CONTRACT_BLOB_AT rekeyed) now 3 failed, was exit 0; CI-1 and
CI-2 now 2 failed each, both were exit 0; CI-3 (TRELYAN_REQUIRE_GIT removed from ci.yml)
2 failed; FIX-3 (the object-store read deleted) 3 failed under TRELYAN_REQUIRE_GIT=1, and
167 passed / 8 skipped without it -- which is what the env gate and the ci.yml test exist
to make impossible in CI. Negative controls still caught: BANNER-1 1 failed, DRIFT-2 4
failed. Baseline 170 passed, 5 skipped with and without TRELYAN_REQUIRE_GIT; the new file
alone 25 passed, 0 skipped. The five skips are the pre-existing ones. App-id rule replayed
over 316 tracked paths: no unclassified file.

Security Impact: no contract, proof or crypto code changed. The change is to what the test
suite refuses. A stale scope sheet that previously merged green through a skipped check now
fails the suite, and CI can no longer be edited to stop these checks running without that
same suite going red. contracts/inscription.py is untouched, so AUDIT_READINESS.md's banner
commit and CONTRACT_BLOB_AT still hold and no LIVE row needed re-verifying.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Review of the branch found four ways its own machinery could be walked past.

1. Check 6 walked a hard-coded five-name tuple while the citation half of the
   same file walks the tree, so the stale "124 differing lines" claim could
   re-enter through any sixth document and nothing noticed. Proven: the phrase
   planted in REVIEWER.md, and "99 lines of the approval TEAL" planted in
   PINNED_BUILD.md, both SURVIVED the whole sdk suite. Every scanned document is
   now swept as well - the superseded form is refused anywhere, and a document
   outside the five may state the count only if it states the committed one.
   Both plants are now KILLED.

2. CONTRACT_BLOB_AT was a self-consistent pair: it proved the contract is the
   blob the dict records for the string "205d874", never that it is the blob
   commit 205d874 holds. Appending a line below every cited construct and
   overwriting the value under the same key left AUDIT_READINESS.md asserting a
   false revision while the suite stayed green. The id is now read back with
   `git rev-parse <banner commit>:contracts/inscription.py`. Unreadable (no
   .git, no git, or a shallow clone that lacks the commit) is a reported SKIP,
   never a pass; the blob-equality check is unchanged and still runs either way.

3. A bare `:N` was only read in a document that also carried a `path:N`.
   AUDIT_READINESS.md carries none - its style is `contracts/inscription.py`
   plus `(L288)` - so a `:305` written into the one document this file exists
   for reached no production check. It tripped only the extractor self-test, by
   the accident that that test plants a path form into the same document. A bare
   `:N` is now read in every markdown file that names inscription.py; outside
   markdown the old gate stands, because there a bare `:N` is usually a port
   (ci.yml says "algod on :4001"). The change adds zero citations to the current
   tree: 53 before, 53 after.

4. CI never ran any of this on the change class it was written for. A commit
   confined to AUDIT_READINESS.md, README.md, REVIEWER.md, CONTRIBUTING.md or
   THREAT_MODEL_AND_TRACEABILITY.md matched no `paths` filter, so a wrong
   citation merged green and first failed on some later, unrelated change. All
   five are in both filters now, which also closes the gap for
   test_cited_documents_exist.py and test_app_id_references_are_coherent.py. The
   two jobs that run `pytest tests` check out with fetch-depth: 0 so the
   object-store read in 2 runs there instead of skipping on a depth-1 clone.

Each new rule is mutation-proven in the file (mutations i, j, k re-run the real
test functions against planted inputs), and all four holes were re-run against
the whole suite in a scratch copy: KILLED, tree restored byte-identical.

Also states plainly what the scan does not read: the two TARGET files and this
file are excluded, and only the ten TEXT_SUFFIXES are opened. The docstring said
"every text file that names inscription.py" and disclosed only contracts/out/.

Not addressed here, deliberately: AUDIT-NOTE A1 at contracts/inscription.py:32
still quotes `op.falcon_verify(m, falcon_sig.bytes, pubkey)` while line 304
calls `.native`. Correcting it changes the contract's blob, which forces the
banner commit and CONTRACT_BLOB_AT to move in the same commit and every LIVE row
to be re-verified. That is its own change, and Brandon's call.

Tests: sdk suite 167 passed, 5 skipped (the same 5 as before this commit, none
from this file); this file alone 22 passed, 0 skipped; app-id rule replayed
independently - 23 tracked text files mention a 7xxxxxxxx id, all classified.

Security Impact: no protocol, contract or crypto code changes. contracts/ is
untouched. The only behaviour change outside sdk/tests/ is which events trigger
CI, which widens coverage. Three document-hygiene checks that could be walked
past now fail closed; nothing that failed before passes now.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

670bc14 closed the review's mechanism-absent blocker for
contracts/verify_deployment.py: no test made its approval-program comparison
fail, though the module docstring claimed every comparison it prints can FAIL.
The identical gap in the reviewer script was left open. Four mutants of
sdk/examples/verify_trelyan.py survived the whole suite:

  VA1  the committed-TEAL assembly compared with itself
  VA2  the 2026-09-03 pin compared with itself
  VA3  the approval redeploy banner never printed
  VA4  the "approval program fetched" check made unconditionally true

Every existing case served the real 709 B approval bytes, so the pin and
assembly checks passed in all of them and nothing drove the drift path - the
same shape as the verify_deployment.py blocker, on the script the README's
headline points a reviewer at.

_run() now takes an approval_field, defaulting to the real program, so exactly
one side moves per case. test_a_differing_approval_program_fails_and_names_the
_redeploy serves a 709 B program differing in one flipped bit: exit 1, FAIL on
the pin and assembly checks only, "approval program fetched" still PASS, the
committed approval TEAL actually assembled, the redeploy banner printed, and
both fingerprints present in it. Equal lengths keep the banner's two sizes the
same, so only the fingerprints can tell the programs apart. The clear-state
checks are asserted unaffected.

The file is renamed test_verify_trelyan_clear_state.py ->
test_verify_trelyan_programs.py because it now covers both programs; nothing
referenced the old name, and it carries no app id, so the app-id rule does not
see the rename.

Mutation proofs redone from scratch this round against a scratchpad mirror
(never the worktree; each mutant applied once, source sha256 restored and
compared after each). 19 mutants of verify_deployment.py and verify_trelyan.py
all CAUGHT, including A1 (approval compared with itself), S7 (the app read via
--compile-url) and RA, the three the review reported as survivors. VA1, VA2 and
VA3 SURVIVED before this test and are CAUGHT by it.

NOT fixed, and deliberately not papered over: VA4 survives, and so does its
clear-state twin VC4. Both "... program fetched" checks only run once a program
has been read, so neither can fail where it stands; an absent field is NOT
CHECKED instead (db13751). Making them able to fail is a behaviour change to a
CI-visible script that no finding asked for, so it is reported rather than
guessed at. No docstring claims those two can fail.

Also unchanged: cd4051d's subject still over-states what is compared. Rewording
it needs a history rewrite, which this round was told not to do.

Checks: full sdk suite 181 passed, 5 skipped with the KAT armed (a
falcondet1024.dll built this round from the worktree's vendored src); the 5
skips are 4 algo-pqc-kit interop cases with the package not installed and 1
isolated-signer test whose 3.10 premise this interpreter does not meet - no
skip is counted as a pass. The three affected test files: 38 passed.
py_compile on the changed file. contracts/verify_deployment.py run live and
read-only against the deployed app: MATCH on all five components, exit 0.
App-id rule replayed independently over git ls-files with the rule's own
lookaround regex: FROZEN 7, LIVE_CLAIM 17, 23 files mention an id, 0
unclassified, 0 classified files missing. yaml.safe_load on ci.yml, rust-ci.yml,
testnet-followup.yml and testnet-redeploy.yml. The file is LF-only, has no NUL
bytes and is cp1252-encodable.

Security Impact: test-only, outside contracts/. No executable line of
verify_trelyan.py or verify_deployment.py changes, and no contract source,
committed TEAL, ARC-56 spec or deploy path changes. What changed: the reviewer
script's approval-program pin and assembly comparisons are now pinned as able
to fail, so a future edit that makes either unable to fail turns this file red.
What could break: nothing selects on the test file's name. Nothing needs
re-audit.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>