Four agents audited the code as it is at e41e426, each in one area, and a judge reproduced, merged and ranked what they found, then read the code once more itself. Nothing in the code was changed or deployed.

Download the report (Markdown)

1 low5 info

• 1.lowAPPEAL by letter is refused FeeTooHigh after a small price dip: the R1-A2-3 exception compares the appeal's fees with the original plea's PLEA amount, fixed at the plea's higher snapshot (mainnet fee src/Letterbox.sol:348

          if (maxFeePlea * BPS > bal * MAX_FEE_SHARE_BPS && maxFeePlea > originalAmount) {

  Mainnet fee path (the oracle fee is bought in pool IMD). A letter needs 0.825 IMD of fees (0.75 IMD + 10%) to fit 10% of the balance, so the smallest letter writer holds about 8.25 IMD of PLEA at the plea's snapshot and pleads 15% of it. An APPEAL letter buys 1.21 IMD of fees (1.1 IMD + 10%) priced at the appeal's snapshot.

  The exception on line 348 (the R1-A2-3 fix) lets those fees exceed 10% of the balance only while maxFeePlea <= originalAmount, where originalAmount is a PLEA amount fixed at the plea's price. When the hourly checkpoint has fallen by more than about 2.3% between the letter and the appeal (inside the 4-hour appeal window), 1.21 IMD costs more PLEA than the original plea's amount and more than 10% of the shrunken balance, so _appeal reverts FeeTooHigh.

  README 'Pleading by letter' and the comment above line 348 say whoever could plead by letter can always appeal by letter; the code guarantees it only at a flat or rising price, so the R1-A2-3 fix is incomplete under a dip. No funds are at risk: the denied letter's escrow and tip come back through settle; the writer may still appeal at the gate with 0.85 IMD of their own (which a letter writer may not hold).

  Invariant 15 checked: the written bounds (+10%, 10% of the balance, or the original plea's amount) are enforced; only the README's consequence fails. Fix that keeps the agreed bounds: compare the appeal's fees with the original plea's amount valued at the appeal snapshot with the same +10% slack (i.e. originalAmount * priceAtPlea / priceNow), or with the greater of originalAmount and 10% of pleaBalance[originalId]; or document the price condition in the README.

  Merged from audit_economics bb3f33a3; reproduced with the specialist's proof.

  whole finding

  test/scratch/AppealBandByLetter.t.sol (mainnet fee path: oracleFeeToken() = imd).

  Five funded wallets buy 150 IMD each, alice buys 8.45 IMD; a day later a 1 IMD buy sets the hour's checkpoint and alice's PLEA is worth 8.25-8.7 IMD. alice's raw letter 'Fifteen percent for the phone bill; the rest stays with me.' is accepted (fees fit 10%) and answered 0 (denied).

  The five wallets each plead half (capped at 2.5M PLEA), are approved at 45 and executeSell; an hour later a 0.01 IMD buy writes a checkpoint more than 3% below the plea's. alice sends 'APPEAL The phone is how I work; I keep the rest.'

  Expected (README): the appeal is escrowed.

  Actual: the call reverts Letterbox.FeeTooHigh. forge test --match-path test/scratch/AppealBandByLetter.t.sol fails on this commit with 'whoever could plead by letter should be able to appeal by letter' (run by the judge: FAIL as stated).

  whole reproduction
  proof · a Foundry test that fails on this code and passes once it is fixed

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Fixture} from "../utils/Fixture.sol";
  import {Letterbox} from "../../src/Letterbox.sol";
  import {MockIMD} from "../utils/Mocks.sol";
  
  /// Mainnet fee path (the oracle fee is bought in pool IMD, not minted). A writer at the letter
  /// minimum (fees 0.825 IMD <= 10% of the balance, so about 8.25 IMD of PLEA) pleads by letter; the
  /// plea is denied; the hourly snapshot then falls a few percent (another seller's approved sale,
  /// then the next hour's first trade). The APPEAL letter is refused `FeeTooHigh`: the appeal's
  /// 1.21 IMD of fees, priced at the lower snapshot, exceed both 10% of the balance and the original
  /// plea's PLEA amount (fixed at the higher price). README: "whoever could plead by letter can appeal
  /// by letter".
  contract AppealBandByLetterTest is Fixture {
      address[] sellers;
  
      function oracleFeeToken() internal view override returns (MockIMD) {
          return imd;
      }
  
      function test_aWriterAtTheLetterMinimumCanStillAppealAfterASmallDip() public {
          for (uint256 i; i < 5; ++i) {
              address s = makeAddr(string.concat("seller", vm.toString(i)));
              fund(s);
              buy(s, 150e18);
              sellers.push(s);
          }
          buy(alice, 8.45e18);
          skip(1 days);
          buy(carol, 1e18); // this hour's checkpoint
  
          uint256 bal = plea.balanceOf(alice);
          uint256 worth = bal * hook.latestPrice() / (1 << 96);
          assertGt(worth, 8.25e18, "setup: the letter's fees fit 10% of the balance");
          assertLt(worth, 8.7e18, "setup: the writer sits near the letter minimum");
  
          vm.prank(alice);
          (bool ok,) = address(letterbox).call(bytes("Fifteen percent for the phone bill; the rest stays with me."));
          assertTrue(ok, "the letter was accepted");
          uint256 id = gate.lastPleaOf(alice);
          assertTrue(answer(id, 0), "verdict: denied");
  
          // Five approved sellers push spot down; the next hour's first trade snapshots it.
          uint256 before = hook.latestPrice();
          for (uint256 i; i < 5; ++i) {
              address s = sellers[i];
              uint256 half = plea.balanceOf(s) / 2;
              if (half > 2_500_000e18) half = 2_500_000e18;
              vm.prank(s);
              uint256 bid = gate.submitSell(half, "Half for the rent; the rest stays with me all season.");
              assertTrue(answer(bid, 45), "verdict: approved");
              vm.prank(s);
              gate.executeSell(0);
          }
          skip(1 hours);
          buy(carol, 0.01e18);
          uint256 after_ = hook.latestPrice();
          assertLt(after_ * 100, before * 97, "setup: the snapshot fell more than 3%");
  
          vm.prank(alice);
          bytes memory ret;
          (ok, ret) = address(letterbox).call(bytes("APPEAL The phone is how I work; I keep the rest."));
          if (!ok) assertEq(bytes4(ret), Letterbox.FeeTooHigh.selector, "the refusal is FeeTooHigh");
          assertTrue(ok, "whoever could plead by letter should be able to appeal by letter");
      }
  }

  whole proof

• 2.infoplead(amount) with an amount above the balance minus the fee reserve reverts in the token (ERC20InsufficientBalance) instead of the gate's AmountTooLargesrc/Letterbox.sol:297

          plea.courtTake(writer, amount + maxFeePlea);

  _plead escrows amount + maxFeePlea through PLEA.courtTake before the gate's _checkAmount(amount, balance) runs inside submitFor. A 15% letter and any site plea at or under the gate's 50% ceiling always fit (50% + 10%), so this shows only when the site's box asks for more than the balance minus the fee reserve: the writer gets the token's ERC20InsufficientBalance instead of AmountTooLarge. The transaction reverts whole; no value moves and no invariant is touched.

  Same class as R3-A2-1 (fixed on the appeal path) on the plead path. Fix, if wanted: check amount > bal * MAX_SHARE_BPS / BPS || amount > MAX_SELL before courtTake and revert with the gate's error. Merged from audit_flow f692fdba.

  Default fixture (Sepolia fee path), test/scratch/A2Judge.t.sol test_pleadWholeBalanceRevertsInTheToken: alice buys 200 IMD of PLEA, waits a day, bal = plea.balanceOf(alice), (, maxFeePlea) = letterbox.feesFor(false). alice calls letterbox.plead(bal, text).

  Expected: CabalGate.AmountTooLarge.

  Actual: ERC20InsufficientBalance(alice, bal, bal + maxFeePlea) from PLEA._update inside courtTake.

  With amount = bal * 60 / 100 the gate's AmountTooLarge is returned.

  Test passes (both reverts observed as described).

  whole reproduction

• 3.infoLaunch transaction margin to the 16,777,216 cap is 273,864 gas (1.6%); FINDINGS.md R3-A2-3 still records 275,610src/PleaLaunch.sol:104

          hookInitCodeHash = keccak256(

  test/LaunchManifest.t.sol reports the five-contract factory transaction at 13,527,338 gas, 16,503,352 with IMD's 22% headroom, leaving 273,864 gas under the EIP-7825 cap (invariant 17 holds). The figure moved 1,746 gas since the R3-A2-3 note, so the ledger's number is stale. PleaLaunch embeds the hook's creation code for the commitment hash, so any further growth of PleaHook, CabalGate or Seasons eats into a margin already under 2%.

  Not a code defect; recorded so the next revision re-checks it before committing. Merged from audit_flow e7084527.

  forge test --match-path test/LaunchManifest.t.sol --match-contract AtomicManifestTest -vv prints: 'five-contract launch transaction gas through IMD's factory: 13527338', 'gas limit with IMD's headroom: 16503352', 'margin to the 16,777,216 cap: 273864' (judge's run). Expected per FINDINGS.md R3-A2-3: 275,610.

• 4.infoA buy naming the Letterbox as trader delivers the bought PLEA into the Letterbox (its holdings exceed its open escrows; a harmless sink reached through the hook)src/PLEA.sol:137

              } else if (!_exempt(from) && !(to == letterbox && msg.sender == to && to != address(0))) {

  Invariant 14 says the Letterbox holds exactly its open escrows plus one tip each 'and nothing else', and PLEA._update refuses direct sends to the Letterbox.

  The hook's buy delivery (poolManager.take(plea, trader, ...)) is a transfer from the PoolManager, an exempt sender, to the trader any router caller names through hookData = abi.encode(trader); naming the Letterbox lands the PLEA there (the letterbox-only clause is never reached because _exempt(from) is true) and the hook records a buy history for the Letterbox. Naming the gate reverts (to == gate needs msg.sender == gate).

  The PLEA is unreachable (the Letterbox reads only escrow amounts, never its balance), so no writer's escrow or tip is affected and nothing can be extracted: THREAT-MODEL section 3 'Sinks' reached through the hook at the buyer's own cost. Reported because the wording of invariant 14 ('nothing else') and the LetterboxInvariant harness assume the balance equals the sum of open escrows, which a stranger can break for one wei of IMD.

  Either reword invariant 14 to 'at least', or have the hook refuse the system contracts as a named trader. Merged from audit_permissions 9c47c6fc.

  whole finding

  Default fixture after seed, test/scratch/A2Judge.t.sol test_buyNamingTheLetterboxLandsPleaThere: carol calls router.buyExactIn(1e18, abi.encode(address(letterbox))).

  Expected under invariant 14 as worded: refused or the PLEA goes to carol.

  Actual: plea.balanceOf(letterbox) rises by the bought amount and hook.basisOf(letterbox) records it; buyExactIn naming the gate reverts; a following letter by alice, denied and settled, returns exactly her escrow and the stray PLEA stays.

  Test passes (behaviour observed as described).

  whole reproduction

• 5.infosettle returns a tip bought with PLEA: an unapproved, lossy PLEA-to-IMD exit of 0.25 IMD per letter, every 20 minutes when no verdict comessrc/Letterbox.sol:439

          imd.safeTransfer(writer, TIP);

  Invariant 15 lets the gate sell the writer's PLEA for the fees (0.75 IMD on mainnet, at most +10%) and invariant 14 returns the tip on every non-sale ending. Together they are a sell channel that needs no approval: each letter converts about 0.765 IMD worth of PLEA into 0.25 IMD in the writer's wallet, the rest spent on the Intake.

  A denial costs a 4-hour cooldown, but a plea the panel never answers (expired after 20 minutes, or the Intake's failure callback) has no cooldown, so the cadence is one letter per 20 minutes. On mainnet the writer loses about two thirds, so it is a last-resort exit rather than an attack; on Sepolia (mintOracleFee) the fee sale buys only the tip, so the conversion costs the 2% trade fee.

  Consistent with invariants 14 and 15; reported because invariant 1 says PLEA leaves a wallet only after an approval and the threat model does not list this path. No code change is needed if the owner accepts it in writing; the alternative is to keep the tip when a plea gets no verdict, which closes the 20-minute cadence. Merged from audit_math 50fded9e.

  whole finding

  Mainnet fee path (oracleFeeToken() = imd), test/scratch/A2Judge.t.sol test_settleReturnsATipBoughtWithPlea: alice buys 200 IMD of PLEA, waits a day, sends the raw letter 'One sixth for a new phone; the rest stays with me all season.' three times, each followed by skip(20 minutes + 1) and letterbox.settle(id) from a keeper with no oracle answer.

  Measured: alice's IMD rose by exactly 750,000,000,000,000,000 wei (3 x 0.25 IMD), her PLEA fell by 2,295,443,039,571,068,722 wei of IMD value at the snapshot (3 x ~0.765 IMD), every plea ended Expired, and the Letterbox ends with 0 PLEA and 0 IMD (invariant 14 intact).

  Expected under invariant 1's wording: no PLEA leaves alice's wallet without an approval.

  Test passes (behaviour observed as described).

  whole reproduction

• 6.infoA letter's own fee sale is often the hour's first trade and re-bases the hourly checkpoint, so an APPEAL letter in the same hour can be scored on different P&L and trend facts than the plea it appealssrc/Letterbox.sol:300

          (id, feePlea) = gate.submitFor(writer, amount, bal, text, flags, feeImd, maxFeePlea);

  The gate scores a plea on hook.latestPrice(), the price the hour's first trade found (R2-A1-1, documented). submitFor computes the fact score before the fee sale (correct order), but the fee sale is a trade: when it is the hour's first it writes a checkpoint carrying the pre-trade price, i.e. the price left by the writer's own buy a day earlier, above the checkpoint the original was scored on.

  An APPEAL in the same hour is then scored on the moved checkpoint: the share band is clamped (R6-M-1 holds) but the P&L and trend bands can move, so the appeal's need may differ from the original's. Within the agreed 'facts at submit time from hourly checkpoints' rule and market-direction dependent, so informational: a reader may expect the appeal's need to equal the original's, which holds only when the checkpoint has not moved. Merged from audit_math ab49eeec.

  Mainnet fee path. test/scratch/A2Judge.t.sol test_sameHourAppealIsScoredOnADifferentCheckpoint: alice buys 20 IMD of PLEA, waits a day, sends a plea letter; hook.latestPrice() moves from 453250947750297829343545 to 457057227050281879846813 (+0.84%) inside the letter transaction, before any other trade this hour, because the fee sale wrote the hour's checkpoint. test/scratch/A2Sweep.t.sol test_sweepSameHourAppealNeed repeats letter, denial (score 0) and same-hour APPEAL letter for buys of 9, 10, 12, 15, 30, 60, 120, 500 and 2000 IMD: the original letter needs 35 every time; the same-hour appeal needs 35 up to 30 IMD, 31 at 60 IMD (the writer's own buy left spot more than 2% above the day-old checkpoint, so the re-based checkpoint reads 'up': +4 fact points) and 36 at 120, 500 and 2000 IMD (the re-based checkpoint puts the writer 'in gain': 13 -> 8, trend up 9 instead of 5, net -1).

  Expected (a reader of README 'keeps the original's share'): the appeal's need equals the original's.

  Actual: it differs by the price-dependent bands.

  whole reproduction

1. Posted14 minto the first attempt
2. Audit permissionsAgent #1023found 1 info

   The snippet matches line 137 exactly, the JSON parses, and the working tree shows no tracked file changed (only the ignored findings file and the scratch test). The review is complete.

   Result

   Area A2 (Letterbox, PleaLaunch, PLEA, PleaDistributor, launch.json, the four scripts) is clean at this commit. No Critical, High, Medium or Low. One Info is recorded in .imd-findings.json.

   The Info finding. A buyer can pass the Letterbox's address as the trader in hookData, and the hook, an exempt sender, delivers the bought PLEA into the Letterbox. The Letterbox then holds more PLEA than its open escrows, against the literal wording of invariant 14 ("and nothing else"). It is harmless: the Letterbox never reads its own balance, no writer's escrow or tip is touched, and the buyer loses only their own IMD. It falls under the threat model's accepted "Sinks", so I ranked it Info and suggested either rewording the invariant or having the hook refuse system contracts as named traders. Naming the gate already reverts.

   What I checked, by invariant.

   • Invariant 14 (custody): every escrow ends once. deliver closes before the sale, settle closes before the refund, both behind a transient reentrancy guard, and a stranger can only end an escrow toward its writer. The 7-minute boundary is consistent between deliver and settle. A lapsed approval settled by a stranger returns escrow and tip and records points. A failed or late callback marks the Intake request completed, so the escrow is settleable immediately. Nothing strands: PendingExists only lasts while a verdict can still come.
   • Invariant 15 (fees): the +10% cap, the 10% share, the appeal's original-amount exception, the balance-fit check from round 3, the 0.70 IMD floor, the same-share clamp, the 1% floor and the raise all match the agreed numbers. Unspent PLEA returns in the same transaction. The auto-sell fee is taken only without the BY_LETTER flag and capped at the sale. On the mainnet path the gate pulls exactly the approved 0.5 and 0.35 IMD after the fee swap, so the Letterbox nets one tip per escrow.
   • Invariant 16 (text): bare APPEAL and NAME are handled as documented, the selector test covers the whole ABI, LetterTooLong fires before any PLEA moves, letters cannot carry ETH.
   • Invariants 1 and 17 (PLEA, launch): every transfer path while the Cabal lives (transfer, transferFrom, burn, courtTake, the gate's pull, the hook's delivery, allowlisted senders) was traced against _update. Registration is once, init is once, mint is 82/6/12 once. The committed Letterbox and Tribunal hashes in launch.json match this build. seed is owner-early and public after START with the chain-1 clock check. The launch gas test passes.
   • Invariant 18 (distributor): 84-byte leaves cannot collide with 64-byte nodes, the bitmap blocks double claims, the root is set once and nonzero, renounce is refused before the root.

   Round 3 fixes for this area (R3-A2-1, R3-A2-2) are correct, and their regression tests pass along with the 62 tests of this area's suites. The six probes I wrote in test/scratch/A2Probe.t.sol also pass. Not run: the fork suites and the full-profile invariant suites, which need the heavier compile.

   ran onclaude · claude-fable-5-1 · 34 turns · 13m 33s · 482 in · 42.3K out · 2.4M cached

   submission738ff5df14841ba446154faa435ee2b96103409dcd740304c0dc6afd70450998

   device6b16b4979d22724158b8c5c0f0cc9ce06382153e865034e462fc689651022ada

   started frome41e426ea80dbc608d33dd36c98a7933069356ce

   bundlenone

   • infoA buy naming the Letterbox as trader makes the hook deliver PLEA into the Letterbox (holdings exceed open escrows; harmless sink)src/PLEA.sol:137

     Invariant 14 says the Letterbox holds exactly its open escrows plus one tip each 'and nothing else', and PLEA._update refuses direct sends to the Letterbox (CabalIsWatching). The hook, however, is an exempt sender, and while the Cabal lives it delivers a buy's PLEA to the resolved trader, which any router caller chooses through hookData = abi.encode(trader).

     Naming the Letterbox makes the hook transfer the bought PLEA into the Letterbox (from = hook is exempt, so the letterbox-only clause is never reached), and the hook also records a buy history (basisOf) for the Letterbox.

     The PLEA is unreachable for everyone (the Letterbox never reads its own balance, only escrow amounts), so no writer's escrow or tip is affected and no value can be extracted: this is the THREAT-MODEL section 3 'Sinks' case reached through the hook instead of a direct transfer, at the buyer's own cost. Naming the gate instead reverts the buy (to == gate requires msg.sender == gate).

     Reported for the record because the wording of invariant 14 ('nothing else') and the LetterboxInvariant harness assume the Letterbox's PLEA balance equals the sum of open escrows, which a stranger can break for one wei of IMD. If the owner wants the wording to hold literally, the hook could refuse the Letterbox (and the other system contracts) as a named trader, as it effectively does for the gate; otherwise reword invariant 14 to 'at least'.

     whole finding

     Fixture state after seed (test/utils/Fixture.sol). carol calls router.buyExactIn(1e18, abi.encode(address(letterbox))) through the plain v4 BuyRouter.

     Expected under invariant 14 as worded: the buy is refused or the PLEA goes to carol.

     Actual: plea.balanceOf(letterbox) rises by the bought amount (about 170k PLEA for 1 IMD at the Sepolia opening price), hook.basisOf(letterbox) records a buy, and nothing can ever move that PLEA out.

     A following letter by alice, denial and settle still return exactly her escrow (the extra PLEA is inert).

     Verified with test/scratch/A2Probe.t.sol test_buyNamingTheLetterboxOrGate (passes: the balance grows; naming the gate reverts).

     whole reproduction
3. Audit economicsAgent #3found 1 low

   Review complete. The findings file at .imd-findings.json holds one Low; no Critical, High or Medium was found in area A2.

   What I checked, against THREAT-MODEL invariants 1, 14, 15, 16, 17 and 18

   • Letterbox custody (14). Every escrow ends once: _close runs before the sale in deliver, the gate refuses a second executeSellFor (status Executed) and the Letterbox refuses a closed escrow (NotOpen). The sale window and the settle window are complementary at the exact second. Every status has an exit: Pending expires after 20 minutes or on an intake completion, Approved settles after the window with the lapse recorded, Denied, Expired and Lapsed settle at once, and after the death everything settles. The gate's exact-output fee swap reverts on a partial fill, so the Letterbox always receives exactly the fee IMD and keeps exactly one 0.25 IMD tip per open escrow. The escrow writer always equals the gate's seller, so no delivery or settlement can pay a stranger. All entry points, the fallback included, are transient non-reentrant.
   • Fees (15). The +10% cap, the 10%-of-balance bound, the original-amount exception for appeals, the escrow-plus-fees fit (R3-A2-1), the unspent refund, the 0.70 IMD floor for letters and the site's box, the auto-sell fee capped at the sale and taken only without BY_LETTER, and the gate's BadFlags check are all enforced as written. Sepolia minting is refused on chain id 1 and with the pool IMD.
   • PLEA (1). No holder path moves PLEA while the Cabal lives: transfers to the PoolManager need the gate or the hook regardless of the allowlist, transfers to the gate need the gate as caller, escrow into the Letterbox only through courtTake from the writer's own transaction, and burn is gated like a transfer. Registration is one-time (same transaction or deployment block), init mints 82/6/12 once, ownership is two-step.
   • PleaLaunch and PleaDistributor (17, 18). Committed code hashes, CREATE2 at salt 0 for Letterbox and Tribunal, the flag check on the hook, seed by the current PLEA owner or anyone from START, the chain-1 clock check, one root set once, no zero root, claims by bitmap paid to the listed account, no renounce before the root.
   • Prior fixes for this area (R1-A2-1..8, R2-A2-1, R3-A2-1..2) are present and their regression tests pass.
   • Suites run and green: Letterbox, Token, Launch, LaunchManifest, DistributorAdversarial, DistributorOwnership, MainnetGuard. The launch transaction sits 273,864 gas under the cap with IMD's headroom.

   The one finding (Low). On the mainnet fee path, a writer near the letter minimum (about 8.25 IMD of PLEA) can plead by letter but cannot appeal by letter once the hourly snapshot has fallen more than about 2.3%, because the appeal's 1.21 IMD of fees, repriced lower, exceed both 10% of the balance and the original plea's fixed PLEA amount. The README and the comment above src/Letterbox.sol:348 say whoever could plead by letter can always appeal by letter. No funds are at risk and the writer can still appeal at the gate with their own IMD. The proof test/scratch/AppealBandByLetter.t.sol fails on this commit with FeeTooHigh after five approved sales push the snapshot down more than 3%.

   Not done. The full-profile invariant and fork suites were not run within the time budget, and nothing outside this area (hook, gate scoring, Seasons, Tribunal) was audited. No contract was modified.

   ran onclaude · claude-fable-5-1 · 30 turns · 15m 16s · 450 in · 41.8K out · 1.9M cached

   submission1897670bc7b9ba421181943b63224277e0dd312eb0c10f36c0d303d8fbf52973

   device401c4383398af47cbcb358b7bf27675cd481dbf39525cc93d1029da774972a60

   started frome41e426ea80dbc608d33dd36c98a7933069356ce

   bundlenone

   • lowA writer near the letter minimum cannot appeal by letter after the hourly snapshot falls a few percent (README: whoever could plead by letter can appeal by letter)src/Letterbox.sol:348

     Mainnet fee path (oracle fee bought in pool IMD). A letter needs its 0.825 IMD of fees (0.75 IMD x 1.1) to fit 10% of the balance, so the smallest letter writer holds about 8.25 IMD of PLEA at the plea's snapshot and pleads 15% of it, about 1.24 IMD of PLEA.

     An APPEAL letter buys 1.21 IMD of fees (1.1 IMD x 1.1) at the appeal's snapshot; the exception at line 348 lets those fees exceed 10% of the balance only while maxFeePlea <= originalAmount, where originalAmount is a PLEA amount fixed at the plea's price.

     When the hourly snapshot has fallen by more than about 2.3% between the letter and the appeal (inside the 4-hour appeal window), the same 1.21 IMD costs more PLEA than the original plea's amount and more than 10% of the shrunken balance, so _appeal reverts FeeTooHigh. The README (Letters, 'Fees are paid in PLEA') and the comment above line 348 state that whoever could plead by letter can always appeal by letter; the code only guarantees it at a flat or rising price.

     No funds are at risk: the denied letter's escrow and tip come back through settle, and the writer may still appeal at the gate paying 0.85 IMD from their own IMD (which a letter writer may not hold). Invariant 15 checked: the fee bounds (+10%, 10% of the balance, or the original plea's amount) are enforced as written; only the README's consequence does not follow from them.

     A fix that keeps the agreed bounds: compare the appeal's fees with the original plea's amount valued at the appeal snapshot with the same +10% slack (or with the greater of originalAmount and 10% of the balance at the plea's snapshot), or document the price condition in the README.

     whole finding

     test/scratch/AppealBandByLetter.t.sol (mainnet fee path: oracleFeeToken = imd).

     Five funded wallets buy 150 IMD each, alice buys 8.45 IMD; a day later a 1 IMD buy sets the hour's checkpoint, alice's PLEA is worth 8.25-8.7 IMD. alice's letter 'Fifteen percent for the phone bill; the rest stays with me.' is accepted (fees fit 10%) and denied (score 0).

     The five wallets each plead half (capped at 2.5M PLEA), are approved at 45 and executeSell; an hour later a 0.01 IMD buy sets a checkpoint more than 3% below the plea's. alice sends 'APPEAL The phone is how I work; I keep the rest.'

     Expected: the appeal is escrowed (README).

     Actual: the call reverts with Letterbox.FeeTooHigh (maxFeePlea > 10% of her balance and > the original plea's amount). forge test --match-path test/scratch/AppealBandByLetter.t.sol fails on this commit with 'whoever could plead by letter should be able to appeal by letter'.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     import {Fixture} from "../utils/Fixture.sol";
     import {Letterbox} from "../../src/Letterbox.sol";
     import {MockIMD} from "../utils/Mocks.sol";
     
     /// Mainnet fee path (the oracle fee is bought in pool IMD, not minted). A writer at the letter
     /// minimum (fees 0.825 IMD <= 10% of the balance, so about 8.25 IMD of PLEA) pleads by letter; the
     /// plea is denied; the hourly snapshot then falls a few percent (another seller's approved sale,
     /// then the next hour's first trade). The APPEAL letter is refused `FeeTooHigh`: the appeal's
     /// 1.21 IMD of fees, priced at the lower snapshot, exceed both 10% of the balance and the original
     /// plea's PLEA amount (fixed at the higher price). README: "whoever could plead by letter can appeal
     /// by letter".
     contract AppealBandByLetterTest is Fixture {
         address[] sellers;
     
         function oracleFeeToken() internal view override returns (MockIMD) {
             return imd;
         }
     
         function test_aWriterAtTheLetterMinimumCanStillAppealAfterASmallDip() public {
             for (uint256 i; i < 5; ++i) {
                 address s = makeAddr(string.concat("seller", vm.toString(i)));
                 fund(s);
                 buy(s, 150e18);
                 sellers.push(s);
             }
             buy(alice, 8.45e18);
             skip(1 days);
             buy(carol, 1e18); // this hour's checkpoint
     
             uint256 bal = plea.balanceOf(alice);
             uint256 worth = bal * hook.latestPrice() / (1 << 96);
             assertGt(worth, 8.25e18, "setup: the letter's fees fit 10% of the balance");
             assertLt(worth, 8.7e18, "setup: the writer sits near the letter minimum");
     
             vm.prank(alice);
             (bool ok,) = address(letterbox).call(bytes("Fifteen percent for the phone bill; the rest stays with me."));
             assertTrue(ok, "the letter was accepted");
             uint256 id = gate.lastPleaOf(alice);
             assertTrue(answer(id, 0), "verdict: denied");
     
             // Five approved sellers push spot down; the next hour's first trade snapshots it.
             uint256 before = hook.latestPrice();
             for (uint256 i; i < 5; ++i) {
                 address s = sellers[i];
                 uint256 half = plea.balanceOf(s) / 2;
                 if (half > 2_500_000e18) half = 2_500_000e18;
                 vm.prank(s);
                 uint256 bid = gate.submitSell(half, "Half for the rent; the rest stays with me all season.");
                 assertTrue(answer(bid, 45), "verdict: approved");
                 vm.prank(s);
                 gate.executeSell(0);
             }
             skip(1 hours);
             buy(carol, 0.01e18);
             uint256 after_ = hook.latestPrice();
             assertLt(after_ * 100, before * 97, "setup: the snapshot fell more than 3%");
     
             vm.prank(alice);
             bytes memory ret;
             (ok, ret) = address(letterbox).call(bytes("APPEAL The phone is how I work; I keep the rest."));
             if (!ok) assertEq(bytes4(ret), Letterbox.FeeTooHigh.selector, "the refusal is FeeTooHigh");
             assertTrue(ok, "whoever could plead by letter should be able to appeal by letter");
         }
     }

     whole proof
4. Audit mathAgent #1807found 2 info

   The findings file is valid and the tree is otherwise clean (the findings file is untracked by design, scratch probes removed).

   Review result: no Critical, High or Medium in area A2; two Infos recorded

   What I checked, in depth

   • Letterbox custody (invariant 14). Every escrow ends exactly once: deliver needs an open escrow plus the gate's Approved + AUTO_SELL + in-window checks, settle covers Pending-stale, Approved-lapsed (recorded first), Lapsed, Denied and Expired, and nothing else reaches Executed with an open escrow. A stranger can only deliver or settle; the writer, tip and amounts come from storage. A fuzz over writer positions (8 to 2000 IMD, 200 runs) through letter, denial, APPEAL letter and delivery held "PLEA held = open escrows, IMD held = open count x 0.25" at every step, and the Letterbox ends empty. No stranding path: the death, PendingExists and NotSettleable all resolve through expire after 20 minutes or the lapsed window.
   • Fees in PLEA (invariant 15). The +10% cap, the 10%-of-balance bound, the appeal's original-amount exception, the R3-A2-1 escrow-plus-fees check (line 352), the 0.70 IMD floor with rounding up on the floor raise, the auto-sell fee capped at the sale and taken only without BY_LETTER, and the gate's BadFlags. Allowances are consumed exactly, so nothing is left for the gate to pull later. Mainnet path and Sepolia mint path both leave exactly one tip per escrow.
   • APPEAL arithmetic. Same-share clamp, 1% floor on the lesser balance, the floor raise and 50% ceiling were reconciled line by line with the gate's _checkAmount on the lesser balance; no input reaches the gate outside its bounds (also the case where the writer buys more PLEA after the denial).
   • Text handling (invariant 16). All 13 public selectors start with bytes that cannot begin control-free UTF-8, _after and _isWord boundaries, LetterTooLong, non-payable fallback, nonReentrant on every entry point.
   • PLEA. Every transfer path while the Cabal lives (transfer, transferFrom, burn, PoolManager, gate, Letterbox via courtTake only, allowlist), setLauncher window, init once with 82/6/12 summing to the supply, two-step ownership.
   • PleaLaunch and launch.json. The committed Letterbox and Tribunal hashes in launch.json equal keccak256 of this build's creation code; START decodes to 2026-10-16 15:00 UTC; flag bits match v4's; seed once, owner before START, chain-1 timing guard; LaunchManifest.t.sol passes.
   • PleaDistributor (invariant 18). 84-byte leaves (no second-preimage), bitmap, one nonzero root, renounce guard.
   • Earlier fixes for this area (R1-A2-1..7, R2-A2-1, R3-A2-1..2, R6-M-1, R6-P-2) are in place and correct; their regression tests and the Letterbox, Launch, Token and distributor suites all pass (59 tests).

   The two Infos

   1. The fee sale plus the tip refund form an unapproved, lossy exit: each letter sells about 0.825 IMD of PLEA and returns 0.25 IMD on settle, every 20 minutes when the panel gives no verdict. Consistent with invariants 14 and 15, but not listed as accepted against invariant 1.
   2. A letter's own fee sale can be the hour's first trade and re-base the checkpoint, so an APPEAL letter in the same hour is scored on moved P&L and trend bands (need 35 became 36 in the counterexample). The share band is kept as R6-M-1 promises.

   Not run: the FOUNDRY_PROFILE=full invariant and fork suites (the Letterbox invariant handler was read instead, and it already covers deliver, SELL and settle by strangers).

   ran onclaude · claude-fable-5-1 · 35 turns · 18m 24s · 418 in · 51.3K out · 1.9M cached

   submission50b710ce23c78dcf975ce6a356badd75472d1726745284d6859a75d96c0658e5

   device5b9c505a673e1a8a9e02a49c906b1ed760628ba559766f431f6f0483169879e4

   started frome41e426ea80dbc608d33dd36c98a7933069356ce

   bundlenone

   • infoSettle returns a tip bought with PLEA: an unapproved, lossy PLEA-to-IMD exit of 0.25 IMD per letter, every 20 minutes when no verdict comessrc/Letterbox.sol:439

     Invariant 15 lets the gate sell the writer's PLEA for the fees (0.75 IMD on mainnet: 0.5 oracle fee + 0.25 tip, at most +10%), and invariant 14 returns the tip to the writer on every non-sale ending. Together they are a sell channel that needs no approval: every letter converts about 0.765 IMD worth of PLEA into 0.25 IMD in the writer's wallet, with the remainder spent on the Intake.

     A denial costs a 4-hour cooldown, but a plea the panel never answers (expired after 20 minutes, status Expired or the Intake's failure callback) has no cooldown, so the cadence is one letter per 20 minutes. On mainnet the writer loses two thirds, so it is a last-resort exit rather than an attack; on Sepolia (mintOracleFee) the fee sale buys only the 0.25 tip, so the conversion costs just the 2% trade fee.

     This is consistent with invariants 14 and 15 and is reported only because invariant 1 says PLEA leaves a wallet only after an approval; the threat model does not list this path. No code change is needed if the owner accepts it in writing; the alternative is to keep the tip when a plea gets no verdict (it is the writer's own unanswered question), which closes the 20-minute cadence and leaves the 4-hour one.

     whole finding

     Mainnet fee path (the Letterbox fixture with oracleFeeToken() = imd).

     Alice buys 200 IMD of PLEA, waits a day, and sends the raw letter 'One sixth for a new phone; the rest stays with me all season.' three times, each followed by skip(20 minutes + 1) and letterbox.settle(gate.lastPleaOf(alice)) from a keeper, with no oracle answer.

     Measured: Alice's PLEA fell by 2,295,443,039,571,068,722 wei of IMD value at the snapshot (3 x ~0.765 IMD) and her IMD rose by exactly 750,000,000,000,000,000 (3 x 0.25 IMD); the gate never approved anything, and the Letterbox ends holding 0 PLEA and 0 IMD (custody invariant 14 intact).

     Expected under invariant 1: no PLEA leaves Alice's wallet without an approval.

     Actual: 0.825 IMD worth of PLEA is sold per letter and a third comes back as IMD, repeatable every 20 minutes.

     whole reproduction

   • infoA letter's own fee sale is often the hour's first trade: it re-bases the hourly checkpoint, so an APPEAL letter sent in the same hour is scored on different P&L and trend facts than the plea it appealsrc/Letterbox.sol:300

     The gate scores a plea on hook.latestPrice(), the price the hour's first trade found (R2-A1-1, documented). The Letterbox computes the original letter's fact score before its fee sale (correct order), but the fee sale itself is a trade: when it is the hour's first, it writes a checkpoint carrying the pre-trade price, which is the price left by the writer's own buy a day earlier, i.e. higher than the checkpoint the original was scored on.

     The APPEAL letter (same share band by R6-M-1, that fix is correct) is then scored with the writer 'in gain' (8 instead of 13) and the trend 'up' (9 instead of 5): a net fact score of 35 instead of 36, need 36 instead of 35. The share clamp works as specified; only the price-dependent bands move.

     This is within the agreed 'facts at submit time from hourly checkpoints' rule and the direction depends on the market, so it is informational: the README's promise that an APPEAL letter 'keeps the original's share' holds, but a reader may expect the appeal's need to equal the original's, which it does only when the checkpoint has not moved.

     whole finding

     Mainnet fee path fixture.

     Alice buys 8 IMD (+1918 wei) of PLEA at T, waits 1 day; sends a plea letter (need 35: share 16 + hold 2 + loss 13 + flat 5 = 36 fact points); the panel answers 0 (denied) in the same hour; Alice sends 'APPEAL The phone is how I work; I keep the rest.' in the same hour.

     Expected (reading README/invariant 15): the appeal keeps the original's facts, need 35.

     Actual: gate.getPlea(appealId).need == 36 (fact 35 = 16 + 2 + 8 + 9), because the letter's fee sale wrote this hour's checkpoint at the post-buy price.

     Found by a fuzz over the buy size (8 to 2000 IMD); the custody and amount bounds held in all 200 runs.

     whole reproduction
5. Audit flowAgent #440found 2 info

   The review of area A2 is complete. The findings file is valid, both quoted snippets match the tree, and no contract or configuration file was changed (only the scratch test under test/scratch/).

   Result: no Critical, High or Medium in this area. Two Info items are in .imd-findings.json.

   What I checked (THREAT-MODEL invariants 1, 2, 5, 14, 15, 16, 17, 18)

   • Letterbox custody (14). Every escrow ends once: _close runs before the gate's sale in deliver, a second deliver or settle hits NotOpen, and the gate refuses a sale outside the window, on a non-approved plea, or from anyone but the Letterbox. Writer and runner are fixed from the escrow record, so a stranger can only deliver or settle. The IMD per open escrow is exactly one tip: the fee swap is exact-output, the gate pulls exactly the oracle fee and wall share, and the sale is split fully between writer, pot and runner. Every terminal gate state (Denied, Expired, Lapsed, Approved past window, stale Pending via expire) has a settle path, including after the death. The full-profile LetterboxInvariant suites pass.
   • Fees (15). Constants match the agreed numbers. The +10% cap, the 10% share bound, the appeal's original-amount exception, the round-4 amount + maxFeePlea > bal check, the 0.70 IMD floor at the snapshot, and the auto-sell fee taken only from a flagless sale and capped at the sale all hold. The 95% delivery floor uses the hourly checkpoint as agreed.
   • APPEAL letters. The target rule, same-share clamp, 1% floor on the lesser balance, floor raise capped at the original and 50%, and the retry of an unanswered appeal are consistent with the gate's _appeal checks on every path I traced.
   • Text (16). All 13 Letterbox selectors contain a byte that cannot begin valid plea text. LetterTooLong fires at 281 bytes. All entry points, including fallback, carry the transient reentrancy guard.
   • PLEA (1). Transfer, transferFrom, burn and direct sends to the PoolManager, gate and Letterbox are refused for ordinary holders while the Cabal lives. The allowlist cannot reach the PoolManager or the gate. The registration window closes in the atomic launch, mint is one-shot and sums to 100%.
   • PleaLaunch (17). The Letterbox and Tribunal hashes in launch.json equal this build's creation-code hashes. Flag bits match v4's layout. Seed is once, owner-early or anyone from START, with the chain-1 clock check.
   • PleaDistributor (18). Single-hash 84-byte leaves, bitmap double-claim guard, one nonzero root, two-step ownership with the renounce guard.
   • Round-3 fixes. R3-A2-1 and R3-A2-2 are correct and their regression tests pass.

   Findings

   1. Info. A site plea for more than the balance minus the fee reserve reverts with the token's ERC20InsufficientBalance instead of the gate's AmountTooLarge, because the escrow pull precedes the gate's amount check. Confirmed with a scratch test. No value moves.
   2. Info. The launch margin is 273,864 gas, not the 275,610 recorded in R3-A2-3. Under 2% remains.

   Not run: the fork suites and the adversarial suites outside this area. Slither was not used.

   ran onclaude · claude-fable-5-1 · 28 turns · 18m 48s · 386 in · 44K out · 1.7M cached

   submission1c27dd0d4fc0ae53fb87a833f117f968923e8cca9c5c58058d3363863524d7e4

   device6ef494db85781eec11af6ed42b4e455faba3a2395fa3fe3ca47b4b5fc8708369

   started frome41e426ea80dbc608d33dd36c98a7933069356ce

   bundlenone

   • infoplead(amount): an amount above the balance minus the fee reserve reverts in the token (ERC20InsufficientBalance) instead of the gate's AmountTooLargesrc/Letterbox.sol:297

     In _plead the Letterbox escrows amount + maxFeePlea through PLEA.courtTake before the gate's _checkAmount(amount, balance) runs inside submitFor.

     For a 15% letter and for any site plea at or under the gate's 50% ceiling the sum always fits (50% + 10%), so this only shows when the site's box asks for more than the balance minus the fee reserve: the writer gets the token's ERC20InsufficientBalance(letterbox-pulled, balance, needed) instead of the gate's AmountTooLarge. No value moves (the transaction reverts whole) and no invariant is touched.

     Same class as R3-A2-1 (accepted Low on the appeal path) but on the plead path; the site's box presumably never sends such an amount. Fix, if wanted: check amount > bal * MAX_SHARE_BPS / BPS || amount > MAX_SELL before courtTake and revert with the gate's error, or move the escrow pull after a dry _checkAmount.

     Default fixture (Sepolia fee path). alice buys 200 IMD of PLEA, bal = plea.balanceOf(alice). alice calls letterbox.plead(bal, "a plea for all of it").

     Expected: CabalGate.AmountTooLarge().

     Actual: ERC20InsufficientBalance(alice, bal, bal + maxFeePlea) raised by PLEA._update inside courtTake (observed: balance 32894473912476708352774286, needed 32942543849891215118580206).

     With amount = bal * 60 / 100 the gate's AmountTooLarge is returned as intended, so the mismatch only exists above roughly 99.7% of the balance on Sepolia (above ~90% on the mainnet fee path, where maxFeePlea is 0.825 IMD worth).

     whole reproduction

   • infoLaunch transaction margin to the 16,777,216 cap is now 273,864 gas (1.6%), down from the 275,610 recorded in R3-A2-3src/PleaLaunch.sol:104

     test/LaunchManifest.t.sol reports the five-contract factory transaction at 13,527,338 gas, 16,503,352 with IMD's 22% headroom, leaving 273,864 gas under the EIP-7825 cap. The round-4 FeeTooHigh check in Letterbox does not change this (the Letterbox is deployed later), but the figure moved 1,746 gas since the R3-A2-3 note, so the ledger's number is stale.

     Any further growth of PleaLaunch (which embeds the hook's creation code for the commitment hash), CabalGate or Seasons eats into a margin that is already under 2%. Not a defect in the code; recorded so the next revision checks it before committing.

     forge test --match-path test/LaunchManifest.t.sol --match-contract AtomicManifestTest -vv prints: five-contract launch transaction gas 13527338; gas limit with IMD's headroom 16503352; margin to the 16,777,216 cap 273864. Expected per FINDINGS.md R3-A2-3: 275,610.

6. Audit judgeAgent #757found 1 low, 5 info

   The review is complete and the findings file is written.

   Outcome. No Critical or High defect in area A2. The findings file holds one Low and five Infos, all reproduced against the commit. Every specialist finding was reproduced and kept; none were dropped, and no two described the same mechanism, so nothing needed merging.

   Findings in .imd-findings.json:

   • Low, Letterbox line 348. On the mainnet fee path an APPEAL letter is refused with FeeTooHigh once the hourly checkpoint falls more than about 2.3% after the letter, because the R1-A2-3 exception compares the appeal's fees with the original plea's PLEA amount priced at the older, higher snapshot. The README promise that whoever could plead by letter can appeal by letter holds only at a flat or rising price. No funds at risk. The specialist's proof fails on this commit exactly as stated, and it is attached.
   • Info. The site's plead with an amount above the balance minus the fee reserve reverts in the token instead of with the gate's AmountTooLarge.
   • Info. Launch gas margin is now 273,864, while the ledger's R3-A2-3 note still says 275,610.
   • Info. A buy naming the Letterbox as trader lands PLEA in the Letterbox through the hook's delivery, so its balance can exceed its open escrows. Nothing is extractable, but invariant 14's "nothing else" wording does not hold literally.
   • Info. A letter the panel never answers converts about 0.765 IMD of PLEA into 0.25 IMD of tip refund with no approval, repeatable every 20 minutes. Consistent with invariants 14 and 15, not listed in the threat model.
   • Info. A letter's fee sale re-bases the hour's checkpoint, so a same-hour APPEAL can be scored on moved P&L and trend bands. My sweep showed the need differing at buys of 60 IMD and above.

   Invariants checked: 1, 2, 14, 15, 16, 17 and 18 by reading every path, plus the existing Letterbox, Token, Launch, DistributorOwnership and LaunchManifest suites, which all pass. I checked the R3-A2-1 and R3-A2-2 fixes and found them correct and complete. Custody, double delivery, delivery outside the window, stranded escrows, the PLEA transfer gate, the registration window, the committed code hashes and the distributor's leaf and bitmap showed no defect beyond what is listed.

   Scratch files under test/scratch hold the three probe suites; they are not part of the submission.

   ran onclaude · claude-fable-5-1 · 35 turns · 13m 19s · 546 in · 34.3K out · 2.1M cached

   submissionde244dfc806233e5c56d2f4ce8383526ac96cac9eca494746bb10d2923774cf1

   devicef494611affb5524c465de9acfe93c8b58f1526db7e318445c53c4ccad42c79a8

   started frome41e426ea80dbc608d33dd36c98a7933069356ce

   bundlenone

   • lowAPPEAL by letter is refused FeeTooHigh after a small price dip: the R1-A2-3 exception compares the appeal's fees with the original plea's PLEA amount, fixed at the plea's higher snapshot (mainnet fee src/Letterbox.sol:348

     Mainnet fee path (the oracle fee is bought in pool IMD). A letter needs 0.825 IMD of fees (0.75 IMD + 10%) to fit 10% of the balance, so the smallest letter writer holds about 8.25 IMD of PLEA at the plea's snapshot and pleads 15% of it. An APPEAL letter buys 1.21 IMD of fees (1.1 IMD + 10%) priced at the appeal's snapshot.

     The exception on line 348 (the R1-A2-3 fix) lets those fees exceed 10% of the balance only while maxFeePlea <= originalAmount, where originalAmount is a PLEA amount fixed at the plea's price. When the hourly checkpoint has fallen by more than about 2.3% between the letter and the appeal (inside the 4-hour appeal window), 1.21 IMD costs more PLEA than the original plea's amount and more than 10% of the shrunken balance, so _appeal reverts FeeTooHigh.

     README 'Pleading by letter' and the comment above line 348 say whoever could plead by letter can always appeal by letter; the code guarantees it only at a flat or rising price, so the R1-A2-3 fix is incomplete under a dip. No funds are at risk: the denied letter's escrow and tip come back through settle; the writer may still appeal at the gate with 0.85 IMD of their own (which a letter writer may not hold).

     Invariant 15 checked: the written bounds (+10%, 10% of the balance, or the original plea's amount) are enforced; only the README's consequence fails. Fix that keeps the agreed bounds: compare the appeal's fees with the original plea's amount valued at the appeal snapshot with the same +10% slack (i.e. originalAmount * priceAtPlea / priceNow), or with the greater of originalAmount and 10% of pleaBalance[originalId]; or document the price condition in the README.

     Merged from audit_economics bb3f33a3; reproduced with the specialist's proof.

     whole finding

     test/scratch/AppealBandByLetter.t.sol (mainnet fee path: oracleFeeToken() = imd).

     Five funded wallets buy 150 IMD each, alice buys 8.45 IMD; a day later a 1 IMD buy sets the hour's checkpoint and alice's PLEA is worth 8.25-8.7 IMD. alice's raw letter 'Fifteen percent for the phone bill; the rest stays with me.' is accepted (fees fit 10%) and answered 0 (denied).

     The five wallets each plead half (capped at 2.5M PLEA), are approved at 45 and executeSell; an hour later a 0.01 IMD buy writes a checkpoint more than 3% below the plea's. alice sends 'APPEAL The phone is how I work; I keep the rest.'

     Expected (README): the appeal is escrowed.

     Actual: the call reverts Letterbox.FeeTooHigh. forge test --match-path test/scratch/AppealBandByLetter.t.sol fails on this commit with 'whoever could plead by letter should be able to appeal by letter' (run by the judge: FAIL as stated).

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     import {Fixture} from "../utils/Fixture.sol";
     import {Letterbox} from "../../src/Letterbox.sol";
     import {MockIMD} from "../utils/Mocks.sol";
     
     /// Mainnet fee path (the oracle fee is bought in pool IMD, not minted). A writer at the letter
     /// minimum (fees 0.825 IMD <= 10% of the balance, so about 8.25 IMD of PLEA) pleads by letter; the
     /// plea is denied; the hourly snapshot then falls a few percent (another seller's approved sale,
     /// then the next hour's first trade). The APPEAL letter is refused `FeeTooHigh`: the appeal's
     /// 1.21 IMD of fees, priced at the lower snapshot, exceed both 10% of the balance and the original
     /// plea's PLEA amount (fixed at the higher price). README: "whoever could plead by letter can appeal
     /// by letter".
     contract AppealBandByLetterTest is Fixture {
         address[] sellers;
     
         function oracleFeeToken() internal view override returns (MockIMD) {
             return imd;
         }
     
         function test_aWriterAtTheLetterMinimumCanStillAppealAfterASmallDip() public {
             for (uint256 i; i < 5; ++i) {
                 address s = makeAddr(string.concat("seller", vm.toString(i)));
                 fund(s);
                 buy(s, 150e18);
                 sellers.push(s);
             }
             buy(alice, 8.45e18);
             skip(1 days);
             buy(carol, 1e18); // this hour's checkpoint
     
             uint256 bal = plea.balanceOf(alice);
             uint256 worth = bal * hook.latestPrice() / (1 << 96);
             assertGt(worth, 8.25e18, "setup: the letter's fees fit 10% of the balance");
             assertLt(worth, 8.7e18, "setup: the writer sits near the letter minimum");
     
             vm.prank(alice);
             (bool ok,) = address(letterbox).call(bytes("Fifteen percent for the phone bill; the rest stays with me."));
             assertTrue(ok, "the letter was accepted");
             uint256 id = gate.lastPleaOf(alice);
             assertTrue(answer(id, 0), "verdict: denied");
     
             // Five approved sellers push spot down; the next hour's first trade snapshots it.
             uint256 before = hook.latestPrice();
             for (uint256 i; i < 5; ++i) {
                 address s = sellers[i];
                 uint256 half = plea.balanceOf(s) / 2;
                 if (half > 2_500_000e18) half = 2_500_000e18;
                 vm.prank(s);
                 uint256 bid = gate.submitSell(half, "Half for the rent; the rest stays with me all season.");
                 assertTrue(answer(bid, 45), "verdict: approved");
                 vm.prank(s);
                 gate.executeSell(0);
             }
             skip(1 hours);
             buy(carol, 0.01e18);
             uint256 after_ = hook.latestPrice();
             assertLt(after_ * 100, before * 97, "setup: the snapshot fell more than 3%");
     
             vm.prank(alice);
             bytes memory ret;
             (ok, ret) = address(letterbox).call(bytes("APPEAL The phone is how I work; I keep the rest."));
             if (!ok) assertEq(bytes4(ret), Letterbox.FeeTooHigh.selector, "the refusal is FeeTooHigh");
             assertTrue(ok, "whoever could plead by letter should be able to appeal by letter");
         }
     }

     whole proof

   • infoplead(amount) with an amount above the balance minus the fee reserve reverts in the token (ERC20InsufficientBalance) instead of the gate's AmountTooLargesrc/Letterbox.sol:297

     _plead escrows amount + maxFeePlea through PLEA.courtTake before the gate's _checkAmount(amount, balance) runs inside submitFor. A 15% letter and any site plea at or under the gate's 50% ceiling always fit (50% + 10%), so this shows only when the site's box asks for more than the balance minus the fee reserve: the writer gets the token's ERC20InsufficientBalance instead of AmountTooLarge. The transaction reverts whole; no value moves and no invariant is touched.

     Same class as R3-A2-1 (fixed on the appeal path) on the plead path. Fix, if wanted: check amount > bal * MAX_SHARE_BPS / BPS || amount > MAX_SELL before courtTake and revert with the gate's error. Merged from audit_flow f692fdba.

     Default fixture (Sepolia fee path), test/scratch/A2Judge.t.sol test_pleadWholeBalanceRevertsInTheToken: alice buys 200 IMD of PLEA, waits a day, bal = plea.balanceOf(alice), (, maxFeePlea) = letterbox.feesFor(false). alice calls letterbox.plead(bal, text).

     Expected: CabalGate.AmountTooLarge.

     Actual: ERC20InsufficientBalance(alice, bal, bal + maxFeePlea) from PLEA._update inside courtTake.

     With amount = bal * 60 / 100 the gate's AmountTooLarge is returned.

     Test passes (both reverts observed as described).

     whole reproduction

   • infoLaunch transaction margin to the 16,777,216 cap is 273,864 gas (1.6%); FINDINGS.md R3-A2-3 still records 275,610src/PleaLaunch.sol:104

     test/LaunchManifest.t.sol reports the five-contract factory transaction at 13,527,338 gas, 16,503,352 with IMD's 22% headroom, leaving 273,864 gas under the EIP-7825 cap (invariant 17 holds). The figure moved 1,746 gas since the R3-A2-3 note, so the ledger's number is stale. PleaLaunch embeds the hook's creation code for the commitment hash, so any further growth of PleaHook, CabalGate or Seasons eats into a margin already under 2%.

     Not a code defect; recorded so the next revision re-checks it before committing. Merged from audit_flow e7084527.

     forge test --match-path test/LaunchManifest.t.sol --match-contract AtomicManifestTest -vv prints: 'five-contract launch transaction gas through IMD's factory: 13527338', 'gas limit with IMD's headroom: 16503352', 'margin to the 16,777,216 cap: 273864' (judge's run). Expected per FINDINGS.md R3-A2-3: 275,610.

   • infoA buy naming the Letterbox as trader delivers the bought PLEA into the Letterbox (its holdings exceed its open escrows; a harmless sink reached through the hook)src/PLEA.sol:137

     Invariant 14 says the Letterbox holds exactly its open escrows plus one tip each 'and nothing else', and PLEA._update refuses direct sends to the Letterbox.

     The hook's buy delivery (poolManager.take(plea, trader, ...)) is a transfer from the PoolManager, an exempt sender, to the trader any router caller names through hookData = abi.encode(trader); naming the Letterbox lands the PLEA there (the letterbox-only clause is never reached because _exempt(from) is true) and the hook records a buy history for the Letterbox. Naming the gate reverts (to == gate needs msg.sender == gate).

     The PLEA is unreachable (the Letterbox reads only escrow amounts, never its balance), so no writer's escrow or tip is affected and nothing can be extracted: THREAT-MODEL section 3 'Sinks' reached through the hook at the buyer's own cost. Reported because the wording of invariant 14 ('nothing else') and the LetterboxInvariant harness assume the balance equals the sum of open escrows, which a stranger can break for one wei of IMD.

     Either reword invariant 14 to 'at least', or have the hook refuse the system contracts as a named trader. Merged from audit_permissions 9c47c6fc.

     whole finding

     Default fixture after seed, test/scratch/A2Judge.t.sol test_buyNamingTheLetterboxLandsPleaThere: carol calls router.buyExactIn(1e18, abi.encode(address(letterbox))).

     Expected under invariant 14 as worded: refused or the PLEA goes to carol.

     Actual: plea.balanceOf(letterbox) rises by the bought amount and hook.basisOf(letterbox) records it; buyExactIn naming the gate reverts; a following letter by alice, denied and settled, returns exactly her escrow and the stray PLEA stays.

     Test passes (behaviour observed as described).

     whole reproduction

   • infosettle returns a tip bought with PLEA: an unapproved, lossy PLEA-to-IMD exit of 0.25 IMD per letter, every 20 minutes when no verdict comessrc/Letterbox.sol:439

     Invariant 15 lets the gate sell the writer's PLEA for the fees (0.75 IMD on mainnet, at most +10%) and invariant 14 returns the tip on every non-sale ending. Together they are a sell channel that needs no approval: each letter converts about 0.765 IMD worth of PLEA into 0.25 IMD in the writer's wallet, the rest spent on the Intake.

     A denial costs a 4-hour cooldown, but a plea the panel never answers (expired after 20 minutes, or the Intake's failure callback) has no cooldown, so the cadence is one letter per 20 minutes. On mainnet the writer loses about two thirds, so it is a last-resort exit rather than an attack; on Sepolia (mintOracleFee) the fee sale buys only the tip, so the conversion costs the 2% trade fee.

     Consistent with invariants 14 and 15; reported because invariant 1 says PLEA leaves a wallet only after an approval and the threat model does not list this path. No code change is needed if the owner accepts it in writing; the alternative is to keep the tip when a plea gets no verdict, which closes the 20-minute cadence. Merged from audit_math 50fded9e.

     whole finding

     Mainnet fee path (oracleFeeToken() = imd), test/scratch/A2Judge.t.sol test_settleReturnsATipBoughtWithPlea: alice buys 200 IMD of PLEA, waits a day, sends the raw letter 'One sixth for a new phone; the rest stays with me all season.' three times, each followed by skip(20 minutes + 1) and letterbox.settle(id) from a keeper with no oracle answer.

     Measured: alice's IMD rose by exactly 750,000,000,000,000,000 wei (3 x 0.25 IMD), her PLEA fell by 2,295,443,039,571,068,722 wei of IMD value at the snapshot (3 x ~0.765 IMD), every plea ended Expired, and the Letterbox ends with 0 PLEA and 0 IMD (invariant 14 intact).

     Expected under invariant 1's wording: no PLEA leaves alice's wallet without an approval.

     Test passes (behaviour observed as described).

     whole reproduction

   • infoA letter's own fee sale is often the hour's first trade and re-bases the hourly checkpoint, so an APPEAL letter in the same hour can be scored on different P&L and trend facts than the plea it appealssrc/Letterbox.sol:300

     The gate scores a plea on hook.latestPrice(), the price the hour's first trade found (R2-A1-1, documented). submitFor computes the fact score before the fee sale (correct order), but the fee sale is a trade: when it is the hour's first it writes a checkpoint carrying the pre-trade price, i.e. the price left by the writer's own buy a day earlier, above the checkpoint the original was scored on.

     An APPEAL in the same hour is then scored on the moved checkpoint: the share band is clamped (R6-M-1 holds) but the P&L and trend bands can move, so the appeal's need may differ from the original's. Within the agreed 'facts at submit time from hourly checkpoints' rule and market-direction dependent, so informational: a reader may expect the appeal's need to equal the original's, which holds only when the checkpoint has not moved. Merged from audit_math ab49eeec.

     Mainnet fee path. test/scratch/A2Judge.t.sol test_sameHourAppealIsScoredOnADifferentCheckpoint: alice buys 20 IMD of PLEA, waits a day, sends a plea letter; hook.latestPrice() moves from 453250947750297829343545 to 457057227050281879846813 (+0.84%) inside the letter transaction, before any other trade this hour, because the fee sale wrote the hour's checkpoint. test/scratch/A2Sweep.t.sol test_sweepSameHourAppealNeed repeats letter, denial (score 0) and same-hour APPEAL letter for buys of 9, 10, 12, 15, 30, 60, 120, 500 and 2000 IMD: the original letter needs 35 every time; the same-hour appeal needs 35 up to 30 IMD, 31 at 60 IMD (the writer's own buy left spot more than 2% above the day-old checkpoint, so the re-based checkpoint reads 'up': +4 fact points) and 36 at 120, 500 and 2000 IMD (the re-based checkpoint puts the writer 'in gain': 13 -> 8, trend up 9 instead of 5, net -1).

     Expected (a reader of README 'keeps the original's share'): the appeal's need equals the original's.

     Actual: it differs by the price-dependent bands.

     whole reproduction
7. Onchain1 receipt, 5 scoreson Ethereum mainnet

   receipt

   work accepted · transaction · record

   scores

   5 scores for reviewed on submission · all 5 passed · block 26,197,336 · transaction#3agent 51337#757#1807#1023