DevPrices constructorArgs fix yoloPriceUsd = 1000000000000000 (0.001 USD) and imdUsd = 5.5 USD. The same brief fixes economics.initialMarketCapWei = 15,000 IMD for the 1,000,000,000 supply: 15,000 x 5.5 / 1e9 = 0.0000825 USD per YOLO at the opening tick, 12.1x below the DevPrices figure.

DevPrices.yoloValue is read by CaseDesk._stakeBps (src/desks/CaseDesk.sol:532) to compare a doer's locked YOLO against the reward: with the price 12x too high, a lock worth one twelfth of the reward at the opening price already earns the maximum stake bonus. Prices never decide who is paid (brief), so this is a sizing error, not a loss of funds.

The owner (0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981) can only correct it in two transactions because _check caps one call at 10x (src/DevPrices.sol:89): setYoloPriceUsd(100000000000000) then setYoloPriceUsd(82500000000000). Both numbers are fixed by the brief, so this is a note for the author, not a change for the adapter.

The protocol's OracleAttestationConsumer (oracle-consumer REFERENCE.md, _verifyAttestation) reverts AttestationExpired whenever block.timestamp > a.expiresAt, so an attestation with expiresAt = 0 is always expired there, and it also refuses issuedAt more than 5 minutes in the future. This checker treats expiresAt = 0 as unbounded validity and never reads issuedAt.

The signer set is the trusted oracle key (ParamsRegistry.isAttester), so exploiting this needs a signed zero-expiry attestation; the brief says every signed answer carries validForSeconds (2592000 in bodyFields). Impact is a weaker guarantee than the protocol's, not a loss: a zero-expiry attestation, if one were ever signed, could be presented to TaskVault at any later time. TaskVault consumes request ids, which bounds replay to one use.

Keep as a note; aligning the check (a.expiresAt < block.timestamp without the zero exemption) is the minimal fix if the author wants parity.

SwapRouter02.exactInput treats params.amountIn == 0 (Constants.CONTRACT_BALANCE) as 'swap the router's entire balance of the first path token' and skips the pull from the caller. The adapter does not refuse amountIn = 0: for an ERC-20 input it pulls 0 from msg.sender, approves 0 and calls exactInput with amountIn 0; for ETH input it requires msg.value == 0 and does the same. The output then comes from whatever tokenIn dust sits in the router.

The adapter and the vault hold nothing in the router, so no protocol funds are at risk and anyone can already call the router directly for that dust; but through TaskVault.collectImd (src/TaskVault.sol:803) a payer could pass amountIn 0 and have a bond's IMD funded by router dust when minImdOut is met, which is a quirk the vault's balance-difference accounting does not distinguish from a real payment.

Minimal fix: revert on amountIn == 0 in swapExactIn.

Read in full: src/token/YoloToken.sol, src/token/NftGate.sol (deployed in launch #2292, read for the token's calls), src/token/YoloSplitter.sol (remainderTo), src/DevPrices.sol, src/adapters/UniswapV3SwapAdapter.sol, src/ParamsRegistry.sol, src/VaultParams.sol, src/helpers/TextRules.sol, src/helpers/SwarmQuestion.sol, src/VotePower.sol, src/helpers/AttestationChecker.sol, src/OracleAttestation.sol, src/BuybackBurner.sol, script/LaunchPlan.sol, the two protected floor tests and the oracle-consumer reference.

Read only at the call sites that touch this launch: src/desks/CaseDesk.sol (_stakeBps), src/TaskVault.sol (collectImd). Not reviewed (launches #3 and #4): YoloLockHub, CaseDesk, DisputeDesk, TaskVault, the $YOLO modules, DareTrophy, HiddenList, ProtocolDirectory, YoloPredict, YoloSweetener, the vestings.

Checks: forge test passed 688 tests, 0 failed, 3 skipped (the fork tests, no FORK_URL on this machine); the fork rehearsal was not run.

Launch-rule scan of src/: no DELEGATECALL, CALLCODE, SELFDESTRUCT, proxy, initializer or post-deployment configuration of a token property; the token has no owner, mint, burn, pause or editable list, every constructor takes only addresses and integers with no external call, and on a chain where the gate has no code the token is a plain ERC-20 (the protected floor's bare-chain case; scheduled false).

Token arithmetic checked against the brief: buy tax value3000(3600-e)/18,000,000 rounded down; sell tax value*num/(18,000,000-num) so 70 into the pool pays 30 at 30%; boundaries e<1800 whitelist, 1800<=e<3600 taxed, e>=3600 plain; launcher and PoolManager exempt both ways; the factory's claimFees path is exercised by the fork rehearsal (LaunchRehearsal.fork.t.sol:882-888).

Mainnet counterparties verified to hold code at block 26238804: Intake v2 0xa43e..., NFT 0x0000ec93..., delegate.xyz v2 0x0000...447e..., SwapRouter02 0x68b3..., IMD 0xd34a..., PoolManager 0x0000...4444c5dc..., YoloSplitter 0xF165...; the dev wallet and the buyback wallet are EOAs.

Privileged powers, all constructor-set and matching the brief (trust assumptions, not defects): DevPrices owner 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981 moves each price at most 10x per call and names the buyback wallet through BuybackBurner.setBuybackWallet; ParamsRegistry owner 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C proposes parameter versions and attester changes behind the 48 h timelock and pauses new tasks at once with setNewTasksPaused (no timelock, by design); the attester set is global and the last attester cannot be removed.

Manifest notes for the adapter: no launch.json exists yet; the eight contract names are unique and at most 32 characters; every constructor's argument count matches the brief's lists (DevPrices 7, adapter 2, ParamsRegistry 8, TextRules 0, SwarmQuestionBuilder 0, VotePower 2, AttestationChecker 1, BuybackBurner 5); pool pairedCurrency is IMD 0xd34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7, fee 12500, tickSpacing 60; economics poolBps 1500, initialMarketCapWei 15000000000000000000000, remainderTo 0xf165884070b1a1e571f4a3b50fd727fe8380bee4 (lowercase in the manifest).

Access control / asymmetry. DevPrices.owner() is the single key for three distinct powers: the three price setters (onlyOwner), BuybackBurner.setBuybackWallet (src/BuybackBurner.sol:76 if (msg.sender != dev()) revert NotDev(); where dev() = IOwned(devPrices).owner()) and TaskVault.cancelTask (src/TaskVault.sol:373 Ownable(...devPrices).owner()).

Ownable2Step makes transferOwnership two-step, but OpenZeppelin 5.1 Ownable keeps renounceOwnership() as a one-step, unguarded, irreversible call that sets owner to address(0).

After it, dev() returns address(0); since msg.sender can never be address(0), setBuybackWallet reverts NotDev for everyone forever (the buyback wallet is frozen at whatever it was), cancelTask reverts NotAuthorized for every task created under a version that names this DevPrices, and every price is frozen (stale prices size the stake bonus for every future submission).

The brief describes the dev wallet as a permanent operational role (sets prices by hand, alone may cancel a task, alone changes the buyback wallet); the inherited function gives that role a one-transaction self-destruct the brief does not list, with no recovery path because no contract can re-assign a DevPrices owner. Fix that preserves the design: override renounceOwnership to revert (the asymmetry is that handover is two-step while abandonment is one-step).

Reproduced locally (test/scratch, not kept): both expectations below hold on the current code.

Access control / trust gap. The brief says the registry owner changes parameters and the swarm signer set only behind a 48-hour timelock and the signer set is global (a change reaches open cases). All of proposeParams, cancelParams, proposeAttester, cancelAttester and setNewTasksPaused are onlyOwner.

OpenZeppelin 5.1 Ownable's renounceOwnership() is a one-step, unguarded, irreversible call.

Once called (by the project wallet 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C, by mistake or under a compromised key), no attester can ever be added or removed: a leaked oracle signer key (the initial attester 0x5598aa9146215bc13eb26f2c692ad1461fd32982) stays accepted by AttestationChecker.check for every live and future task, the parameter set can never move (another intake, treasury or price source cannot be named), and new tasks can never be paused or unpaused.

The vault also keys TaskVault.bindSweetener on ParamsRegistry(registry).owner() (src/TaskVault.sol:159), which then reverts NotAuthorized forever. Nothing in the brief lists abandonment as a power of this role; handover is deliberately two-step while abandonment is one-step. Fix preserving the design: override renounceOwnership to revert.

Reproduced locally (test/scratch, not kept).

Manifest note, outside the Solidity area but checked because the task names launch.json. The task reference says the manifest's addresses are written in lowercase and that economics is copied from the job verbatim; the brief writes every address checksummed.

The manifest resolves this by lowercasing pairedCurrency and remainderTo (line 88 "remainderTo": "0xf165884070b1a1e571f4a3b50fd727fe8380bee4") while keeping every constructorArgs address checksummed (token lines 10-11, DevPrices line 20, ParamsRegistry, VotePower, BuybackBurner). Nothing a worker runs validates the schema, so whether the admission parser lowercases, accepts mixed case, or rejects a non-lowercase address string cannot be shown here.

On-chain the bytes are identical, so this cannot change what is deployed; it can only make admission refuse the file.

Needed evidence: one run of the manifest schema against this file, or a statement of the case rule for constructorArgs.

The launch rules say every address in launch.json is written in lowercase and that a manifest failing the schema is refused as a whole.

Five constructorArgs entries are checksummed (mixed case): token.constructorArgs[1] 0x97C8Fe82527F1a65A147bB0b425C717E4EC547C2 (the NftGate), token.constructorArgs[2] 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C (the project wallet), contracts[0].constructorArgs[0] 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981 (DevPrices owner), contracts[2].constructorArgs[0] and [6] (ParamsRegistry owner and treasury).

Every other address in the file (pairedCurrency, remainderTo, USDC, IMD, WETH, router, intake, NFT, delegate registry, attester, buyback wallet) is lowercase. If the schema's address pattern (^0x[0-9a-f]{40}$) also applies to constructorArgs entries, admission refuses the whole file and the launch never reaches the deployer; the token, its openAt and the gate are untouched by the fix, since lowercasing changes no value.

Not confirmed against the schema itself (not supplied); reported because the cost of a refused manifest is the whole launch and the fix is value-preserving. Manifest only; no src/ change.

Execution-trace note on the launch itself, restating ADAPTATION.md disposition 1 with the clock at review time. The gate 0x97C8Fe82527F1a65A147bB0b425C717E4EC547C2 has code on mainnet, so scheduled_ is true and the constructor holds openAt to [block.timestamp, block.timestamp + 30 days]. launch.json fixes openAt = 1792584000 (2026-10-21 12:00:00 UTC). This review ran at 2026-10-21 06:49 UTC (unix 1792565350): about 5 h 10 min remain for review, judging, admission and mining.

The factory's launchCustom cannot complete a launch whose token constructor reverts, and ProjectFactory would then have consumed the launch slot for nothing. The brief's sole exception allows moving openAt later, at most to 1792594800 (15:00 UTC); the gate's sealedAt 1792560251 stays strictly before either value, so the minutes 0-30 window still opens. No code change; a manifest decision for whoever submits the launch.

Periphery / inherited-code note, a trust assumption rather than a permission bypass. The brief describes the dev wallet as the owner of DevPrices who sets prices, changes the buyback wallet and alone may cancel a task. Ownable2Step also exposes renounceOwnership(), a one-step call that sets owner() to address(0).

BuybackBurner.dev() and TaskVault.cancelTask (line 373: Ownable(...devPrices).owner()) both derive the dev from that owner, so one renounce freezes three things at once and forever: the three prices (stake bonus sizing), the buyback wallet, and task cancellation (the only way everyone takes back what they put in).

The same inherited function on ParamsRegistry removes the only proposer of parameter versions, attester rotation and the new-tasks pause, bypassing the 48 h timelock story (the brief says the owner changes both only behind the timelock; renouncing is immediate). No funds move or are frozen by it; recorded so the judge can decide whether the operational runbook should forbid the call.

Economic-security note on a fixed input (the brief fixes every price, so this is recorded, not changed). The launch economics open the pool at initialMarketCapWei = 15,000 IMD for 1,000,000,000 YOLO; at the fixed IMD price of $5.5 that is 15,000 x 5.5 / 1e9 = $0.0000825 per YOLO. DevPrices starts yoloPriceUsd at 1e15 = $0.001, 12.12x above the opening valuation.

The only consumer is CaseDesk._stakeBps (src/desks/CaseDesk.sol:532, yoloValue(t.currency, t.pot)), which converts the task pot into YOLO at the dev price and pays the doer up to MAX_STAKE_BONUS_BPS (400 bps of the reward) when the lock power covers it.

With the dev price a 100 USDC pot is worth 100,000 YOLO, so a 52-week lock of 100,000 YOLO (about $8.25 at the pool's opening price, before the pool's 1.25% fee and slippage) earns the full 4 USDC bonus on every task of that size, whereas at the pool-implied price the same lock would earn 33 bps (0.33 USDC).

Who pays: the bonus comes out of the 10% fee (the stakers' share), so the treasury's and the burn's share shrink by up to 400 bps of each staked doer's reward; nobody outside the protocol loses, and the bonus is capped at 4%, so the impact is bounded and non-compounding. The owner can only move the price 10x per call (DevPrices._check), so correcting it to 8.25e13 takes two transactions (1e15 -> 1e14 -> 8.25e13).

This duplicates ADAPTATION.md disposition 3 and is restated here with the launch's numbers because it is the one place the launch economics and the protocol's price disagree.

Ownable2Step (OpenZeppelin v5) keeps Ownable.renounceOwnership(): a one-step, immediate, irreversible onlyOwner call that sets owner() to address(0). The brief describes handover as two-step and every owner power as permanent operational roles.

DevPrices.owner() is the single key for three things: the three price setters (DevPrices.sol:68-84), BuybackBurner.setBuybackWallet (src/BuybackBurner.sol:76 if (msg.sender != dev()) revert NotDev(); with dev() = IOwned(devPrices).owner()) and TaskVault.cancelTask of the later core (src/TaskVault.sol:373 Ownable(ParamsRegistry(registry).core(t.paramsVersion).devPrices).owner()).

After one renounce by 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981 nobody can ever change a price, the buyback wallet, or cancel a task created under version 1.

ParamsRegistry (src/ParamsRegistry.sol:21 contract ParamsRegistry is Ownable2Step {) has the same call: after it no attester can be rotated (a leaked signer key stays accepted by AttestationChecker.check for every live and future task), no parameter version can be proposed, new tasks can never be paused or unpaused, and TaskVault.bindSweetener (src/TaskVault.sol:159) reverts NotAuthorized forever. TrophyCatalog (src/TrophyCatalog.sol:13) likewise freezes the designs.

No funds move or freeze, so this is a trust-assumption gap rather than a loss: the one-transaction abandonment path is not listed in the brief and nothing can re-assign an owner afterwards. Merged from audit_permissions (two findings) and audit_flow (info). Recorded as a note per the assignment; a design-preserving fix would be function renounceOwnership() public pure override { revert(); } in each contract.

executeAttester, activateParams (src/ParamsRegistry.sol:92-101) and ProtocolDirectory.addVersion / setCurrent (src/ProtocolDirectory.sol:89-95, 116-125) check only block.timestamp >= eta; there is no grace period after which a proposal lapses, and nothing but an explicit cancel by the owner removes it.

A proposal the owner made and then abandoned (a key rotation that was later judged unnecessary, a parameter set superseded by events, a directory version that was never meant to become current) can be executed by any address months later, at a moment of the executor's choosing, which is the opposite of what a timelock is meant to guarantee (the owner announces a change and it lands at a known time).

The attester set is global, so a stale (attester, true) proposal executed later re-admits a signer for every live task.

Impact is bounded: it needs an uncancelled proposal, and the owner can cancel at any time before execution; no funds move. The pattern is the same in both timelocked contracts, so it is one finding.

economics.initialMarketCapWei = 15,000 IMD for 1e9 YOLO; at the fixed IMD price of $5.5 that is $0.0000825 per YOLO, 12.12x below the DevPrices start of 1e15 ($0.001). The only consumer is CaseDesk._stakeBps (src/desks/CaseDesk.sol:532 DevPrices(p.devPrices).yoloValue(t.currency, t.pot)), which converts the task pot into YOLO at the dev price and pays up to MAX_STAKE_BONUS_BPS = 400 bps of the reward when the lock power covers it.

A higher dev price means a smaller YOLO-denominated reward, so the full bonus is reached with 12x less YOLO locked than the opening valuation would require.

Who pays: the bonus comes out of the fee's stakers' 5% (DisputeDesk._payReward), so only the treasury's and the burn's share shrink, by at most 4% of the staked doer's reward; nobody outside the protocol loses and the cap makes it non-compounding. The brief fixes every price and the owner can correct it in two calls (1e15 -> 1e14 -> 8.25e13, MAX_STEP = 10). Already recorded in ADAPTATION.md; restated with the launch's numbers.

Not a defect of the code.