The review is complete and the findings file is written.

Outcome: no critical, high or medium defect in the registry as it arrived. The file .imd-findings.json holds two low findings and one info entry with the coverage statement.

Findings

• Low, self-challenge front-run (line 294). A listed project's beneficiary can watch the mempool and file its own challenge ahead of any outsider's. The outsider's call reverts with AskOpen, and the beneficiary's bond comes back to itself on a signed yes, so each cycle costs it only the 0.5 IMD fee. The handoff interval's comment promises a retrying challenger always gets a question filed, and this route breaks that promise. A scratch test runs three cycles and confirms the net cost is exactly three fees.
• Low, application-slot griefing (line 252). Anyone can hold a project's application slot with a doomed application naming themselves as beneficiary. The owner's own application reverts until the panel rejects, and there is no cooldown after a rejection, so the attacker can repeat at 0.5 IMD per round.
• Info, coverage. Lists what was read, what could not be reached, and what was measured.

What was checked and held

• Build and the offline suite pass with 172 tests, 8 fork tests skipped for lack of an RPC.
• Callback access, request ownership, one-time consumption, issuedAt tolerance, panel 15 of 11, bond accounting and checks-effects-interactions all trace through guards as the brief describes.
• Generated text stays within the oracle's limits. The longest rule is 472 of 512 characters and the questions are about 1,100 of 2,000.
• Runtime is 22,736 bytes with no forbidden opcodes, and the manifest matches the brief's seven constructor arguments in order.

Not reachable: the live Intake v2, test IMD and Stacker on Sepolia. The Intake's getter shape, the 1M callback gas and the paid door's acceptance of the body rest on the fork test and test run 3's history rather than on anything I could run here.

No tracked file was changed. The two scratch tests live under test/scratch and are not kept.

The build is clean with no notes on the new test, and the working tree holds only the three intended paths.

Outcome. The registry on this branch already meets every launch rule and carries the fix the brief asks for, so src/ is unchanged. I added the adaptation notes, a reproduction test for the audit's two lows, and the README entry for test run 4.

What I verified

• forge build passes with the project's own configuration (solc 0.8.26, cancun, 10,000 runs, no bytecode hash).
• forge test with an empty environment: 174 passed, 0 failed, 8 skipped (the fork tests, which need RPC URLs). The suite is now 182 tests.
• The constructor takes 7 static arguments, makes no external call, and deploys on an empty chain in test/Deployment.t.sol. The runtime is under EIP-170 and has no forbidden opcodes. No owner exists, so nothing can fall to the factory or IMD.
• The existing launch.json matches the brief exactly and the deployment test accepts it. I did not touch it, the build configuration, or anything under .github/.

The audit's two lows. Both reproduced against the mock Intake exactly as described, and I left the contract as it is. The self-challenge front-run is the finding test run 3's judge accepted as a design limit, and the doomed-application slot is a known limit in docs/design.md. The mitigations the audit offers are bypassed by a second wallet or require a project-owner notion the registry deliberately lacks, and the only effective one changes the defended bond's destination, which the brief fixes. test/RegistryAuditLows.t.sol pins what each limit costs the attacker and what it cannot do. ADAPTATION.md gives the full reasoning.

Left open for after deployment. The README's "Sepolia test run 4" row says the address is to be filled in once live, since it is only known after the launch. No stand-in was written.

The review is complete and the findings file is written.

Result: no substantiated economic defect in the ProjectRegistry for this launch. The findings list in .imd-findings.json is empty, with a 13-row coverage record covering all 9 listed entry points plus three invariants and one unreached item.

What I checked, against the Economic Security, Invariant and Flow Gap guides:

• Value flows: the fee is pulled at the live Intake price and approved exactly, so the Intake can never reach held bonds. Each challenge holds exactly one bond, which leaves exactly once, to the beneficiary pinned at ask time or back to the asker. The registry balance always covers open bonds plus owed bonds.
• The owed-bond fix: a refusing token records the bond instead of blocking settlement. I measured the worst callback paths at 97k to 104k gas, about half the 200k mainnet stipend.
• Dependency failure: a stopped Intake, a paused or blocklisting asset, or a withheld answer strands no funds. Open questions settle or expire, and refused payouts stay claimable to any wallet.
• Handoff and front-running: a pending challenge's bond cannot be redirected, and a beneficiary can refuse a challenge by handoff at most once per day.
• The full suite passes offline (174 passed, 8 fork tests skipped).

Known limits I did not re-report: a beneficiary's self-challenge and a stranger's doomed application each occupy the project's single question slot for the fee alone. Both are documented as accepted design limits in docs/history.md and ADAPTATION.md and are pinned by existing regression tests.

Unreached: the live Sepolia fork tests could not run here without an RPC, so the live Intake's requests() tuple shape and the 1M callback gas rest on the earlier fork run recorded in the README.

The task is complete. The findings file is excluded from git by the harness's own exclude rule, which is expected since the harness collects it from the working tree.

Outcome: forge build and forge test pass. The suite now has 194 tests: 186 run offline and 8 fork tests skip without an RPC. I also ran the 8 fork tests against live Sepolia and mainnet through a public endpoint, and all passed.

What I added (all under test/):

• test/RegistryBondOwedInvariant.t.sol: invariant tests over random call sequences for the value the registry holds, with a token whose refusal to pay each wallet flips at random (by reverting or returning false). Applications, challenges, answers delivered with 200k gas, failures, expiries and claims interleave across 3 projects and 4 actors. Invariants: the registry holds exactly the open bonds plus what it owes, each wallet is owed and holds exactly its signed entitlement, the token is conserved, and no approval is left to the Intake. A deterministic path proves the campaign reaches every owed outcome. 128 runs at depth 48, zero reverts.
• test/RegistryTryTransferEdges.t.sol: the registry's own transfer read in _tryTransfer judged on every return shape. No return data and over-long data count as paid. false, a non-boolean word, a one-byte return, an empty revert and a 4 KiB revert are owed and still settle within 200k gas. Also: an owed bond is settled once (replayed answer, late failure, expire, consumed request id all refused), survives relisting and later payouts, only the creditor claims, a failed claim keeps the debt, and a claim never touches an open bond.
• test/ADVERSARIAL_COVERAGE.md: two rows describing the new files.

Live facts confirmed on Sepolia at block 11,897,538: the Intake sells the question for 0.5 test IMD, the live Stacker's IMD and SIMD are the launch #1129 pair, and test run 3's registry has bond 5e18 and cooldown 3600, matching launch.json.

Finding reported in .imd-findings.json, severity info only: claimBond accepts the registry's own address as destination, which zeroes the debt and strands the tokens with no owner to sweep them. It is self-inflicted and costs only the caller, so I did not treat it as a defect in the agreed design. I found no defect in the owed-bond fix itself. I did not change src, foundry.toml, launch.json or the README; the README's "Sepolia test run 4" row waits on the live address and is outside my write paths.

Review complete. The findings are in .imd-findings.json (valid JSON, 1 finding, 12 coverage rows). No tracked file changed; the findings file and test/scratch/ are excluded by the repository's own git exclude list.

What I audited. The math, boundary and numerical-gap surface of src/ProjectRegistry.sol and the attestation library, against the Pashov Math Precision, Boundary and Numerical Gap guides. The registry has no division or scaling at all, so the surface is time boundaries, text caps, uint64 casts, the oracle fee and bond additions, callback gas, and the return-data decoding of the bond transfer.

Result: no defect that affects this launch. One info-level item for the mainnet copy of this code:

• Expensive refusal defeats the owed-bond guarantee (src/ProjectRegistry.sol:456). The bond payout forwards all remaining gas to the token. A token whose refusal burns the forwarded gas instead of reverting early leaves the registry too little to record the owed bond, so the 200k callback itself fails and the signed verdict is lost until expire a day later. Not reachable here: the oracle asset is immutable, and I read the live Sepolia test IMD as a 1,821-byte plain ERC20 with no proxy slot. A proof test that fails on the current code is embedded in the finding; a bounded gas forward is the suggested fix.

Boundaries verified with numbers, on this tree and live:

Check	Measured	Cap
Longest panel rule (feeGuard)	472 bytes	512
Worst-case challenge question	1,113 bytes	2,000
Worst-case body	3,826 bytes	16,384
Callback gas, largest path (defended, live token, fresh recipient)	128,956	200,000
Runtime size	22,736 bytes	24,576
launch.json notes	1,580 chars	4,000

The deadline, tolerance, cooldown and handoff comparisons are all exact and complementary at the boundary second. On a Sepolia fork the live Intake's requests() decodes as the registry expects, and a real bond was paid and refunded through the 200k callback. Test run 2's live registry has already accepted a signed answer filed under chain 1, which settles the WrongPanel chain check. The manifest matches the brief's seven arguments in order.

Coverage. All 9 listed entry points have a row: 8 hold, onOracleResult carries the info finding. Not reached: the mainnet IMD token's transfer behaviour, which I could only take from the README's description.

The review is complete and recorded in .imd-findings.json. No source, test, or configuration file was changed. The scratch reproduction was removed.

Outcome of the permissions audit (Access Control, Trust Gap, Asymmetry) on the ProjectRegistry

The permission model holds. Every state-changing entry point was traced for its guard, state writes and failure paths, and the full offline suite passes.

Check	Result
Offline tests	174 passed, 0 failed, 8 fork tests skipped
Manifest	matches the brief exactly, notes 1,580 chars

Findings recorded

• Low, open-question slot griefing. One question per project is first come, first served, and holding it costs only the 0.5 IMD fee. The beneficiary's second wallet can front-run every hostile challenge with a bland self-challenge whose bond comes back on a yes, so the hostile challenger's reason never reaches the panel. Anyone can likewise keep an unlisted project out by front-running the owner's application with a bogus one. I reproduced both sequences offline over five rounds. No funds are lost and an honest panel can still delist on a self-challenge, so the severity is low and the mitigation is a design decision for the author.
• Info, immutable oracle wiring as a trust assumption. The brief asks for no owner, and the code honours it, but the oracle-consumer reference says the signer, action id and intake must be owner-settable. If the signer rotates or oracle-1 is retired, every listed project stays listed for good and nothing new can be listed. Recorded as a documented dependency, not a defect.

What held under review

• The callback accepts only the Intake, only its own open request, each attestation once, signed for this contract after the ask, from a 15-of-11 panel. The yes and no branches write mirrored state.
• The failure hook and expire clear symmetrically and never move value beyond returning the challenger's own bond.
• The handoff rule blocks any change of the bond destination while a question is open, and the legacy challenge entry point is closed for good after the first handoff.
• Bond accounting conserves: each close path pays or owes exactly one bond, and claimBond zeroes before paying.
• The launch manifest, constructor argument order and the Deployment test agree with the brief.

Coverage. All nine listed entry points have a row, plus two invariant rows. Nothing was left unreached.

The review is complete. .imd-findings.json holds one substantiated finding and a coverage row for every listed entry point plus three invariant rows. No tracked file was changed; only the findings file and two scratch tests exist, both excluded from git.

Outcome: no defect of medium or higher severity in the registry's control flow. The one finding is informational.

Finding 1 (info) at src/ProjectRegistry.sol:460. The new bond-payment helper claims SafeERC20 parity but diverges for a token whose transfer returns 1 to 31 bytes. SafeERC20 reverts there. The registry instead treats a completed transfer as refused and also records the bond in bondOwed, so it owes a bond it no longer holds. A scratch test under test/scratch/ShortReturnToken.t.sol shows the double accounting. It is unreachable in this launch because the oracle asset is immutable and fixed to the Sepolia test IMD, which I checked live and which is a plain OpenZeppelin ERC20 with no owner, pause or blocklist. I reported it because that parity claim is the justification for the owed-bond fix this run exists to test.

What I verified against the live chain, beyond the offline suite:

• The eight fork tests pass against Sepolia through a public RPC. An application pays the real Intake v2 0.5 test IMD and registers both selectors.
• The live Intake's record for test run 3's cleared request decodes exactly as the interface expire relies on, with the fourth word completed = true.
• The oracle's real rehearsal attestation, signed by the launch's signer for its consumer address, replays through onOracleResult in a registry deployed at that address and lists the project. That confirms the EIP-712 domain, struct, chain id 1 and panel 15/11 checks against what the live oracle actually signs. See test/scratch/LiveAttestation.t.sol.
• The manifest has only the schema keys, seven arguments in declaration order matching the brief, notes under the limit, and a 22,736-byte runtime without forbidden opcodes.

Not re-reported: the self-challenge slot-taking and the doomed-application slot-holding, both previously judged and accepted as design limits and now pinned by the last contributor's tests. The beneficiary and rate rules remain panel policy rather than contract enforcement, as the design states.

Coverage: all nine entry points have a row. Eight hold. onOracleResult and the balance invariant point to finding 1. Stacker.credit is outside this launch and is never called by the registry.

The review is complete. The findings file is in place and the tree shows no tracked-file changes (scratch tests and the findings file are untracked, which git status confirms as clean).

Outcome: no blocking defect. The registry as built, and the manifest as written, deploy and behave as the brief describes. Every specialist finding reproduced against the code, and I kept all five after rerunning each one, at the severities below. My own pass over the nine entry points, the manifest, the factory limits, and the oracle body found nothing the specialists missed.

Findings written to .imd-findings.json:

1. Low, slot griefing. One open question per project is first-come. A beneficiary's second wallet can front-run every hostile challenge with a bland self-challenge for 0.5 IMD a round, and anyone can keep an unlisted project from ever being listed the same way. No funds lost. Reproduced offline with the mocks in a scratch test.
2. Info, unbounded gas to the token. The bond-payment call forwards all remaining gas, so a token that burns gas before refusing still makes the callback run out and holds the question open. The specialist's proof fails on this code for exactly that reason and is attached. Unreachable with the fixed Sepolia test IMD or mainnet IMD.
3. Info, short return data. A token that moves tokens and returns 1 to 31 bytes is treated as a refusal, so the bond is paid and recorded as owed at once. Reproduced in a scratch test. Unreachable with the fixed asset.
4. Info, claimBond to the registry. Passing the registry's own address as destination zeroes the debt and strands the tokens. Self-inflicted only.
5. Info, trust assumption. Signer, Intake, action and asset are fixed at deployment as the brief requires, so a signer rotation or retirement of oracle-1 freezes the registry with current listings in place.

Coverage: all nine entry points answered. Four map to the findings above, five hold. Three extra rows record the manifest and factory checks (seven string args in order, notes at 3,030 of 4,000 characters, runtime 22,736 bytes, no forbidden opcodes), the oracle body limits, and the full suite result of 186 passed with 8 fork tests skipped offline.

Not verified: the live Sepolia state (Intake price, Stacker bytecode) since the fork tests need RPC URLs that were not set. The README's test run 4 address is correctly left as a post-launch step.