The report is written and every finding's path, line and snippet match the tree. The scratch test is removed, and git status shows only the untracked findings file, so the review changes nothing in the repository.

Audit result: no defects that warrant a code change

I read all six contracts in src/ plus the interfaces, deploy script, pinned protected tests, the Pashov checklist, and the oracle-consumer reference. I also read the Intake v2 and BurnExecutor V2 reference sources for the callback and refund semantics. The 169-test non-invariant suite passes on this tree.

Every state-changing entry point was walked for caller, value moved, and what it trusts. The oracle callbacks are Intake-only and check the pending id, question hash, exact window, panel minimums, chain, signer, expiry and answer shape before writing anything. All IMD-moving functions are reentrancy-guarded. There is no owner, setter, pause, blacklist, proxy, initializer, DELEGATECALL, CALLCODE or SELFDESTRUCT. ETH is only ever the current call's value, forwarded to the executor or refunded. I did not find loss of funds, misdirected payments, broken accounting, or weak access control. None of the listed design decisions is disputed as a defect.

Live inputs verified over public RPCs today. On Sepolia all five constructor addresses have code, the curator is settled, the Intake sells the action for 0.5 TestIMD, and the V1 executor's previewBridge reverts, so the burn rule records BurnSkipped(1) exactly as the brief says. The mainnet counterparts also check out.

Findings written to .imd-findings.json (one low, four info):

• Low. registerSpec checks the mainnet block window against the deployment chain's height. Sepolia is at block 11.9M while the Curator deploy block is 25.77M, so no community spec with a real mainnet window can be registered in the rehearsal. Mainnet behaviour is correct.
• Info. On Sepolia every chain-evidence question names the Sepolia curator address as a mainnet contract, so traits 701 to 1201 will come back as Missed(8). Only trait 1301 and T5 specs can reach Verified in the rehearsal.
• Info. Registry runtime is 15 bytes under the EIP-170 limit. Any adaptation that adds code to it parks the launch.
• Info. The mainnet executor currently quotes 454.9 IMD, so the burn rule will be live on mainnet from the first sponsored claim, a branch Sepolia never exercises.
• Info. Scope statement: what was read, what was checked, and what was not reached (fork suites, invariant suites, a live Sepolia plane quote).

For the adapter: nothing in src/ needs changing, so the adapt step should report zero changes. The rehearsal plan should use trait 1301 for the end-to-end verified path.

Added ADAPTATION.md, the only submitted change. No contract changes were needed.

forge build passed. Seeded forge test: 174 passed, 0 failed, 17 skipped.

The document records all audit dispositions, Sepolia limitations and successful fork checks. The older mainnet fork could not load its pinned block because the RPC reported pruned history. No deployment was broadcast.

launch.json is written and verified. Only that file changed in the tree.

What the manifest declares

• Renderer, no constructor arguments.
• Composer, no constructor arguments.
• Registry with the eight address arguments in ABI order: curator, idmd, imd (Sepolia TestIMD), intake (Intake v2), attester (IMD oracle signer), then $contract:Renderer, $contract:Composer, and the BurnExecutor V1 stand-in. No argument uses $owner, since the contracts have no owner or admin role.

The notes field explains the Sepolia rehearsal, the V1 executor behaviour (BurnSkipped(1) and refund), and restates the documented design decisions as decisions rather than defects. It is well under the 4,000 character limit.

Checks run

• A schema check confirmed exactly the keys kind, contracts and notes, unique identifiers under 32 characters, backward-only contract references, and no zero address.
• A scratch test in test/scratch mirrored the protected probe: all three contracts deployed in one CREATE2 call on an empty chain with chain id 11155111, the predicted helper addresses matched, every stored Registry argument equalled the manifest value, the name and symbol are Sworn and SWORN, every runtime stays under the EIP-170 limit with no DELEGATECALL, CALLCODE or SELFDESTRUCT, and no contract answers owner() or admin().
• The full suite with the verifier's fuzz seed passed: 175 tests, 0 failures, 17 skipped. The skipped tests are the fork tests, which skip when no RPC URL is set.

Adapt step: no change to src/ was needed. The prior adaptation record already states the same three-contract order and argument set, and no check failed, so nothing was modified beyond adding launch.json.

Review complete. The findings file is written and validated, no source files were changed, and the scratch test lives only under test/scratch/.

Outcome

The economics of the Sworn registry hold as designed. I traced every one of the 16 state-changing entry points for the Economic Security, Invariant and Flow Gap failure modes, confirmed the live Sepolia constructor inputs over RPC, and ran the full local suite (174 tests pass). Two findings are recorded in .imd-findings.json, neither critical or high, so no proof file was attached.

Finding 1, low. Spec windows are validated against the deployment chain's block height, at src/Composer.sol:279, while every question is fixed to mainnet. Sepolia's head is about 11.9M blocks and the catalog windows sit above 25.8M, so on Sepolia registerSpec with any current mainnet window reverts with BadSpec("window"). The highest window a Sepolia spec can carry corresponds to mainnet February 2021. Mainnet is unaffected; the rehearsal simply cannot exercise spec registration as specified. A scratch test pins both the Sepolia revert and the mainnet acceptance. Fixing it touches the frozen spec rules, so I left the code alone and flagged it for a scope decision.

Finding 2, info. Any Curator member can spend pool money on catalog traits that are provably false for them. Four of the nine eligible ids are single-wallet ordinals, so a member can waste 0.5 IMD per day and 4.5 IMD lifetime at gas cost only. This is the documented design, recorded as a quantified donor trust assumption, not a defect.

Verified on Sepolia (live reads). The Curator reports settled, the Intake sells the action in TestIMD at 0.5, the IDMD and executor have code, and the executor's preview reverts, giving the BurnSkipped(1) path the brief describes. Two rehearsal notes went into the coverage rows: the Sepolia IDMD has no minted tokens, so upgradeSponsored cannot be exercised there until one exists, and the Sepolia Intake grants a 1,000,000 gas callback stipend rather than 200,000, which is harmless.

Invariants checked and holding. Registry IMD balance changes only through mint, spec, sponsor inflows and pool outflows. Paid paths pull exactly what they forward. The registry keeps no ETH on any burn or refund branch. No third party can lock another wallet's pending pair.

Not reached. Fork tests against the mainnet BurnExecutor V2 were not run, since no archive RPC is configured here, and Renderer internals are outside this area.

Review complete. The findings file is written and the tree is otherwise unchanged (my scratch tests are removed).

Result: one low finding, no critical, high or medium defects in the math, boundary or numerical-gap area.

Finding 1 (low), src/Registry.sol:633. The spec-registration window guard mixes two block-number scales. Every spec window is a mainnet block range by design, but registerSpec validates it against the deployment chain's block.number. On mainnet the scales coincide. On Sepolia the local head is about 11.9M while the game's windows sit at 25.77M to 25.79M, so every community spec about the WhitelistCurator game, or about any contract deployed after early 2021, reverts with BadSpec("window") in the rehearsal. The same call succeeds on mainnet. No fee is lost, and the catalog traits are unaffected because their windows are constants. ADAPTATION.md already records this as a retained limitation. I reported it anyway because it is a concrete failing input on the Sepolia launch and leaves community specs effectively untested in the rehearsal. Both fix options are design decisions, so the code was left alone.

What I checked and found sound:

• Callback arithmetic: answer length cap of 2112 bytes is exactly 64 addresses, the T3 envelope is validated word by word before the uint16 cast, threshold comparison is exact at the uint256 maximum, expiry and issuedAt edges behave as documented.
• Shared facts: the hash match forces the caller's list to equal the stored length, so head indexing is in bounds. Position 31 is found and position 32 is rejected for head 32.
• Pool and counters: the IDMD counter stops at 9, the daily allowance uses a UTC day in uint64, and all three invariant suites pass.
• Composer: every maximum-size spec that passes validation still composes under the 1,000-character question and 512-character definition caps across all five kinds.
• Renderer: the step, ring, honey-pair and end-point index math stays within the generated tables at every edge.
• Live Sepolia reads: the Curator is settled, IDMD and TestIMD have code, the Intake quotes 0.5 IMD, and the V1 executor lacks the preview selector and reverts, so free claims skip the burn and refund as described.

One observation outside the code: the Sepolia Intake grants a 1,000,000-gas callback stipend versus 200,000 on mainnet, so a successful rehearsal completion does not prove the mainnet gas budget. The existing cold-gas tests cover that case.

Coverage: all 16 listed entry points have a row, plus three invariant rows. Tests run: 169 unit tests and 5 invariant tests passed, 14 scratch probes passed.

The review is complete. .imd-findings.json holds three findings and a 19-row coverage record, and no file under src/, script/ or the configuration was changed. The two proof tests live in test/scratch/, which git excludes.

What I found

1. Medium: registerSpec checks a mainnet window against Sepolia's block height. Every question is about Ethereum mainnet, so a spec's window is in mainnet block numbers, but Registry.registerSpec passes the deployment chain's block.number to the window validator. Sepolia is at block 11.9M while mainnet is at 26.2M, so the catalog's own window and any window on the Curator are refused with BadSpec("window"). The rehearsal cannot register any realistic community spec. Proof test test/scratch/WindowOnSepolia.t.sol fails on the current code with that revert.

2. Medium: catalog oracle questions on Sepolia name a contract that does not exist on mainnet. specOf builds every catalog question from catalogSpec(traitId, address(curator)), so on Sepolia the question asks for events "emitted by the contract 0x0919ba50… on Ethereum mainnet". I confirmed with a live mainnet read that this address has no code there. Every catalog chain trait is therefore an honest answer of 0 and a Missed(8), Top Weights can never be stored, and the 1301 question deviates from the fixed mainnet address TEMPLATES.md pins. The rehearsal never exercises the success path of onResult. Proof test test/scratch/QuestionTargetOnSepolia.t.sol fails on the current code.

3. Info: the Sepolia Intake gives callbacks 1,000,000 gas, not the 200,000 the documentation states, so Sepolia deliveries cannot stand in for mainnet gas evidence.

What held

Live reads against Sepolia show the constructor will pass on the brief's arguments: all four dependencies have code, the Curator is settled and exposes every view the registry reads, the Intake quotes 0.5 IMD for the test token and has requestWithFailure, the executor has code and its previewBridge() reverts as the brief expects. The callback ordering, pending-pair lifecycle, abandon rules, pool accounting, shared-fact hashing, refund path and ERC-721 surface all traced as intended. None of the stated design decisions is disputed.

Not reached

The Renderer's image bytes were not re-verified against the goldens, and the full test suite was not rerun in this budget.

Review complete. The findings file is written and verified against the tree, and no source file was changed.

Outcome. The permission model of src/Registry.sol holds against the Access Control, Trust Gap and Asymmetry checklists. The intake-only callbacks, the pending-id and question-hash binding, the claimant-only abandon rule, the paired request/fulfil and upgrade/requestSharedFact surfaces, and the no-ETH invariant all traced clean. The Sepolia constructor inputs were verified live: all five addresses have code, the Curator reports settled, the Intake prices the action at 0.5 TestIMD, and the V1 executor's preview reverts so the burn rule skips with code 1. The attester is an EOA matching the protocol reference.

Findings written to .imd-findings.json:

• Medium, with a failing Foundry proof. The spec window guard reads the deployment chain's block height for a window that lives on mainnet. Sepolia is at block 11.9M while the Curator game sits at mainnet 25.7M, so registerSpec reverts with BadSpec("window") for every realistic spec on this launch. The rehearsal cannot exercise community specs at all. On a chain taller than mainnet the guard inverts and accepts unmined windows. Mainnet itself is unaffected. The proof in test/scratch/SepoliaSpecWindow.t.sol fails on the current code with that revert.
• Info. The Sepolia Curator and IDMD stand-ins expose open setters, confirmed by simulating them from an arbitrary address. Anyone can self-grant membership or an IDMD token and draw from the Sepolia pool. TestIMD is free, so no value is at stake, but the membership gate is not rehearsed.
• Low, reported as a disputed design decision. The fixed attester, Intake, action and token contradict the oracle-consumer reference, which requires each to be owner-settable, and the ECDSA-only check rejects the reference's ERC-1271 rotation path. A key rotation leaves the sponsored path spending pool IMD on answers that can never verify, with no recovery.

Coverage. All 16 listed entry points have a row, plus two invariant rows. Thirteen entry points hold, registerSpec carries finding 1, and the two sponsored claim paths carry finding 2 for the Sepolia trust gap only.

Not changed. Nothing in src/ was adapted; no check failed in the existing suite, which passed 169 tests outside the fork and invariant sets. The adapt step made no changes.

Added Sepolia deployment, failure-path, oracle, and accounting invariant tests.

forge build and seeded forge test pass: 192 passed, 17 optional fork tests skipped. New invariants exercised 24,576 calls.

Reported one low-severity mainnet-window validation defect with a runnable proof in .imd-findings.json.

No production code or configuration changed.

The review is complete and .imd-findings.json holds six findings and an 18-row coverage record. The working tree is clean apart from that file.

What I kept, after reproducing each against the code

• Medium, src/Registry.sol:633. Five specialists reported the same root cause, merged into one finding. registerSpec bounds a mainnet block window with the deployment chain's height. On Sepolia the Curator game window and every realistic mainnet window revert with BadSpec("window"). I ran all four attached proofs and each fails for exactly that reason. The permissions specialist's proof is attached, since it covers both the T1 and T5 shapes.
• Medium, src/Registry.sol:378. Catalog questions name the deployment chain's Curator as the mainnet contract. I dumped the composed Sepolia bodies and confirmed they ask about events of the Sepolia stand-in "on Ethereum mainnet", where that address has no code. The 1301 question also falsely calls the mainnet deploy block that contract's deploy block. The plane's free wording check accepts both questions with no blockers, so requests are paid and end as guaranteed misses. The flow specialist's proof is attached.
• Low, src/Registry.sol:561. The disputed design decision on fixed attester and Intake, reported as the brief asks and not adapted. My scratch test confirmed that after a signer rotation the sponsored path still spends pool money on a guaranteed reason-2 miss.
• Info, three items. The Sepolia Curator and IDMD stand-ins accept setter calls from any EOA, confirmed by live simulation. Sepolia Intake callback gas is 1,000,000 against the 200,000 that INTEGRATION.md states. Pool spending on single-wallet ordinals is a quantified trust assumption, which the docs already describe as the design.

What I verified beyond the specialists

• The existing suite passes with 192 tests and 17 skipped fork tests.
• Live Sepolia reads show the constructor's non-floor checks pass on the launch inputs. The Curator is settled, the Intake quotes 0.5 TestIMD, and the V1 executor has code and reverts on previewBridge.
• Sizes fit: Registry runtime is 24,561 bytes with 15 bytes of headroom, init code 26,610 bytes.
• The manifest has only the three schema keys, correct argument order, backward references, and 1,922 characters of notes.
• My own pass over the callback, shared-fact, abandon, pool and ERC-721 paths found nothing the specialists missed. Each entry point has a coverage row with its reason.

Both reopened findings reproduced on the accepted tree and are fixed; the four advisory findings are answered without code changes except one documentation correction.

What reproduced and what changed

• Window guard (9a97dce5, medium) and audit 91cf6828. The reviewer's proof failed on the starting tree with BadSpec("window") for both the game window and the T5 deploy-block spec on Sepolia. Composer.validateSpec compared mainnet block heights against the consumer chain's height. It now bounds the window by the mainnet height: the registry's block.number on chain 1, unchanged, and elsewhere Composer.mainnetHeightBound(), one block per 12-second slot since the merge. That bound is never below the real height and about 0.3% above it, which I checked against five recorded mainnet heights read live. It also closes the Base inversion the finding mentioned.
• Question target (206a260d, medium) and audit 25e1b004. The proof failed: catalog questions on Sepolia named the Sepolia Curator as a mainnet contract. catalogSpec and the 1301 parenthesis now use a MAINNET_CURATOR constant, as TEMPLATES.md already wrote it. The registry's curator argument serves direct reads only. Sepolia bodies now equal the mainnet fixtures with only the consumer chain id changed and carry the plane's recorded question hashes.
• Registry untouched. Both fixes live in src/Composer.sol; the Composer's two address parameters stay in the ABI, unnamed. Registry runtime is byte-equal at 24,561 bytes. Composer is 23,655 bytes with 921 of headroom.

Advisory findings

• 7e76e9b8 (callback gas): reproduced live, Sepolia 1,000,000 vs mainnet 200,000. INTEGRATION.md and README corrected.
• 1a09ea86 (fixed attester, no setter): disputed per the brief's explicit decision, code unchanged. The pool-drain consequence is added to INTEGRATION.md's "What can kill the registry".
• d543592d and ada37f2e: rehearsal trust gap of the stand-ins and documented pool design, recorded in ADAPTATION.md, no change.

Verification

Check	Result
Reviewer proofs on starting tree / now	0 of 3 pass / 3 of 3 pass
Full seeded forge test (proofs included)	185 passed, 0 failed, 17 fork skips
New test/SepoliaRehearsal.t.sol	8 tests
gen_template.py --check, tools unittest	28 artifacts match, 18 passed

The opt-in burn fork suite could not run this round: the public RPC no longer serves state at its pinned block. The burn rule is untouched. All eleven finding ids are answered in .imd-responses.json, and ADAPTATION.md lists every file changed and why.

The existing launch.json is correct as it stands, and no change was required for this revision. The brief listed no findings to address, so I verified the accepted manifest against the source, the protected checks and the schema rather than rewriting it.

What I verified:

• Contracts and order match the brief and the accepted source: Renderer and Composer have no constructor, then Registry.
• Registry's eight constructor arguments match the declaration order in src/Registry.sol:188 (curator, idmd, imd, intake, attester, renderer, composer, burnExecutor), with the two helper references pointing backward to earlier entries and every static address nonzero.
• No owner roles exist in any of the three contracts, so no argument uses $owner. This satisfies the protected owners check that forbids the factory or IMD as an owner.
• Schema shape holds: only kind, contracts and notes, every argument a string, identifiers under 32 characters, and notes at 1,922 characters.
• Build and tests pass under the verifier's fuzz seed. The only skipped tests are the Sepolia fork tests, which need an RPC this machine does not have.

Check	Result
forge build	ok
forge test	182 passed, 0 failed, 17 skipped (fork only)
Working tree	clean, no file changed

Adapt step: no changes were made to src/ or any other file. The documented design decisions in the brief were left as they are and none of the checks disputed them.

The findings file is excluded by the harness's own git exclude list, so it is read from disk as the brief intends. Everything is in place.

Outcome: the revision is complete and the full suite passes with the verifier's seed.

Check	Result
forge build	passes
forge test (seeded, offline)	214 passed, 0 failed, 17 skipped (optional fork tests) across 23 suites
Sepolia invariant campaign	256 runs, 24,576 handler calls, 0 reverts

What this round responded to. The adapt step fixed the window finding I reported last round, plus a Curator-naming finding, in src/Composer.sol. Off mainnet the guard now bounds a window by a slot-clock mainnet height, and every catalog question names the mainnet Curator. My tests had never asserted the old behaviour, so none broke, but the notes were stale and the new code was untested through the real launch.

What changed in test/:

• SepoliaCommunity.t.sol (new, 9 tests through the exact-address launch fixture): the seven catalog questions carry the plane's recorded question hashes and name the mainnet Curator, never the Sepolia one; the game windows register at Sepolia height 1 and at the maximum height; the guard is exactly the bound at both edges, fuzzed over time and height; refused specs take no id and pull no fee; validateSpec ignores its height argument only off mainnet; spec fees land in the pool; a T3 spec is payable only through the shared-fact path.
• SepoliaCommunityOracle.t.sol (new, 4 tests, signed with the test key in the Sepolia domain): a T5 community spec verifies cold under the stipend; a T1 spec misses on threshold, window, question hash and Sepolia evidence and then verifies; a T3 fact applies within its head; mainnet still refuses a window at its own height.
• SepoliaInvariant.t.sol: two new handler operations, community registration (valid windows and windows at or past the bound at random Sepolia heights) and community requests, with ledger checks for dense ids, immutable specs and no unsigned credential, plus a second positive-control sequence.
• Sepolia.md: updated to record the fix and the new coverage.

Finding reported in .imd-findings.json, severity info: the slot-clock bound runs about 0.3% ahead of mainnet's real head, so on Sepolia a registrant can register and pay to ask about a window up to 76,424 blocks (about ten days) past the real head at the recorded timestamp. It is the documented design and has no effect on chain 1, so I did not assert it as correct in a test. No critical or high defect was found in the revised code.

Review complete. The findings file is written and validated; nothing in src/ was changed.

Settled from the previous round

• Window guard (medium, fixed). Composer.validateSpec now bounds a spec's mainnet window by block.number on chain 1 and by a slot-clock upper bound elsewhere. All three attached window proofs pass on the revised code, and Registry bytecode is unchanged.
• Catalog question target (medium, fixed). catalogSpec and the 1301 parenthesis now name the mainnet Curator on every chain, while direct-read traits still read the deployment chain's Curator. Both attached proofs pass; Templates.t.sol confirms mainnet bodies stay byte-exact.
• Sepolia callback gas (info, fixed). INTEGRATION.md now records the 1,000,000-gas Sepolia stipend beside mainnet's 200,000. Dropped.
• Ordinal griefing (info). Documented design, now recorded in ADAPTATION.md with the 4.5 IMD per member figure. Dropped as not a defect.

Kept in the report

1. Low, disputed decision, code unchanged. Fixed attester, Intake, action and token with bare ECDSA checking. The brief requires it be reported and left; the pool-drain consequence is now documented. For the judge to weigh.
2. Info, rehearsal trust gap. The Sepolia Curator and IDMD stand-ins have permissionless setters, so the Sepolia pool is spendable by anyone. Not Sworn's code; recorded in ADAPTATION.md.
3. Info, new from the fix. The slot-clock bound runs about 76,000 blocks ahead of the real mainnet head off chain 1, so Sepolia can register and pay for a window mainnet has not mined yet. Reproduced with a scratch test; documented as the accepted tolerance.

Verification run

Check	Result
Attached proofs (5 files)	7 passed, 0 failed
Full suite excluding scratch	214 passed, 17 skipped (fork tests)
Registry runtime size	24,561 B, under the 24,576 limit

Coverage answers all 16 entry points as holds, plus rows for the manifest and the fix's diff. No blocking finding remains outstanding.