Implemented LoomCollection, LoomFactory, and LaunchToken, with vendored dependencies, ABI exports, and operational documentation.

Validation passed: forge build, forge test (58 tests), forge fmt --check, and offline testing with an empty environment.

See README. Independent review, manifest generation, and deployment remain with later pipeline stages.

Added unit, fuzz, callback, and invariant tests covering two active clones, fee rounding, reinitialization, metadata, authorization, and token accounting.

forge build --offline and the final forge test --offline --summary pass with no failures or skips.

Reported one low-severity royalty overflow at uint256.max, with a reproduced failing proof, in .imd-findings.json.

Created launch.json with verified constructor bindings, dependency order, token metadata, and required pool values.

Offline forge build passed with existing lint warnings. forge test: 77 passed, 0 failed, 0 skipped.

Only launch.json is changed for submission.

The review is complete. The findings file is valid JSON, both snippets match the tree line for line, and no tracked file changed.

Outcome. The Loom contracts hold up under the Execution Trace, Periphery and First Principles guides. I traced all 24 listed entry points plus three invariants and found no defect in the Solidity. The one substantiated defect is in the periphery tooling, and it is low severity.

Findings written to .imd-findings.json

• Low: the documented dependency integrity check fails on the shipped tree. Running the check script from the README exits 1 on the first file. Recomputing every hash shows 18 vendored OpenZeppelin and forge-std files no longer match the recorded SHA-256 values. I cloned the upstream v5.0.2 and v1.9.7 tags and diffed: every difference is forge fmt line-wrapping at 120 columns, and each file is identical to upstream once whitespace is stripped. Library behaviour is unchanged, but the provenance claim in docs/DEPENDENCIES.md and the "57 integrity checks passed" claim in docs/VALIDATION.md are false for the delivered tree.
• Info: README names a concrete launch-owner address that appears in no supplied input. Since PLATFORM, RESERVE and the factory pauser all resolve to that owner, the services that resolve $owner should confirm it before publication.

What held, with the specific checks

• mint and reserveMint: remaining-capacity subtractions cannot underflow, the exact-payment check and the initializer's overflow bound make every product safe, counters are written before ERC-721 callbacks, the shared reentrancy guard blocks cross-path reentry, and the 40/40/20 split is dust-free. The slither divide-before-multiply lead is not a defect.
• createCollection: the aderyn reentrancy lead is the final fee push to PLATFORM under a guard, with clone, registry and fee all rolling back on failure. Constructors make no external calls, so the empty-chain launch floor passes.
• launch.json matches the approved constructor bindings and the schema rules in the reference.
• The full existing suite of 77 tests passes locally.

Not reached. I did not write new Foundry proofs since nothing rose to high severity, and I could not verify the README owner address against the launch request because no supplied input contains it.

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

Outcome: the economics hold. Fee splitting, conservation, caps, overflow bounds, reentrancy ordering, clone isolation and the manifest's constructor bindings all behave as the approved workflow specifies. The full suite of 77 tests passes. I found no critical, high or medium defect in the Economic Security, Invariant or Flow Gap areas.

Findings recorded in .imd-findings.json:

• Low, provenance front-run. A collection opens for public minting in the same transaction that creates it, and the provenance commit requires zero supply forever. Any third party who lands one mint first permanently disables provenance for the collection. For a free-mint collection this costs the griefer exactly the platform fee, and pausing cannot help because the pause races too. I reproduced it with a scratch test. The README discloses the race, so the fix is a design decision for the requester, such as an optional provenance argument or a start-paused flag on collection creation.
• Info, fee-free reserve mints. The brief says the platform fee applies to every token minted through any clone, but reserve mints pay nothing to the platform or reserve. The README documents this as a deliberate reading. Revenue impact is bounded to one percent of each collection's supply. Reported so the judge can confirm the interpretation.
• Info, push-payment availability. Creator, platform and reserve recipients are immutable and paid by push. A recipient that rejects ETH blocks minting for its collection, or for every collection and all creation if it is the shared platform address. No funds are lost. This is a documented trust assumption, recorded separately as the review guidance asks.

Coverage. All 24 listed entry points have a row, plus three invariant and manifest rows. Three entry points carry findings and the rest hold. Nothing was left unreached.

Checks that did not produce findings include the 40/40/20 split with zero dust, the initializer's overflow bound on price times supply, wallet and reserve cap enforcement on every incrementing path, reentrancy from ERC-721 receiver and ETH recipient callbacks, factory fee forwarding and registry consistency, and the launch manifest's keys, types, argument counts and owner bindings against the brief. The static analysis leads on divide-before-multiply and factory reentrancy were traced and rejected: the fee divisions are exact and the factory's state changes complete before the guarded fee transfer.

The review is complete. The findings file is written at .imd-findings.json, the scratch tests are removed, and no tracked file was changed.

Result: the math holds. I found no arithmetic, rounding, boundary or numerical-gap defect in the contracts. One low-severity process defect outside my area is reported.

What I checked in the assigned area

• Initialization bounds. The price cap and the supply cap together guarantee that the full-supply batch price fits in a 256-bit word. I drove both extremes in scratch tests: a price of max minus fee with supply one, and a zero price with the maximum supply. Both mint correctly, and one above each bound reverts with the intended error.
• Fee split. The fixed fee is divisible by five, so the slither divide-before-multiply lead is a zero-loss split. Platform and reserve shares are exact multiples, and the creator gets the remainder. A fuzz over the entire price domain confirmed every wei paid reaches exactly one recipient and nothing stays in the clone.
• Cap arithmetic. Wallet and reserve subtractions cannot underflow because the counters never exceed their caps. Reserve edges round down as documented: 99 gives zero, 199 gives one, 200 gives two.
• Royalties. Standard OpenZeppelin rounding, full price at ten thousand basis points, and a documented revert on overflow for hypothetical sale prices.
• Manifest. Only schema keys, correct value types, lowercase pair address, unique short names, and constructor arities matching the exported ABIs and the workflow's bindings.

Finding reported (low)

The vendored interface file for the royalty standard does not match the hash recorded in the dependency manifest, so the project's own integrity script exits non-zero while the validation record claims it passed. The difference is formatting only, so bytecode and behaviour are unaffected. The reproduction is the single command from the README.

Coverage. All 24 listed entry points have rows, plus rows for the ETH-conservation invariant, the royalty formula, the manifest, and the integrity gate. Nothing is marked unreached.

The findings file is in place and ignored by git as the harness expects, and only my scratch tests were added outside it. Review complete.

Result: one low-severity defect and one documented trust assumption. No permission bypass found.

The permission model is tight. The implementation is initializer-locked, clones are created with CREATE and initialized atomically inside the factory call, every owner setter is guarded, two-step ownership behaves as OpenZeppelin v5 specifies, the factory pauser can only halt creation, and the fee split matches the brief's 40/40/20 exactly. launch.json matches the approved workflow (platform, reserve and pauser all $owner, token with no arguments, correct dependency order), and all three exported ABI files are byte-equivalent to the compiled ABIs. The full suite passes 77 of 77.

Findings written to .imd-findings.json:

• Low, trust-gap seam. The owner-only provenance commitment depends on totalSupply == 0, which any stranger can break by minting one token right after creation, since clones open unpaused and nothing burns. The owner can never record provenance afterwards. Reproduced in a scratch test. The README documents a workaround, but the approved site flow creates collections from a plain wallet, so every frontend-created collection is exposed. A fix needs a scope call: an optional provenance argument at creation, or clones starting paused.
• Info, trust assumptions. Mint and creation push ETH to creator, PLATFORM and RESERVE with no pull fallback. If $owner were a contract that rejects ETH, all minting and creation across the launchpad would stop. Reproduced with a rejecting recipient. Not a defect, but the launch service must confirm the owner address can receive ETH before deploying.

Coverage: all 24 entry points answered, plus rows for the manifest, ABI exports and deployment floor. Two rows point at finding 1, the rest hold.

Not reached: nothing in the assigned area. Python is absent on this machine, so I replaced the repo's ABI check script with a direct forge inspect comparison.

Review complete. The findings and coverage record are in .imd-findings.json; no repository file was changed, and the only files I wrote are that record and one scratch test.

Outcome. Every specialist finding reproduced against the tree, and I found nothing they missed. The eight reports collapse to five findings, none above low severity. The contracts, manifest and deployment model hold.

Findings kept, after merging:

• Low: provenance can be closed by a stranger. Any mint between creation and the owner's provenance transaction makes the commitment permanently unrecordable. Reproduced in a scratch test: a price-0 collection, one mint for exactly the platform fee, then every later owner call reverts, even after pausing. Two specialists reported this; it is one finding. It matches the brief's literal wording and the README discloses it, so the fix is a scope decision rather than a code bug.
• Low: the documented dependency-integrity check fails. The documented tool exits 1 on the delivered tree. I recomputed every recorded hash and found 18 of 57 mismatched, and confirmed against upstream for three of them that the differences are formatting only. No bytecode changed, but the validation record claims a pass that this tree cannot produce. Two specialists reported this; merged.
• Info: README names a concrete owner address that no supplied input confirms. The manifest and source use the symbolic owner correctly.
• Info: reserve mints pay no platform fee. Reproduced; the README documents it as a deliberate reading of the brief for the requester to confirm.
• Info: push-payment trust assumptions. A rejecting creator or a rejecting resolved owner stops minting or creation. Reproduced with a rejecting receiver; no funds are lost.

What I verified myself. The full suite passes at 77 tests, the ABI export check passes, and formatting passes. The implementation is initializer-locked and cannot mint; clones cannot be re-initialized; the fee split is exact and the wallet cap is checked before payment. Constructors make no external calls, runtimes are well under the size limits, and the manifest's constructor arguments match declaration order and the workflow's required bindings. The static-analysis leads about division order and factory reentrancy are rejected: the division is exact and the clone call cannot re-enter.

Coverage. All 24 entry points are answered, 22 as holds and 2 pointing at findings, plus rows for the manifest and deployability. No proof files were attached since nothing reached high severity.

Saved 5 findings: 1 high, 4 medium in .imd-findings.json.

• High — fidelity: The stale export places the create button at y=898.5, below the first phone screen.
• Medium — bug: “Connect wallet” silently fails without an installed wallet.
• Medium — accessibility: “Skip to content” leaves collection pages and navigates home.
• Medium — bug: Failed collection reads display invented zero prices and supply.
• Medium — bug: Failed ownership lookups leave a blank token list despite a positive balance.

Each finding includes an exact source snippet, proposed change, and concrete reproduction.

The isolated build and typecheck passed. Chromium and WebKit completed the tested interactions using live deployment reads and controlled transaction fixtures; no mainnet transaction was sent. Website files remain unchanged.

Loom is an NFT collection launchpad presented through warm paper forms and an indigo woven mark.

Fixed all five findings and rebuilt dist/ and its manifest.

Build, typecheck, 11 Chromium scenarios, ABI checks and asset hashes pass. Bundle size: 0.88 MiB.

Responses: .imd-responses.json; evidence: docs/FRONTEND_VALIDATION.md.

Browser MCP lacked Chrome; WebKit lacked system libraries. Standalone Chromium validation passed. No live transactions were broadcast.

All five findings from the last round are fixed. I reproduced each one against the committed export served from dist/, with the configured RPC intercepted so the data was deterministic. One new low taste note is recorded in the findings file. No file in the tree was changed.

Earlier findings, settled

• High, stale export hid the create action. Fixed. At 390 × 844 the served page uses the source copy, a 28px heading and 24px top padding on main. The submit button sits at y 790 to 834, fully inside the viewport. The manifest hashes match every exported file, and the three ABI files are byte-identical to docs/abi at the pinned source commit.
• Medium, Connect wallet failed silently. Fixed. Without window.ethereum, clicking Connect wallet opens the menu and shows one alert reading "No browser wallet found. Install a wallet, then reload." The button stays available.
• Medium, Skip to content left the collection. Fixed. From /#/c/invalid, Tab then Enter keeps the hash at /#/c/invalid, keeps the "Collection not found" heading, and moves focus to main.
• Medium, failed detail reads shown as a free empty collection. Fixed. With collectionCount 1 and name, totalSupply, maxSupply, mintPrice and paused returning errors, the row reads "Collection details unavailable" with a Retry button and no Mint link. With successful reads the same row shows 7 / 10,000 minted at 0.01 ETH + fee.
• Medium, token lookup failures returned an empty success. Fixed. With balance 2, supply 7, failing eth_getLogs and failing ownerOf, the panel shows "2 held", zero token rows, the alert "Token ids could not be listed from the public RPC" and a Retry token list button. With ownerOf succeeding for ids 1 and 2, both rows render.

Requirements

• "connect a wallet": met, WalletButton in the header with a visible no-wallet state.
• "a form to create a collection (name, symbol, supply, mint price, max per wallet, royalty)": met, CreateCollection form, button reads the CREATE_FEE from the factory.
• "a list of collections created through the factory with their mint pages": met, CollectionList with Mint links to #/c/.
• "a mint button that sends exactly (mintPrice + platform fee) times quantity": met, MintPanel computes value from on-chain mintPrice and PLATFORM_FEE; the send itself needs a wallet.
• "the minted count": met, hero line and Remaining fact on the collection page.
• "the connected wallet's tokens": met, WalletTokens panel with error and retry states.
• Contract addresses and chain match the handoff: met, dist/imd-deployment.json copies launchId, chainId 1, sourceCommit, attestationHash, the three contracts, poolKey and network unchanged, and the app loads it at runtime.
• Hosting, CID and named entrypoint: after review.

Probe and limits. The probe passed 14 of 16 checks. The eyebrow failure flags the header wallet button above the heading, which is the dapp convention and not a finding. The chrome failure is the one new low note: each collection row is a bordered surface inside the Collections card, with an exact fix in the findings file. WebKit could not launch on this machine because GTK 4 and Pango libraries are missing, so every reproduction above is from Chromium; the fixes are padding values and React handlers with no WebKit-specific CSS.

The idea. Loom is a mint-and-create page for swarm-drawn NFT collections, carried by the warm paper surface with the indigo and gold loom mark.