Implemented ROUTR with 18 decimals and exactly 1,000,000,000 tokens minted once to the deployer. Dependencies are vendored; deployment parameters and responsibilities are documented in README.md.

Verified successfully:

• forge build
• forge test: 32 passing tests, including fuzz and invariant checks with the supplied seed
• forge fmt --check

Nothing further is needed. The manifest is written and validated, the tree builds and tests pass, and only launch.json exists as a change.

Delivered: launch.json at the repository root with kind custom_token.

• Token: contract ROUTR, name ROUTR, symbol ROUTR, 18 decimals, no constructor arguments, totalSupply "1000000000000000000000000000". The constructor takes no parameters and mints that entire supply once to msg.sender, the factory.
• Contracts: []. The accepted tree contains only src/ROUTR.sol besides tests, so there are no application contracts to name.
• Pool: pairs with IMD at 0xd34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7, fee 12500, tick spacing 60, initial price 79228162514264337593543950336 (2^96, provenance only).
• Economics: copied verbatim from the brief.
• Notes: 602 characters describing only the token's actual behavior.

Verification: forge build compiled 28 files with Solc 0.8.26. forge test with the pinned fuzz seed passed all 32 tests, including the 1,024-run fuzz suite and the 128-run invariant suite. A scratch checker confirmed the manifest's key set, types, lowercase address, name shape, constructor-argument count against the compiled ABI, empty link references, economics equality, and the 2^256 price bound. git status shows launch.json as the only change; no other file was touched.

The findings file is in place and no tracked file changed (git reports a clean tree, with the findings file and scratch directory ignored by the workspace).

Result: no defects found in the economics area. The file .imd-findings.json holds an empty findings list and eight coverage rows, all holds.

What was reviewed. ROUTR is a 17-line contract: it inherits the vendored OpenZeppelin ERC20 and mints the full supply to the direct caller in the constructor. It adds no transfer override, fee, burn, owner, pause, mint, or callback. I checked it against the Senior Auditor's Mindset and the Economic Security, Invariant and Flow Gap guides, and verified each claim concretely:

• Launch flows arrive exact. A scratch test drove the 10% transfer to the distributor, a pool-manager pull of the 85% seed via transferFrom, the 5% remainder, a claim, and a buy and sell against the manager. Every balance matched the amount sent and the supply stayed at 10^27.
• Supply cannot grow. The compiled ABI exposes only the ERC-20 surface plus the supply constant. The internal mint is reachable only from the constructor. The project's 128-run stateful invariant and 32 unit and fuzz tests all pass.
• ERC-20 compliance and sentinels. Zero-address sender, receiver and spender revert with ERC-6093 errors. Insufficient balance or allowance reverts and rolls back. Unlimited allowance is not decremented. Overspending by one wei reverts.
• Dependency integrity. All five vendored OpenZeppelin files hash identical to the lock file and to the upstream v5.0.2 sources I fetched during review, so the library is genuine.
• Bytecode. A reachable-opcode walk, the same one the protected test uses, found no DELEGATECALL, CALLCODE or SELFDESTRUCT in the 1752-byte runtime.
• Static-analysis lead. Aderyn's large-numeric-literal note on line 12 is style only. The expression compiles to exactly 10^27, which the tests assert.

Not a defect, noted for the judge. Tokens sent to the token contract itself are unrecoverable, and the standard ERC-20 approve ordering race exists. Both are inherent to plain ERC-20, are documented in the README, and carry no privileged actor or exploit path. No manifest exists yet, which is expected before the manifest step runs. The README's stated constructor arguments and total supply are consistent with what the constructor does.

Coverage. All three listed entry points plus five invariant rows are answered as holds. Nothing in my area was left unreached. The scratch test directory was removed after running, since it contained no proof for a finding.

The review is complete. .imd-findings.json holds an empty findings list and seven coverage rows, all holds.

What I reviewed. The token is src/ROUTR.sol, a 17-line fixed-supply ERC-20 that inherits OpenZeppelin v5.0.2 with no overrides. I applied the Senior Auditor's Mindset and the Math Precision, Boundary and Numerical Gap guides to every arithmetic and boundary path reachable from the three entry points.

Why there are no findings in the math area:

• The only arithmetic the contract adds is the supply constant. It is a compile-time checked expression equal to exactly 10^27 and is minted once to the deployer.
• The inherited transfer path checks balance before its unchecked subtraction, and the receiver-side add cannot wrap because the sum of balances is fixed at 10^27.
• The allowance path checks the allowance before its unchecked decrement and skips the decrement only at exactly max uint. An allowance of max minus one is decremented correctly.
• There is no division, scaling, fee, rounding or downcast anywhere, so the Numerical Gap seams have nothing to attach to.
• The launch's basis-point splits divide 10^27 exactly, so the swarm, pool and remainder shares produce no dust and arrive whole.

Evidence. The project suite passed with the documented fuzz seed. I also ran a scratch test of 1 wei, max uint, exact-allowance, max-minus-one allowance, full-balance self-transfer and supply concentration cases, all passing. I confirmed the vendored OpenZeppelin files match both the lock file and the upstream v5.0.2 sources byte for byte, so the arithmetic under review is unmodified upstream code. The scratch test and downloaded files were removed afterwards.

Leads dismissed. Aderyn's large-numeric-literal line is a style note only. The value it points at is verified correct.

Not reached. Nothing within the assigned area. Permissions, economics and control flow belong to the other specialists, though I noted in passing that the token has no owner, admin or mint path at all.

The review is complete and the findings file is written. The repository tree is unchanged apart from the gitignored scratch test and the findings file.

Result: no defects found in the control-flow area. ROUTR is a nine-line contract that inherits OpenZeppelin's ERC-20 unchanged and mints the fixed supply once to msg.sender in its constructor. Across the three guides nothing reached a concrete failing input.

What I checked:

• Execution Trace. Traced approve, transfer and transferFrom through the vendored ERC-20 into _update, _approve and _spendAllowance. Every failure path reverts the whole call, including allowance rollback when the balance or receiver check fails. The only sentinel is the documented infinite allowance. There are no external calls, callbacks, fees or partial updates.
• Periphery. The five vendored OpenZeppelin files are byte-identical to upstream v5.0.2, which I fetched from GitHub into a separate directory and hashed. Context returns plain msg.sender.
• First Principles. The constructor's one assumption, that msg.sender is the intended holder, holds under the factory's CREATE2 deployment. I confirmed this with a probe contract. The supply constant equals 10^27 and decimals default to 18, matching the brief.
• Floor checks reproduced locally. A scratch test mirrored the protected floor where it needs no Uniswap harness. The reachable runtime contains no DELEGATECALL, CALLCODE, SELFDESTRUCT, CALL or CREATE. Twelve privileged selectors from the deployer all revert and the holder keeps and can move their balance. The compiled ABI has only the three listed non-view functions.
• Existing suite. All 32 project tests pass with the README seed, including the 128 by 64 invariant run against an independent ledger.

The static-analysis lead about the large numeric literal is a style note. The literal is a compile-time constant with the correct value.

Coverage record: the three entry points plus the constructor, two invariants, the vendored base, the bytecode floor and the aderyn lead are marked as holding. One row is marked unreached: the actual Uniswap v4 seed and swap from the protected test, since that harness is not in this repository. Token-side transfers into and out of a pool-holder contract were verified exact.

The review is complete. The findings file holds an empty findings list and nine coverage rows, and the working tree is otherwise untouched.

Result: no defects in the permissions area. ROUTR is a thin wrapper over an unmodified OpenZeppelin v5.0.2 ERC20 with a single constructor mint, and every failure mode in the Access Control, Trust Gap and Asymmetry guides was checked against it without producing a reproducible issue.

What I verified, with evidence:

• Entry-point inventory from the compiled ABI shows exactly three state-changing functions: approve, transfer and transferFrom. There is no owner, minter, pauser, blacklist, initializer, upgrade path, receive or fallback. Selector sweeps from both the deployer and a stranger all revert.
• Constructor mints exactly 10^27 base units once to msg.sender, which is the factory, and nothing to tx.origin or the factory's caller. The aderyn large-literal lead resolves to the exact intended value.
• No privileged pull right. The deployer calling transferFrom on a holder with zero allowance reverts with the allowance error even for one wei, so no actor can move or freeze a holder's balance.
• Asymmetry pass. Both transfer paths share the same internal checks and event. The only difference is allowance consumption on transferFrom, and no admin, batch or force variants exist to diverge from the user path.
• Trust Gap pass. With no privileged actor, setter, fee recipient or callback, no seam exists where authorization and economics interact.
• Runtime bytecode scan finds no CALL, DELEGATECALL, CALLCODE, STATICCALL, CREATE or SELFDESTRUCT among reachable opcodes. Context uses plain msg.sender with no meta-transaction forwarder.
• Dependency integrity. All six vendored OpenZeppelin files hash identically to the lockfile and to the upstream v5.0.2 tag fetched from GitHub, so no hidden hook or exemption was introduced in the library.
• Project test suite passes: 32 tests including 1,024-run fuzzing and a 128 by 64 stateful invariant run. My five additional scratch permission tests also passed and were removed afterward.

Two notes that are not defects: the standard ERC-20 approve ordering race is inherent to the interface and is documented in the README, and the Approval event is not emitted on transferFrom, which is upstream v5 behaviour and also documented. Nothing in my area was left unreached.

Added 12 boundary, failure-path, and fuzz tests; expanded stateful invariants to 10 randomized actions.

Verified offline with the required seed: 44 tests passed, including 32,768 invariant calls. forge build also passed.

All changes are under test/. No implementation defects were reproduced.

The review is complete. The findings file is written and the working tree has no changes beyond it.

Outcome: no defects found. The file .imd-findings.json holds an empty findings list and six coverage rows, all holds.

What was checked

• Specialist input. All four specialists and the test writer reported nothing, so there was nothing to reproduce, merge or drop.
• The token itself. ROUTR is OpenZeppelin v5.0.2 ERC20 with one constructor mint of 10^27 base units to msg.sender and no overrides. Each of the three entry points was traced through the inherited approve, transfer and transferFrom paths, including zero-address, insufficient-balance and insufficient-allowance reverts.
• Dependency integrity. The five vendored OpenZeppelin files hash-match both the lockfile and the upstream v5.0.2 files fetched from GitHub.
• Launch floor. A scratch replica of the protected test's checks passed: CREATE2 deployment through a factory contract leaves the whole supply with the factory, decimals are 18, the reachable runtime has no DELEGATECALL, CALLCODE or SELFDESTRUCT, creation and runtime sizes are far under the limits, the 10% swarm flow arrives whole, and 22 admin-style selectors all revert without changing balances or supply. The scratch directory was removed afterwards.
• Manifest. launch.json uses only schema keys, empty constructorArgs match the no-arg constructor, totalSupply equals what the constructor mints, and the paired currency on chain 1 has code and reports the symbol IMD.
• Static analysis lead. Aderyn's large-literal note on line 12 was evaluated and the literal equals the intended supply, so it is not a defect.
• Repo suite. All 44 existing unit, fuzz and invariant tests pass with the README's seed.