The review is complete and the findings file is written and validated.

Outcome. No critical or high defects were found in the contracts as they arrived, so no proof tests were attached. The findings file at .imd-findings.json holds nine entries: one medium, five low, three info. Every snippet was checked against the tree line by line, and each defect was reproduced with a scratch Foundry test under test/scratch/ before being reported.

What was read. PinkyVault, PinkyStaking, OracleAttestation, LaunchToken, the IIntake interface, all project tests and mocks, launch.json, README and the request bodies. OracleAttestation is byte-identical to the reference copy. The protocol conformance vector passes, the callback completes under a 200,000 gas call, and the runtime bytecode of both application contracts contains no forbidden opcodes and is well under the size limit. The token mints exactly one billion PINKY to its deployer with no admin paths. The manifest matches the constructor order and types and the reference's Robinhood Chain addresses.

Findings, most severe first:

• Medium. PinkyStaking permanently strands the rest of a reward stream whenever everyone unstakes, and it has no owner or sweep. Forfeited IMD sent "to stakers" can become unreachable.
• Low. Panel settings are checked at delivery time against current owner values, so a routine setPanel while a request is pending discards a correct answer and wastes the fee.
• Low. The callback does not require agreed >= quorum, which the oracle reference asks for. An attestation with agreed 0 decides the bond.
• Low. The maker can call ask on their own broken promise and take the 10% bounty, cutting the penalty to 90%.
• Low. Owner trust assumption missing from the README: setProtocol can point at an intake whose price equals a bond, moving the whole bond there on the next ask.
• Low. Anyone can re-ask after the one-day timeout, which kills a still-valid late answer and spends another fee from the maker's bond.
• Info. Transfers between endTime and whoever calls close are counted, a trap for makers who do not close promptly. The questionHash is not pinned, so pairing rests on the writer. A coverage entry lists what was verified and what was not.

Not reachable offline. The live Intake, IMD and ArbSys behaviour on chain 4663, whether the oracle accepts toleranceBps and a 30-day block window as wide as MAX_DURATION allows, the launch's pool section for fee and tick spacing, and the policy owner that $owner resolves to. The widest-window case matters because an unanswerable question refunds the maker.

Done. The project builds and all tests pass with its own configuration, and the work is confined to source, tests, README, ADAPTATION.md and one manifest value.

What I found

The repository already met the factory's shape: a fixed-supply LaunchToken named Pinky / PINKY, nonpayable constructors with the owner as an argument, no proxies or forbidden opcodes, and constructors that call no other contract. The attestation library is byte-identical to the protocol reference. All six actionable audit findings reproduced against the unchanged code in scratch tests.

What I changed

• src/PinkyStaking.sol: stream time that passes with nobody staked is now credited to the next staker instead of being stranded forever. One line in the reward modifier.
• src/PinkyVault.sol: a per-promise terms record. It stores the oracle price seen at make time, so the owner cannot redirect a bond through a dearer intake, and the panel each request was bought with, so a panel change mid-flight no longer refuses a correct answer. The callback now requires that at least quorum members agreed. A maker who asks about their own broken promise earns no bounty, and the first watcher keeps the bounty across re-asks. A re-ask no longer kills the earlier request, so a late valid answer still counts.
• launch.json: pool fee 3000 changed to 12500, the only value the launch terms required. Constructor arguments are untouched because the constructor signatures did not change.
• Tests: new test/LaunchToken.t.sol and test/PinkyStaking.t.sol, nine new vault tests including a cold-storage 200,000 gas check, and one existing test rewritten because it encoded the old re-ask behaviour.
• README.md and ADAPTATION.md: every change, the finding or rule that required it, the two info findings left as documented trust assumptions, and the launch section.

Verification

Check	Result
forge build	passes
forge test	46 project tests pass
scratch floor emulation on chain 4663	passes, vault runtime 12,528 bytes, no forbidden opcodes

Nothing was run against the live chain, and no commit was made since the git directory is out of scope for this task.

launch.json is written and verified. The build and all 46 tests pass, and the manifest is the only changed file.

What the manifest declares

• Token: LaunchToken, name Pinky, symbol PINKY, 18 decimals, no constructor arguments. This matches the accepted source.
• PinkyStaking: two address arguments, the launch token via $token and IMD as the reward token. It has no owner, so no $owner is passed.
• PinkyVault: ten arguments in declaration order. Owner from policy via $owner, IMD, $contract:PinkyStaking, the Robinhood Chain Intake, the padded action id for oracle.request@oracle-1, the oracle signer, a 5 IMD minimum bond, panel 7, quorum 5, and 86400 seconds of answer validity.
• Pool: IMD as the paired currency, fee 12500, tick spacing 60, and the one-to-one initial price, exactly as the launch terms give them.

How it was checked

• The Intake, signer, IMD and action id values match the live Robinhood Chain table in the oracle-consumer reference.
• A scratch Foundry test deployed all three contracts on an empty chain 4663 from a factory address with the exact manifest arguments and confirmed every stored setting, the supply staying with the deployer, and runtime sizes under the EIP-170 limit.
• A script checked the manifest keys, string and number types, lowercase addresses, name lengths and uniqueness, one argument per constructor parameter from the compiled ABI, backward-only references in address slots, and the notes length.

The previous manifest from the earlier contributor already carried these arguments. The only substantive change is the notes field, which now spells out each constructor parameter, the owner's setters, and that no contract receives launch supply.

Review complete. The findings file is written at the repository root with four findings and a coverage row for all 16 entry points plus three invariants.

What I checked

• Traced every PinkyVault and PinkyStaking entry point through its guards, state writes and failure paths against the Execution Trace, Periphery and First Principles guides.
• Confirmed OracleAttestation.sol is byte-identical to the protocol copy, the conformance test deploys PinkyVault at the vector address, and the callback uses 89k gas cold under the 200k stipend.
• Verified against Robinhood Chain and the oracle API: ArbSys block numbers match the RPC, the Intake quotes 0.5 IMD, the signer in launch.json matches the live attester, and the body the vault builds (including toleranceBps) is the one the oracle attested on 2026-10-09.
• launch.json constructor arguments match both constructors in declaration order; constructors make no external calls.

Findings

1. Medium. A 30-day term yields a window of about 26 million blocks (measured ~10 blocks/s). The oracle has only been shown to answer 1,000 to 18,000-block windows, with panel members scanning ten blocks per call. An unanswerable window ends in refund, so long promises favour a maker who broke them. The oracle-side failure is inferred, not demonstrated. I recommend one live request over a multi-day window before launch.
2. Low. The "maker earns no bounty" rule compares addresses only. A maker's second wallet asks first and takes 10% of the forfeited bond. Reproduced in a scratch test.
3. Low. A signed chain-evidence answer with agreed below quorum is refused, and three refusals refund a broken maker. This follows the skill's guidance, so it is a trade-off for the author to decide. Reproduced.
4. Info. After a gap with no stakers, a 1-wei staker is credited the whole idle stream in one block. This is the documented design.

No critical or high defects were found, so no proof files are attached. All 46 project tests pass unchanged. The scratch tests under test/scratch/ are mine and need not be kept.

The findings file is in place at the repository root (the harness excludes it and the scratch directory from git, which is expected for a review). No tracked file was changed. The review is complete.

Outcome: .imd-findings.json holds 5 findings and 19 coverage rows for the Economic Security, Invariant and Flow Gap area. One finding is medium and carries a failing Foundry proof; three are low; one is an info-level lead that cannot be verified offline.

Findings, by severity:

• Medium, ask price cap (src/PinkyVault.sol:201). ask refuses any Intake quote above the one recorded at make. When the real Intake raises the price by any amount, no open promise can ever be asked, and after the 7-day grace refund returns the whole bond to the maker regardless of whether they dumped. The protocol's core guarantee fails for the entire open book at once. The proof test in test/scratch/PriceRiseStrandsVerdict.t.sol fails on this tree. The proposed fix keeps the owner-redirect protection by recording the Intake at make, while allowing a same-Intake price up to the bond or an asker top-up.
• Low, bounty rule bypass (line 273). The "maker gets no bounty" rule keys on the asker address, so a maker asks from a second wallet and keeps 10% of a forfeited bond, front-running honest watchers. Logged: 0.95 IMD on a 10 IMD bond.
• Low, zero quote at make (line 155). A zero Intake quote (unsold action id, or a free action) is accepted and stored as maxPrice 0, so the promise can never be asked and always refunds.
• Low, staking restretch (src/PinkyStaking.sol:106). Permissionless notify with 0.01 IMD per day stretches the stream so stakers receive about 14.5 of 22 IMD within the advertised seven days.
• Info, 30-day windows. A 30-day term yields a block window two to three orders of magnitude beyond the 1,000-block range the live check answered. Recorded as a lead for one live request before launch.

What held: the vault's bond conservation across make, ask, payout and refund; the staking gap-credit accounting, confirmed by a scratch solvency invariant over 1,649 handler calls; the callback at 89,364 gas from cold under the 200k stipend; the payout try path, which cannot be gas-griefed into burning the staker share; and the launch manifest's argument order, live addresses and owner placeholder.

Not reached: behaviour against the live oracle (window-size limits, callback delivery on chain), which no offline test can establish.

The review is complete. The findings file is in place, no tracked file changed, and the scratch tests are excluded by the harness as expected.

Outcome. The math, boundary and numerical-gap pass over PinkyVault and PinkyStaking found one medium and two low defects, each with a reproduced trace. The file .imd-findings.json holds them plus coverage rows for all 16 listed entry points and two invariants.

Findings

• Medium, PinkyVault.make. The Intake's priceOf returns 0 for an unsold action rather than reverting. I confirmed this live on Robinhood Chain for the oracle-2 action id and for the native asset. make accepts that zero, since the floor check degenerates to bond < 0, and records maxPrice = 0. ask then refuses the promise forever, both while the price is 0 and once any price is quoted. The only exit is a full refund seven days after close, so every promise made in that window is unenforceable while still looking bonded. The oracle-consumer reference requires the action id to be switchable for a new version, so the window is ordinary operation. Proof attached: test/scratch/ZeroPriceProof.t.sol fails today and passes once make rejects a zero price.
• Low, PinkyStaking.stake. The earlier audit fix freezes lastUpdate while nobody is staked, so the whole idle stream is credited to the first arriving stake in its first update, regardless of size or stay. A 1-wei stake, unstake and claim in one transaction collected about 6 IMD of a 7 IMD stream in the scratch test, and a staker arriving a second later earned nothing. This contradicts the contract's own docstring, though the README documents the general behaviour.
• Low, PinkyVault.payout, outside my area. The "maker gets no bounty" rule compares addresses only. A maker asking from a second wallet receives the 10% bounty on their own broken bond, as the scratch test shows.

Coverage. Every entry point has a row. Staking's restretch and reward-per-token arithmetic conserve value up to documented dust, with large headroom given the live IMD supply. The payout split always sums exactly to the remaining bond, the burn transfer and zero-value transfers succeed on the live IMD token, and ArbSys is present on chain 4663 so the block source matches the oracle's. One note without a failing input: the 30-day maximum term is roughly 25 million blocks at the measured cadence, while the live oracle check covered 18 thousand.

The findings file is intentionally excluded by the harness's own .git/info/exclude, so the platform collects it from the working tree rather than from a commit. Nothing more to do there.

Recap

Result: forge test passes with 120 tests (46 existing, 74 new) across 9 suites, two of them invariant suites at 256 runs × 64 depth with zero reverts. No critical or high defect was found in the contracts, so no proof files were needed. Five design-level observations are recorded in .imd-findings.json (two low, three info), each tied to a test that demonstrates the behaviour.

What I added under test/:

• PinkyVaultEdges.t.sol (52 tests): constructor zero/boundary refusals; make at exact duration and bond boundaries, without allowance, with a fee-on-transfer IMD, under a zero price quote; close/ask at exact block and time boundaries, with the Arbitrum block path; Intakes that revert, pull the wrong amount, pull nothing, or reuse a request id; the callback with expired, not-yet-valid, wrong-length, inconsistent-panel, replayed, tampered, other-vault and other-chain attestations, from senders that never asked, and after a refund; delivery under the real 200,000 gas stipend from cold storage, including a refused delivery leaving the request pending; payout when the staker share is below the stream floor or the bond is fully spent; refund timing and independence from the Intake; owner setter bounds; three fuzz properties (verdict boundary, exact broken split, exact refund).
• PinkyStakingEdges.t.sol (17 tests): zero amounts, over-unstake, allowances, floor/restretch arithmetic, late and flash stakers, the idle-stream rule, full-supply stake, rounding at one wei, and two fuzz properties (pro-rata at every moment, no over-payment across notifies).
• PinkyStakingInvariant.t.sol: a three-staker, two-notifier handler with invariants that PINKY held equals the stakes, nobody withdraws more than staked, IMD held covers what is owed, nothing is paid twice, and every wei is claimed, owed, streaming, idle or bounded dust.
• PinkyInvariant.t.sol (extended, not rewritten): a transition checker after every handler call so a promise only moves forward and never reopens, a maker-asker action, exact split assertions in payout, and invariants that the bond equals deposit minus fees paid and that verdicts are final.
• OracleConsumerVectorKey.t.sol: the vault at the protocol's vector address, driven through make/close/ask, with the vector's own signature passing the signature check in the real callback and an answer signed by the vector key settling the promise under the stipend.
• mocks/MoreMocks.sol and utils/PinkyFixture.sol: a stipend-delivering Intake, misbehaving Intakes, a fee token, and a shared fixture at the launch's configuration.

Findings reported (none change the launch as configured):

• Low: the idle reward stream is credited in full to the next staker, even a one-wei flash stake in one transaction.
• Low: a promise made while the Intake quotes zero can never be asked, only refunded.
• Info: permissionless notify can restretch the stream for 0.01 IMD per call; stale request ids remain mapped after refund (harmless, status-guarded); and the burn transfer to the dEaD address against the live IMD token is a fork check still owed, since this run had no network.

The review is complete. No tracked file was changed; the only writes are .imd-findings.json in the repository root and two scratch tests under test/scratch/.

Outcome: the permission model holds. Two low defects and one documented trust assumption, all in .imd-findings.json.

What I checked in the assigned area (Access Control, Trust Gap, Asymmetry):

• Every privileged path is onlyOwner with non-zero checks, the signer is writable only through the owner setter, and the oracle callback is bound to the intake that was asked via a mapping only ask writes. An outsider's own Intake request cannot be matched to a promise.
• Paired surfaces (make/payout/refund, ask/onOracleResult, stake/unstake, Kept/Broken branches) mirror their state writes. Bonds are zeroed before transfers and the staking approval is always reset.
• Live inputs verified on Robinhood Chain: IMD and the Intake have code, the quote is 0.5 IMD for the manifest action id, ArbSys answers, the signer is an EOA, and the cited oracle request is attested with the vault's exact body shape. The vendored OpenZeppelin is identical to upstream v5.5.0 apart from line endings. All 46 project tests pass.

Findings:

1. Low. Maker captures the watcher bounty from a second wallet. The asker == maker exclusion in payout is defeated by asking from any other address at the first eligible block. Stakers and the burn receive 90% of a forfeited remainder instead of all of it, and a maker can deny a watcher's bounty for free. The README states the opposite guarantee and the earlier audit recorded it as fixed.
2. Low. make accepts a bond under a zero Intake quote. The live Intake returns 0 for an action it does not sell, so after an action retirement or a mistyped action id, every new promise freezes a zero price ceiling and can never be asked. The only exit is a refund to the maker whatever they transferred. This finding carries a proof test that fails on current code.
3. Info. Owner trust assumption. The owner can forge verdicts via setSigner and divert up to three oracle fees per promise via setProtocol. This is documented in the README and has no unprivileged amplifier, so it is recorded with actor and preconditions rather than as a defect.

Coverage: all 16 entry points have a row. Thirteen hold, three point at findings 1 and 2. One row is marked unreached for oracle behaviour on 30-day windows and split panels, which is outside my area and not reproducible offline.

The diff is confined to the findings. Everything is done and verified.

Both required findings reproduced and are fixed. The reviewer's proofs failed on the starting tree and pass now.

• Zero quote at make (src/PinkyVault.sol): make now reverts with InvalidPayment when the Intake quotes 0, mirroring ask. A read-only call to the live Intake confirmed it returns 0, not a revert, for the unsold oracle-2 action.
• Price rise strands promises (src/PinkyVault.sol): Terms records the Intake and action at make. At that same protocol, ask accepts any price up to the remaining bond. The old cap now applies only to a different Intake or action the owner set later, which is the owner-redirect case the audit fix was for.

Advisory findings I judged real and changed (src/PinkyStaking.sol):

• Flash stake on idle time: the stream pauses while nobody is staked and resumes for the time it had left. A 1 wei flash stake earns nothing. One earlier test changed with the behaviour.
• Dust notify restretch: a notify never lowers the rate. Dust keeps the current rate and ends sooner. A large payout still raises the rate over seven days.

Advisory findings answered without code changes:

• Maker's second wallet bounty: no address rule can exclude it. The README now says the sure penalty is 90% and the bounty is a rebate to the first asker.
• Split panel refusal: kept deliberately per the oracle-consumer reference, documented as a trade-off.
• Burn address: verified on the live IMD token via eth_call. The dEaD address holds 28.1 IMD and a simulated transfer returns true.
• 30-day window and owner trust: documented as a pre-launch check and a stated trust assumption.

Verification: forge build and forge test pass with 53 project tests plus the two proofs. A scratch copy of the protected floor passes on an empty chain 4663 with the launch.json arguments. Constructor signatures are unchanged, so launch.json still applies. All nine findings are answered in .imd-responses.json, and ADAPTATION.md has a revision section listing each change.