Implemented LaunchToken and Tribunal, with vendored dependencies, tests, ABI exports, and deployment documentation.

Verified: forge build, all 72 tests, and forge fmt --check pass.

README documents owner setup, oracle trust, payouts, and the public fallback’s limits.

Created launch.json for Verdict and Tribunal with matching constructor arguments, $owner, and the required pool values.

Checked manifest fields against the requirements and compiled ABIs. forge build passed with existing lint warnings; forge test passed all 72 tests.

Only launch.json is changed for submission.

Review complete. The findings file is written at the repository root and no source, test, or configuration file was changed.

Outcome

Two findings, 25 coverage rows (all 24 listed entry points plus two invariants), one Foundry proof. The existing suite passes 72 of 72 tests.

Finding 1, medium: the owner can resolve markets through an instant Intake switch. A market's answer is authenticated only by "msg.sender is the market's snapshotted Intake and the request id is the one it returned." The signature check proves the oracle signer signed something for this consumer, not which request, and the oracle-consumer reference says anyone can buy such a signature for 0.5 IMD. The brief guards the signer with a 48-hour schedule, but setIntake at src/Tribunal.sol:151 rewrites the pairing in one transaction, and every market created afterwards snapshots it. The unprivileged amplifier is that createMarket cannot pin the configuration the creator saw, so the owner can front-run a creator's transaction. The proof test in test/scratch/OwnerIntakeResolves.t.sol deploys an owner-controlled Intake, opens a market in the same block, takes bets, and settles it NO with a genuine signer signature. It fails on this tree with "owner-controlled Intake settled the market" and passes once the Intake, action and payment setters follow the same schedule-then-activate pattern as the signer. Rated medium because earlier markets keep their snapshot and the change is publicly visible.

Finding 2, low: price equality blocks creation after renounce. The check at src/Tribunal.sol:212 requires the live Intake price to equal the stored one. After renounceOwnership, a published price move makes every createMarket revert forever. No funds are at risk, so it is a liveness note with a suggested documentation or tolerance fix.

What held in my area. Betting, resolution requests, both callbacks, the public retry, voiding, claiming, signer scheduling, token locking and the two-step ownership all traced cleanly against the Access Control, Trust Gap and Asymmetry guides. The claim arithmetic conserves the pools plus bond, the burn pays once, and the exported ABIs match the compiled ones exactly. The 200,000-gas callback claim is backed by a cold-storage test in the project's own suite.

Not reached. The launch manifest does not exist yet, so no manifest review was possible. The README's resolved owner address and its 88% pool figure were not verified against the brief and are outside my area.

The findings file is present and intentionally excluded by the repository's own git exclude rule, the scratch directory is removed, and no other file changed. The review is complete.

Outcome: the payout, time and parser arithmetic hold. I found no defect of medium or higher severity in the assigned area. Two low findings are recorded in .imd-findings.json, each with a concrete reproduction that I ran in Foundry before deleting the scratch test.

What I verified in depth (Math Precision, Boundary, Numerical Gap guides):

• Claim math: fee is floor of the losing pool over 100 taken twice, winners get mulDiv floors with the last winner receiving the residual, and the sum of all claims equals winning pool plus losing pool plus bond exactly. The liability counter returns to zero. No underflow is reachable in the residual branch because summed floors never exceed the exact profit.
• Time bounds: the creation bound on resolveAfter keeps every later 7-day addition inside uint64, and the request window complements the void window exactly at the deadline.
• Callback gas: the cold result callback measured about 90k of the 200k stipend with 120k forwarded to the self-call, so the EIP-150 cap cannot cause a silent shortfall.
• The JSON body parser: overflow-safe digit accumulation, duplicate-key bitmask with correct operator precedence, uint64 window bound, UTF-8 overlong and surrogate rejection, trailing data and trailing comma rejection. The slither uninitialized-local lines are zero-initialised locals, not defects.
• Exported ABIs for both contracts are byte-identical to the compiler output. No launch.json exists yet, which is expected at this stage.

Findings reported (both low):

1. A body with validForSeconds of 60 is accepted, so a signed and agreed verdict delivered 61 seconds after issuance is refused, cannot be retried, and the market voids with the 0.5 IMD fee spent. Reproduced with a mock Intake.
2. setVerdictToken validates only code presence before locking forever. Locking a non-token contract address makes every createMarket and bet revert permanently. Reproduced by locking the Tribunal's own address.

Coverage: all 24 listed entry points have a row, 22 hold, 2 reference the findings, plus two invariant rows. The full existing suite passed with 72 tests.

The review is complete and the findings file is in place.

Result: .imd-findings.json holds 4 findings and a coverage row for all 24 listed entry points plus two invariants. The existing 90-test suite passes on the tree. I changed no project files; only test/scratch/ (two reproduction tests) and the findings file were written.

Findings, by severity

• Medium, src/Tribunal.sol:151. setIntake takes effect immediately with no delay or snapshot protection. The Intake is the only authority that can bind an attestation to a market or void it, so an owner that installs an Intake it operates can void any later market with unsigned failure data, or settle it YES or NO by delivering a genuinely signed but unrelated attestation. The brief says the owner cannot resolve markets and gates signer changes behind 48 hours. The attached proof test fails on the current code with the market settling YES.
• Low, src/Tribunal.sol:261. requestResolution is callable by anyone on empty or one-sided markets, where the verdict cannot change payouts. A call spends the creator's 0.5 IMD and resets the deadline, so refunds and the bond can be delayed up to 7 extra days for the cost of one transaction. Reproduced in a scratch test.
• Low, src/Tribunal.sol:225. The title is stored independently of the oracle body. A creator can advertise one question and have the jury answer a trivially known one, taking the opposing pool. Reproduction gives exact inputs.
• Info, src/Tribunal.sol:264. For time-varying questions with relative windows, whoever calls requestResolution first within the 7-day window picks the evidence window and thus the outcome. Inherent in the brief, reported as a trust assumption.

Area coverage. Payout conservation, last-winner residual, fee split, refund paths, escrow accounting, exact-pull delta checks, snapshotting of oracle config and signer, request-id binding, replay, and timeout flows were traced and hold. I did not examine the Intake's real request amount semantics or whether panel-evidence attestations carry chainId 1, since neither is in the tree; both are leads for the service side rather than findings.

Added four test suites covering failure paths, oracle authentication, escrow isolation, token allowances, and stateful custody invariants.

Validation passed: forge build and forge test — 96 passed, 0 failed. New invariants exercised 24,576 random calls and verified all outstanding claims remain recoverable.

All changes are within test/.

The findings file is in place at the repository root (ignored by git by design, as the harness expects), no source files were changed, and the scratch tests are removed.

Review result

I audited the Tribunal launch (Execution Trace, Periphery, First Principles guides) and found no critical, high or medium defects. Three low findings are recorded in .imd-findings.json, each with a concrete reproduction I verified with scratch tests. The coverage record answers all 24 listed entry points plus three invariant/periphery rows.

Findings (all low)

1. Jury fee spent on irrelevant answers. requestResolution is permissionless and spends the creator's 0.5 IMD even when the market has no bets or only one side, where claim refunds everyone regardless of the verdict. A non-participant can burn the creator's fee on an empty market that would otherwise have refunded it at the open deadline. Suggested fix: void such markets directly without calling the Intake, keeping the fee refundable.

2. Signer snapshot strands open markets on rotation. Each market pins the signer at creation and only ever accepts that key. If IdentityMD rotates its attester, every Open or Pending market fails verification, cannot be retried, and voids after 7 days with the fee lost. The README calls this intentional. The brief says a change "takes effect after 48 hours", so the author should decide the trade-off explicitly.

3. Verdict token is a post-launch owner call. The platform supplies $token, yet the token is set once by the owner after deployment. Renouncing or losing ownership first bricks the contract. Setting any wrong code address locks it permanently.

What held. Payout math conserves funds in every claim order including the last-claimer residual. The oracle callback uses 119k gas cold on the success path, inside the 200k stipend. The digest-binding plus public retry design correctly refuses unrelated signed questions. The OracleBody parser rejects duplicate, escaped, unknown and redirecting keys and never panics under fuzzing. OracleAttestation.sol is byte-identical to the canonical reference and the protocol vector verifies. Exported ABIs match the compiled artifacts. Static-analysis leads were all false positives or intended behaviour.

Unverified leads, not reported as findings. The contract hard-requires attestation chainId == 1. The supplied reference does not state what the oracle puts there for panel evidence, so this should be confirmed against one real attestation before launch. A short creator-chosen validForSeconds combined with writer delivery latency would also void a market, which is a product note for the frontend default.

The review is written to .imd-findings.json: 7 findings (1 medium, 4 low, 2 info) and a coverage row for all 23 entry points. No source files were changed; I deleted my scratch test folder afterwards. The project's own test suite passes.

Medium

1. The owner can change the Intake instantly and use it to settle markets (src/Tribunal.sol:151). The economics and permissions specialists both reported this, so it's one finding. The oracle's signature doesn't tie an answer to a specific market's question, so the Intake address is the only thing that does. A signer change has to wait 48 hours, but setIntake, setAction and setPayment take effect immediately, and every market created afterwards copies them. An Intake the owner controls can then settle a market with any signed answer, which anyone can buy for 0.5 IMD, or void it at will. That breaks the brief's rule that "the owner cannot resolve markets". I ran the specialist's proof test: it fails on this code with "owner-controlled Intake settled the market", and it is attached to the finding. Markets created before the switch are unaffected, which is why it's medium and not high.

Low 2. Anyone can waste the creator's 0.5 IMD jury fee (:261). On a market with no bets or bets on only one side, the oracle's answer can't change any payout, but requestResolution still pays the fee. It can also push the void date back by up to 7 days. Two specialists reported this; merged. 3. A signer rotation strands live markets (:223). Each market only accepts the signer it was created with, so after a rotation, markets already Open or Pending time out to VOID and the creator loses the fee. The README says this is intentional, so it's a trade-off for the author to confirm. 4. The VERDICT token address is a one-time owner call that can lock the contract for good (:145). The only check is that the address has code, and it can never be changed. Setting the wrong contract, or renouncing ownership before setting it, permanently stops markets from being created. Two specialists reported this; merged. 5. Any price change at the Intake blocks new markets (:212). Creation requires the live price to equal the stored one exactly, and only the owner can update it. After ownership is renounced, the block is permanent. No funds are lost.

Info 6. A market's title is not tied to the question the oracle actually answers. 7. Whoever calls requestResolution picks when a relative evidence window ("last 24 hours") is evaluated, anywhere in a 7-day span.

Dropped: the claim that validForSeconds = 60 lets answers expire before delivery. It depends on how quickly the oracle delivers after signing, which can't be checked from the code. Even if it happened, bettors are refunded and only the creator, who chose the setting, loses the fee.

The static-analysis leads didn't hold up. The reentrancy reports only involve the Intake copied into each market, and all state changes are under the reentrancy guard. The "divide before multiply" in claim is intended rounding, and payouts still add up exactly. The "uninitialized local" reports are variables that are meant to start at zero.

Implemented 48-hour scheduling for oracle configuration changes and fee-free VOID resolution for empty/one-sided markets. Updated ABI exports, documentation, and all seven responses in .imd-responses.json; disputed the token-setup redesign to preserve the required one-time setting.

Validation passed: forge build, 81 tests, and forge fmt --check. The unchanged reviewer exploit proof now passes.

The revision is done. Only launch.json changed.

What I found. The brief carried no pasted findings, so I compared the accepted tree against the manifest I wrote last round. The source revision that landed afterwards did not touch the Tribunal constructor. It still takes six static arguments in the order owner, intake, asset, action, price, signer, and the ABI export in docs/abi/Tribunal.json agrees. The published oracle attester at the IMD requests endpoint still returns the signer address the manifest names, checked today. All six argument values, the token name and symbol, and the pool block were already correct.

What I changed. One sentence in the notes. The accepted source now puts Intake, action and payment changes behind the same 48-hour delay and permissionless activation as signer changes, and the old notes described only the signer delay. The notes now say that, and that existing markets keep their snapshotted signer and oracle configuration.

Checks run.

• Forge build succeeded and all 81 tests passed, including the invariant suite.
• A scratch validator confirmed the manifest uses only the schema keys, has string uint and address values, lowercase addresses, a unique 32-character-safe contract name, exactly one argument per constructor parameter, the required pool values, and ASCII notes under the 4000-character limit.
• Git status shows launch.json as the only modified file.

The revision is complete and verified. All changes are confined to the four files I own under test/.

What had changed under my tests. After my previous round the implementation gained two behaviours: requestResolution now voids an empty or one-sided market immediately, returning a zero id and leaving the jury fee refundable, and the Intake, action and payment setters now schedule a change that only applies after 48 hours and an explicit activation. Fourteen of my tests failed on the new code for those reasons alone, not because of a contract defect.

What I changed.

• test/TribunalAccountingInvariant.t.sol: the handler's ask step now models both branches. A contested ask must return a request id paired to its market and marks the fee spent. An uncontested ask must return a zero id, record no request, keep the deadline and void the market with the fee still owed to the creator. The deterministic scenario now exercises a contested market, a one-sided one and an empty one, and checks that only the contested markets paid the Intake.
• test/TribunalOracleBoundaries.t.sol: every case that needs to reach the jury now creates a contested market, so the signature, field-tampering, expiry, deadline and signer-rotation checks still hit the oracle path instead of being voided early.
• test/TribunalEscrowBoundaries.t.sol: the three configuration tests now wait out the delay and activate the schedule from a non-owner account. Three new tests cover the uncontested path: the fee is refunded in the market's original asset after the payment asset changed and with the Intake set to reject, the void is final against late bets, asks, timeouts and spoofed failures, the last askable second and the timeout path yield identical refunds, and a creator alone on both sides is still contested and pays the jury.
• test/TESTING.md: notes updated to match.

Results. The full run passes with 108 tests across 13 suites, including the 256-run accounting invariant campaign. Formatter check passes on my files. I found no defect in the revised implementation that needed reporting, so no findings file was written.

The findings file is in place and ignored by the harness's own exclude rule, the scratch directory is gone, and no tracked file changed.

Outcome: no open findings. Every item from my previous round is settled, and I found nothing new in the revised code. The file .imd-findings.json holds an empty findings list and 32 coverage rows, one for each of the 25 entry points plus the prior findings and the manifest.

How each prior finding settled

• Medium, setIntake immediate (59260d2a): fixed. The attached proof, copied to the scratch directory, passed on this tree. The three setters now stage one pending configuration under a 48-hour delay with explicit, permissionless activation. My own test confirmed a market created in the scheduling block, and one created after maturity but before activation, both keep the honest Intake.
• Low, uncontested fee burn and lock extension (162909bf): fixed. A stranger calling requestResolution one second before the old deadline on a one-sided market now gets a Void with reason "uncontested", no Intake call, unchanged deadline, and the creator's claim returns the full 100 IMD and bond.
• Low, signer rotation strands old markets (a87d3a28): accepted as documented. Behaviour is unchanged, which was one of the two options I offered. I reconfirmed that an S2 answer defers and the old S1 key still settles the market.
• Low, verdict token one-shot (c2d50222): dispute accepted and dropped. The brief mandates set-once-then-lock, the README now warns about wrong addresses and renouncing before setup, and the unaccepted-transfer variant does not reproduce under Ownable2Step.
• Low, exact price check (f62c6d89) and the two info items: accepted as documented. README and docs/ABI.md carry the ownership-retention, title-versus-body and relative-window guidance, with a regression test for price recovery.

Checks on the rest of the tree

• The full project suite passes with 108 tests, including the invariant runs.
• The manifest uses only schema keys, its six constructor arguments match the constructor in order, and the addresses, action bytes and price match the oracle reference.
• Exported ABIs for both contracts are byte-identical to the compiler output.
• Tribunal runtime is 20,533 bytes with no DELEGATECALL, CALLCODE or SELFDESTRUCT opcodes. The protected project test itself needs the verifier's environment variables, so I replicated its opcode and size loop in a scratch test instead.

One thing I could not verify is the pool section of the manifest, since the assignment's "This launch" values for fee, tick spacing and initial price were not in front of me.

Saved four substantiated findings in .imd-findings.json:

• High — fidelity: the hero and statistics push the market docket below the first phone screen.
• Medium — taste: shared links have no og:image.
• Medium — taste: typography uses 12 mobile and 14 desktop sizes, including one-offs.
• Low — bug: the browser test races the terms-checkbox reset after switching bet sides.

Each finding includes an exact source citation, proposed change, reproduction steps, and measured evidence. Site files remain unchanged.

Build, typecheck, eight unit tests, ABI provenance, manifest hashes, and byte-for-byte rebuild passed. Chromium’s 25 interaction groups passed after a diagnostic wait exposed the reported test race. WebKit passed 18 interaction groups; its accessibility scan was stopped, and live RPC requests encountered access-control errors. No real transaction was sent.

The requirement mapping below consolidates repeated and related clauses. Inherited contract requirements are mapped to preserved source and tests, not independently re-audited.

Fixed all four findings, rebuilt dist/, and wrote .imd-responses.json.

Build, typecheck, 8 unit tests, and 27 browser checks passed; browser checks passed three consecutive runs. Submission snapshot: 2.90 MiB.

Evidence is in docs/frontend/REVISION.md. Social image URLs await publication. Git metadata is read-only; files are ready for collection.

All four prior findings are resolved. No new reproducible defect was found. .imd-findings.json contains {"findings":[]}. Site files remain unchanged.

The requirement inventory below groups related clauses and counts the duplicated workflow once. Contract requirements are supported by the preserved pinned source and existing contract-test evidence; this was not a new contract audit.