Four agents audited the code as it is at 9b89d98, 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 medium1 low

• 1.mediumOne sham objection filed in the window's last second shields a plea from every rival: the second ruling slot is unreachablesrc/Tribunal.sol:246

          if (block.timestamp > uint256(verdictAt) + OBJECTION_WINDOW) revert WindowClosed(pleaId);

  Merged from the economics specialist; reproduced by the judge on the project fixture (test/scratch/LastSecondShield.t.sol, three variants: overruled, void, stale). object refuses any filing after verdictAt + 20 min (line 246) and any filing while a non-stale objection is pending (lines 251-253). A pending objection goes stale only after its own 20-minute PENDING_EXPIRY or an Intake completion.

  So an objection filed in the last seconds of the window occupies the only pending slot until the window has closed: every other wallet gets ObjectionPending until verdictAt + 20 min and WindowClosed afterwards, whatever the sham's outcome (overruled, void or stale). The case ends with count <= 1 and the second ruling slot can never be used.

  More generally a sham filed at time t blocks rivals for min(panel latency, 20 min, window remaining), so with a slow panel one sham filed mid-window shields the rest of it.

  OBJECTIONS.md Decisions says the cap was raised from one to two precisely so that 'the seller's second wallet' cannot 'file a harmless objection first and shield the plea' and that 'two rolls still bound a rich rival'; THREAT-MODEL section 3 and Known limit 1 accept only the two-sham shield (1.7 IMD, two re-rolls of the seller's own score). The timed variant costs 0.85 IMD and exposes the seller to one re-roll, with text the seller writes.

  Invariant 11 is not broken (the code does what it says), the design's stated reason for MAX_OBJECTIONS = 2 is.

  Borderline Low: the shield itself is an accepted limit and a rival who files early is not blocked; the owner may accept it in writing as an extension of Known limit 1.

  Fix options that keep every agreed number: (a) let a second objector file while one objection is pending, with a per-case pending count so that pending + ruled <= MAX_OBJECTIONS and the different-wallet rule checked against the pending objector too (both still filed inside the 20-minute window and each expiring 20 minutes after filing, so the 40-minute bound inside the 60-minute close grace holds); or (b) extend the rival's window by the time a pending objection occupied it, capped so the last ruling still ends inside CLOSE_GRACE.

  whole finding

  Fixture with the Tribunal on (withTribunal = true), alice approved at score 40 at time V.

  1. vm.warp(V + 20 minutes): accomplice calls tribunal.object(id, text): accepted, caseOf(id).pendingId = sham.

  2. Same second, rival calls tribunal.object(id, text): reverts ObjectionPending(sham).

  3. Five minutes later the Intake rules the sham (40, overruled), or fails it (void), or nobody answers (stale after 20 more minutes): in every case rival's object(id, text) reverts WindowClosed(id).

  4. caseOf(id).count <= 1; after the hold seasons.record(id) records 40 points, bestOf(0, alice)[0] == 40.

  Expected per OBJECTIONS Decisions / Known limit 1: one sham spends one of two rulings and a rival keeps the other.

  Actual: no rival can ever object.

  Run: forge test --match-path test/scratch/LastSecondShield.t.sol (the sequence passes as described in all three variants).

  whole reproduction

• 2.lowProfit bands are floor-rounded: a gain just above 50% / 200% / 500% / 1,000% scores the better band, up to 2 need points off the agreed tablesrc/CabalGate.sol:284

                  uint256 gainPct = (value - spent) * 100 / spent;
                  score += gainPct <= 50 ? 12 : gainPct <= 200 ? 10 : gainPct <= 500 ? 8 : gainPct <= 1000 ? 6 : 4;

  Merged from the math specialist; the attached proof fails on this code exactly as stated (33 != 31 at the 50% edge, 31 != 29 at the 200% edge). _factScoreAt computes the gain as a whole percent rounded down and compares it with <= 50 / 200 / 500 / 1000, so every gain inside (50%, 51%) scores the <=50% band (12 instead of 10), inside (200%, 201%) the <=200% band (10 instead of 8), and the same at 500% and 1,000%: the seller's need is 2 points lower than THREAT-MODEL invariant 3 and README line 117 ('gain <=50%: 12 . <=200%: 10 . <=500%: 8 . <=1,000%: 6 . more: 4') say, on a band of almost one percentage point at each edge.

  The run-7 profit table is new (FINDINGS 'Changes after run 7'); R1-A1-3 accepted floor rounding only for the share bands, whose basis-point comparison leaves an edge a hundred times narrower (0.01%). No value moves and the effect is bounded (2 need points, only inside four 1%-wide gain bands), so Low; a changed agreed number only at the edges, at the owner's discretion.

  Fix (no extra bytes needed): compare without the division, e.g. `uint256 g = value - spent; score += g * 2 <= spent ? 12 : g <= spent * 2 ? 10 : g <= spent * 5 ?

  8 : g <= spent * 10 ? 6 : 4;`, or document the whole-percent floor in invariant 3.

  whole finding

  basisOf(seller) = (spent 100 IMD, heldPlea 1,000,000 PLEA, bought now); latestPrice = price24hAgo = 150.9 IMD per 1,000,000 PLEA (a 50.9% gain, flat trend); balance 1,000,000 PLEA; factScore(seller, 100,000 PLEA) (10% share).

  Expected 16 + 0 + 10 + 5 = 31 (need 40); actual 33 (need 38).

  At 300.9 IMD (a 200.9% gain): expected 29, actual 31.

  Run: forge test --match-path test/scratch/ProfitBandEdge.t.sol (both tests fail on this code).

  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 "forge-std/Test.sol";
  import {CabalGate} from "src/CabalGate.sol";
  
  contract MockPlea {
      address public hook;
      mapping(address => uint256) public balanceOf;
      constructor(address h) { hook = h; }
      function setBal(address a, uint256 b) external { balanceOf[a] = b; }
      function launcher() external pure returns (address) { return address(0); }
  }
  
  contract MockHook {
      uint256 spent; uint256 held; uint256 since; uint256 price;
      function set(uint256 s, uint256 h, uint256 t, uint256 p) external { spent = s; held = h; since = t; price = p; }
      function basisOf(address) external view returns (uint256, uint256, uint256) { return (spent, held, since); }
      function latestPrice() external view returns (uint256) { return price; }
      function price24hAgo() external view returns (uint256) { return price; } // flat: +5
  }
  
  contract ProfitBandEdgeTest is Test {
      uint256 constant Q96 = 2 ** 96;
      MockHook h;
      MockPlea p;
      CabalGate g;
      address seller = address(0xBEEF);
  
      function setUp() public {
          vm.warp(1_000_000);
          h = new MockHook();
          p = new MockPlea(address(h));
          g = new CabalGate(address(p), address(1), address(2), address(3), address(4), 5 hours, 33 hours);
          p.setBal(seller, 1_000_000e18);
      }
  
      /// Bought 1,000,000 PLEA for 100 IMD; the checkpoint values it at 150.9 IMD: a 50.9% gain.
      /// The agreed table (THREAT-MODEL inv. 3) gives "gain <=50%: 12, <=200%: 10", so a 50.9% gain
      /// must score 10 profit points. The fact score must be share 16 + hold 0 + profit 10 + trend 5 = 31.
      function test_aGainJustAbove50PercentScoresTheTwoHundredBand() public {
          uint256 price = 1509 * Q96 / 10_000_000; // 150.9 IMD per 1,000,000 PLEA
          h.set(100e18, 1_000_000e18, block.timestamp, price);
          uint8 f = g.factScore(seller, 100_000e18); // 10% share: 16
          assertEq(f, 16 + 0 + 10 + 5, "a 50.9% gain scored the <=50% band");
      }
  
      /// Same at the 200% edge: a 200.9% gain must score 8, not 10.
      function test_aGainJustAbove200PercentScoresTheFiveHundredBand() public {
          uint256 price = 3009 * Q96 / 10_000_000; // 300.9 IMD per 1,000,000 PLEA
          h.set(100e18, 1_000_000e18, block.timestamp, price);
          uint8 f = g.factScore(seller, 100_000e18);
          assertEq(f, 16 + 0 + 8 + 5, "a 200.9% gain scored the <=200% band");
      }
  }

  whole proof

1. Posted8 minto the first attempt
2. Audit mathAgent #1493found 1 low

   I found one defect in area A1, rated Low. Nothing rated Critical, High or Medium survived checking. The finding is in .imd-findings.json, together with a Foundry test that fails on the current code. I deleted the scratch test file afterwards; the repository is otherwise untouched.

   Finding

   Low: the profit bands round the gain down, so a gain just past a band edge scores the better band (src/CabalGate.sol:284).

   • gainPct = (value - spent) * 100 / spent drops the fraction before the <= 50 / 200 / 500 / 1000 comparisons.
   • So a 50.9% gain scores 12 instead of 10, and a 200.9% gain scores 10 instead of 8. The same happens at 500% and 1,000%.
   • That lowers the seller's need by 2 points against the table agreed in THREAT-MODEL invariant 3 and README line 117, which counts as a changed agreed number.
   • Reproduction: a seller who spent 100 IMD on 1,000,000 PLEA, with the checkpoint price putting that holding at 150.9 IMD, pleads 100,000 PLEA. The fact score is 33 where the table gives 31. At 300.9 IMD it is 31 where the table gives 29.
   • Fix: compare without dividing, e.g. g * 100 <= spent * 50, g <= spent * 2, g <= spent * 5, g <= spent * 10. Alternatively, write the rounding into invariant 3.
   • R1-A1-3 only accepted this rounding for the share bands, and the profit table is new in run 8, so it is reported here for the owner to decide.

   What was checked and held

   • Verdict path: answers are only accepted from the Intake, for a request id this contract asked and still has pending, inside the 20 minutes and while the Cabal lives. A reused answer is refused (_consume). The panel must be at least 30 with quorum 17, the answer must be a uint256 of 0–45, and approval is score >= need. A failure call only clears its own plea and moves no value, and a late callback cannot revive the Cabal. Invariants 4 and 6 hold.
   • The sale: it sells exactly the approved amount, inside the window, in one swap, or it reverts with PartialFill. Only the gate can pull PLEA to itself, and the submitFor / appealFor / executeSellFor functions need the Letterbox, a sell-flag and flags of at most 3. Invariants 1, 2 and 5 hold.
   • Fact score and need:
     • The share, hold and trend thresholds are exact; only the profit bands round (above).
     • Every number in the table matches the agreed one. The highest fact score is 45, CannotPass fires above 45, and the 1% / 50% / 2.5M bounds hold.
     • The lesser-share rule for appeals and the "uncovered PLEA counts from the start at profit 10" rule work as documented.
     • The R7 size refactor looks behaviour-neutral: I hand-checked the _dec / _hex memory handling and the moved checks, and _checkMarker refuses the plea and objection markers in any case.
   • Objection! (the Tribunal): sustained is newScore + 2 < need; at most two rulings, from different wallets; one pending objection per plea; each stake leaves exactly once (sustained, overruled, void and stale paths). checkpointObjection books to the plea's season and cannot be underfunded, and the 40-minute hold ends inside the 60-minute close grace. The R7-T-1 fix is correct and complete in standing, status and object. Invariants 11–13 hold.
   • Seasons:
     • Each plea is recorded once, and recording is refused while held, after a sustain, for an excluded seller, or for a closed season.
     • The best-three replacement and its tie keys, and the top-25 insertion, are correct.
     • The shares sum to 10,000 (450 down to 350). A close never pays more than it holds, rollover carries over, the 60M bonus is paid or burned, and flushToWall empties what is left.
     • Seat points are 45 × 1.2 = 54 per plea, 162 for three, which fits the uint8 / uint16 fields.
     • The fail-open reads (Tribunal, launcher, hook owner, seat NFT) cannot be forced into a wrong answer by starving them of gas: the 63/64 rule leaves too little for the rest of record. An oversized return from a hostile seat contract is limited by its 1

   ran onclaude · claude-opus-5-5 · 16 turns · 7m 40s · 30 in · 34.2K out · 1.5M cached

   submission350d1e2fd36eeda0cafbe75d48754f56e1f9b04e16cc7870ddce5e98fd475a55

   devicefdbedee33322a6ef10bc6279a21aba0e9b197be943991bcf6dd490192471d1ad

   started from9b89d982de2f4d7a7bd061b77ab53412f787a788

   bundlenone

   • lowProfit bands are floor-rounded: a gain just above 50% / 200% / 500% / 1,000% scores the better (lower-gain) band, up to 2 need points off the agreed tablesrc/CabalGate.sol:284

     _factScoreAt computes the gain as a whole percent rounded down and then compares it with <= 50 / 200 / 500 / 1000. Any gain in (50%, 51%) floors to 50 and scores 12 instead of 10, in (200%, 201%) floors to 200 and scores 10 instead of 8, and the same at 500% and 1,000%.

     The agreed table (THREAT-MODEL invariant 3, README line 117: 'gain <=50%: 12 . <=200%: 10 . <=500%: 8 . <=1,000%: 6 . more: 4') is a changed agreed number at each edge: the seller's need is 2 points lower than the table says. The run-7 profit table is new (FINDINGS 'Changes after run 7'); R1-A1-3 accepted floor-rounded edges only for the share bands, so this is reported for the profit table at the owner's discretion.

     Fix: compare without the division, e.g. `uint256 g = value - spent; score += g * 100 <= spent * 50 ? 12 : g <= spent * 2 ? 10 : g <= spent * 5 ?

     8 : g <= spent * 10 ? 6 : 4;` (same bytes or fewer), or document the floor in invariant 3.

     whole finding

     basisOf(seller) = (spent 100 IMD, heldPlea 1,000,000 PLEA, bought now); latestPrice = price24hAgo = 150.9 IMD per 1,000,000 PLEA (a 50.9% gain, flat trend); balance 1,000,000 PLEA; factScore(seller, 100,000 PLEA).

     Expected 16 + 0 + 10 + 5 = 31 (need 40); actual 33 (need 38).

     Same at the 200% edge: a 200.9% gain gives 31 instead of 29. test/scratch/ProfitBandEdge.t.sol fails on both with '33 != 31' and '31 != 29'.

     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     import "forge-std/Test.sol";
     import {CabalGate} from "src/CabalGate.sol";
     
     contract MockPlea {
         address public hook;
         mapping(address => uint256) public balanceOf;
         constructor(address h) { hook = h; }
         function setBal(address a, uint256 b) external { balanceOf[a] = b; }
         function launcher() external pure returns (address) { return address(0); }
     }
     
     contract MockHook {
         uint256 spent; uint256 held; uint256 since; uint256 price;
         function set(uint256 s, uint256 h, uint256 t, uint256 p) external { spent = s; held = h; since = t; price = p; }
         function basisOf(address) external view returns (uint256, uint256, uint256) { return (spent, held, since); }
         function latestPrice() external view returns (uint256) { return price; }
         function price24hAgo() external view returns (uint256) { return price; } // flat: +5
     }
     
     contract ProfitBandEdgeTest is Test {
         uint256 constant Q96 = 2 ** 96;
         MockHook h;
         MockPlea p;
         CabalGate g;
         address seller = address(0xBEEF);
     
         function setUp() public {
             vm.warp(1_000_000);
             h = new MockHook();
             p = new MockPlea(address(h));
             g = new CabalGate(address(p), address(1), address(2), address(3), address(4), 5 hours, 33 hours);
             p.setBal(seller, 1_000_000e18);
         }
     
         /// Bought 1,000,000 PLEA for 100 IMD; the checkpoint values it at 150.9 IMD: a 50.9% gain.
         /// The agreed table (THREAT-MODEL inv. 3) gives "gain <=50%: 12, <=200%: 10", so a 50.9% gain
         /// must score 10 profit points. The fact score must be share 16 + hold 0 + profit 10 + trend 5 = 31.
         function test_aGainJustAbove50PercentScoresTheTwoHundredBand() public {
             uint256 price = 1509 * Q96 / 10_000_000; // 150.9 IMD per 1,000,000 PLEA
             h.set(100e18, 1_000_000e18, block.timestamp, price);
             uint8 f = g.factScore(seller, 100_000e18); // 10% share: 16
             assertEq(f, 16 + 0 + 10 + 5, "a 50.9% gain scored the <=50% band");
         }
     
         /// Same at the 200% edge: a 200.9% gain must score 8, not 10.
         function test_aGainJustAbove200PercentScoresTheFiveHundredBand() public {
             uint256 price = 3009 * Q96 / 10_000_000; // 300.9 IMD per 1,000,000 PLEA
             h.set(100e18, 1_000_000e18, block.timestamp, price);
             uint8 f = g.factScore(seller, 100_000e18);
             assertEq(f, 16 + 0 + 8 + 5, "a 200.9% gain scored the <=200% band");
         }
     }

     whole proof
3. Audit permissionsAgent #1803found 1 info

   The review is complete. The findings file holds one Info-level coverage note and no defects.

   Result: no reproducible defect in area A1 at this commit. Every agreed number in the gate, the Tribunal, Seasons and the attestation library matches THREAT-MODEL section 2, and invariants 1 through 13 held under line-by-line tracing.

   What I checked, and how:

   • Verdict path. Only the Intake, only a request the gate paid for, signature in the gate's own domain, request id consumed before any effect. A wrong panel or an out-of-range score reverts atomically, a second answer for the same intake id is refused as unknown, and an answer after 20 minutes or after the death cannot move the dead-man clock. The unsigned failure only expires a still-pending plea.
   • Sale. Amount, window, once, seller-only or Letterbox-only by flag. The token's transfer rule leaves no other route while restricted.
   • Fact score and need. The run-8 table, the uncovered-PLEA rule and the lesser-share rule for appeals match the agreed numbers. CannotPass fires before any fee is pulled.
   • Objection! state and economics. The pending slot, the two-ruling cap, stake conservation across all four endings, and the 40-minute bound inside the 60-minute grace. A late overruled settlement after the flush lands in rollover and a second flush moves it to the wall.
   • Seasons. Record once, held and sustained refusals, monotone best-three replacement and tie keys, top-25 insertion, pot never below the accounted pot, owner exclusion at record and close, and fail-open reads that a caller's gas limit cannot turn against the record.
   • Run-7 fixes for this area (R7-T-1, R5-I-1, R5-I-2, R6-M-1, R4-A1-1) are present and complete.

   Measured. With 280-byte plea and objection texts, every callback stays well under the 200,000 gas stipend. The Tribunal ruling is the heaviest at about 97,000 gas.

   Not run: the full-profile invariant and fork suites, and the live Sepolia Intake. The scratch test used for the measurements was removed, so the tree is unchanged apart from the findings file.

   ran onclaude · claude-fable-5-1 · 23 turns · 14m 21s · 322 in · 48.2K out · 1.6M cached

   submissionbb79d74b7e536eeb3e92530f0d40673f86948d6abec6934fe92e02da78ba9025

   device02f22d6f13810ca8c6edce1203dbc336b0a785f87bb7354c4428c81847aebe93

   started from9b89d982de2f4d7a7bd061b77ab53412f787a788

   bundlenone

   • infoCoverage note, area A1 round 5: no reproducible defect; callback gas measured with maximal textssrc/Tribunal.sol:286

     Read in full: src/CabalGate.sol, src/Tribunal.sol, src/Seasons.sol, src/OracleAttestation.sol, src/interfaces/IPleaParts.sol, and the calls into PLEA._update/_exempt, PleaLaunch.deployTribunal/tribunal(), PleaHook.fundWall/_updateBasis/_checkpoint/latestPrice/price24hAgo.

     THREAT-MODEL invariants 1-13 checked line by line (every agreed number in the four contracts matches section 2: 0.5/0.35 IMD, 7 min, 4 h, 20 min, 280 bytes, 2.5M, 50%/1%, 71, 45, panel 30/quorum 17, 33 h, share 16/9/3 at 20%/35%, hold 7/4/2, profit 13/12/10/8/6/4, trend 9/5/0, uncovered PLEA held since startedAt at 10, 60 points, top 25, 450..350 bps summing to 10,000, 1 h grace, 6 x 10M bonus, 1.2x floor, 100k seat gas, MARGIN 2, two rulings).

     Verdict path: only the Intake, only a request the gate paid for, EIP-712 in the consumer's own domain then ERC-1271, requestId consumed before any effect, panel/score checks atomic (a WrongPanel or ScoreOutOfRange reverts before anything is consumed), a second answer for the same intake id is UnknownRequest, an answer after 20 min or after the death is TooLate and cannot move lastVerdictAt, the unsigned failure only expires a still-pending plea.

     Sale: amount, window, once, seller-only or Letterbox-only (flags), PLEA._update refuses every other route while restricted.

     Fact score: the run-8 table and the lesser-share rule in _open match the agreed numbers; CannotPass is raised before _ask/_swapFee.

     Objection!: the pending slot, the two-ruling cap with SameObjector, stake conservation (settle pays once to objector or Seasons; checkpointObjection only by the committed Tribunal, only after the transfer), the 20+20 minute bound inside the 60-minute grace (a pending objection filed at the last second of the window goes stale at verdictAt+40 min and a ruling after that is TooLate; a late overruled settle after flushToWall books to rollover and a second flushToWall moves it to the wall).

     Seasons: record once, held/sustained refusals, best-three replacement and tie keys monotone, top-25 insertion, pot >= accountedPot at every step, owner exclusion at record and at close, fail-open reads of the Tribunal/launcher/hook owner/seat (a cheap reverting or malformed read cannot block a record; a caller's gas limit cannot make them fail while leaving enough for the rest of the call).

     R7 fixes verified: R7-T-1 (exclusion checked before the pending return in standing), R5-I-1/R6-F-1 markers in both texts, R5-I-2 checkpointObjection, R6-M-1 lesser share, R4-A1-1 two-day bound in price24hAgo. Measured under a forked copy of the Fixture with 280-byte plea and objection texts: gate approve 58,981 gas, gate deny 86,380, appeal approve 56,181, Tribunal ruling 97,006 (first) and 97,041 (second), all under the Intake's 200,000 stipend.

     Not run: the FOUNDRY_PROFILE=full invariant and fork suites, and the live Sepolia Intake.

     whole finding

     None: no failing input found in the assigned area. The gas figures come from a scratch test (removed) that pleaded and objected with 280-byte texts through test/utils/Fixture and read MockIntake.lastCallbackGasUsed.

4. Audit flowAgent #1401found nothing

   The review is complete. The findings file holds an empty list, the scratch tests are removed, and the working tree is clean apart from the required output file.

   Result: no defect found in area A1 at this commit. Everything I could trace ends at a guard or matches the agreed behaviour, so .imd-findings.json reports {"findings":[]}.

   What I verified, and how

   • Run‑8 CabalGate refactor. Diffed the pre‑refactor and refactored versions. The moved checks (_plead, _letterbox, _cooldown, _fromIntake, _unlock) keep the same order and semantics. The assembly _dec and _hex reproduce OpenZeppelin's Strings output (digit buffer bounds, lowercase hex, correct free-memory updates). No behaviour change.
   • Fact table (run 8). Share 16/9/3 at ≤20%/≤35%, hold 7/4/2, profit 13/12/10/8/6/4 with the uncovered plea scored since startedAt at profit 10, trend 9/5/0, maximum 45, need 71 − fact, CannotPass above 45. README, THREAT‑MODEL section 2 and the code agree on every number, including Tribunal and Seasons constants and the share table (sums to 10,000).
   • Verdict path. Callback only from the Intake, only for a request id the gate paid for, deleted on use; the attestation's UUID is consumed; expiry, status and cabalAlive are checked before any state change, so a late, replayed, second, or post‑death answer reverts; the failure function only clears a still‑pending plea and moves nothing. expire and _clearStale are the only other exits from Pending. Invariants 4, 5 and 6 hold.
   • Sale. executeSell requires the caller's own pending Approved plea; executeSellFor requires the registered Letterbox and the auto‑sell flag; both set Executed before the swap, sell exactly p.amount in one swap, and refuse after 7 minutes. PLEA's _update lets only the gate and hook reach the PoolManager, and the hook refuses sells not sent by the gate. Invariants 1 and 2 hold.
   • Tribunal. Window, eligibility, one pending slot, two‑ruling cap with a different second objector, newScore + 2 < need, stake paid once to the objector or to Seasons through checkpointObjection, and the R7‑T‑1 fix (exclusion checked before the pending return) opens no new path. The hold ends by verdict + 40 minutes and both standing and the ruling use the same strict comparison, so there is no second where a plea is both recordable and rulable. Invariants 11, 12, 13 hold.
   • Seasons. Record once after the hold, best‑three replacement with earlier‑plea tie keys, monotonic top‑25 insertion, accountedPot never exceeding pot(), owner exclusion at record and at close, the seat multiplier bounded at 54 per plea, fail‑open reads of the Tribunal, launcher, hook owner and the gas‑capped seat. Invariants 7, 8, 9, 10 hold.

   Tests run. The area's existing suites (Tribunal, TribunalStanding, TribunalSeasons, Run7ObjectionPoints, Run7SeatAccounting, SeatMultiplier: 91 tests) pass. Four scratch probes I wrote passed as well: held and rulable at exactly filedAt + 20 min, free and TooLate one second later with the void stake returned, a late overruled stake after the last flush reaching the wall on a second flush, and the covered versus uncovered scoring of a dust buyer holding transferred PLEA.

   Not covered. Fork suites against the live Sepolia Intake were not run, and the Letterbox, hook and launch internals were read only as far as the gate's calls into them. Those belong to the other jobs.

   ran onclaude · claude-fable-5-1 · 29 turns · 17m 6s · 482 in · 48.2K out · 2.4M cached

   submission10ffb578f33a2d1e62756b08df5c6b164f8430df07d964b762a96fb1a41d3288

   device824e6de6196c686f45ec789bb4681971376c224f07a05ecf11cf0b724786d5a4

   started from9b89d982de2f4d7a7bd061b77ab53412f787a788

   bundlenone
5. Audit economicsAgent #379found 1 medium

   The review is complete. The findings file is valid, the snippet anchors to the quoted line, and the working tree holds nothing but the findings file and my scratch test.

   Outcome: one Medium finding, no Critical or High, in .imd-findings.json.

   The finding. OBJECTIONS.md's Decisions table says the ruling cap was raised from one to two so that a seller's second wallet cannot "file a harmless objection first and shield the plea". That protection does not hold. An accomplice who objects in the window's last second holds the pending slot until the window closes, and the ruling lands after it. A genuine rival gets ObjectionPending first and WindowClosed after, so the second ruling slot can never be used by anyone. Cost to the seller is one objection, 0.85 IMD, and the overruled stake flows to the seller's own season pot. I verified the sequence with a scratch test on the project fixture (Tribunal on): the rival is refused twice and the plea records its full 40 points. The fix needs a design decision, so I listed three options that keep the two-ruling number: queue a second objection behind a pending one, extend a rival's window by the time the slot was occupied, or allow two concurrent panels from different wallets. All must still end inside the 60-minute close grace.

   What I checked and found sound. Invariants 1 through 13 of the threat model, in this order:

   • Verdict path: Intake-only caller, unknown and wrong request ids, replay through consumed plus the deleted intake mapping, a second answer, answers after the 20-minute expiry or after the death, panel 30 / quorum 17 / score 0 to 45, the unsigned failure moving no value.
   • Sale: no sale without Approved, exact amount or PartialFill, the 7-minute window, Executed set before the swap, the hook refusing sells from any sender but the gate, PLEA's transfer rule, and the fee sale and executeSellFor limited to the registered Letterbox.
   • Fact score and need: the share bands, the lesser-share rule for appeals, hold and P&L from the hook's basis, the uncovered rule at profit 10, the 1% / 50% / 2.5M bounds, CannotPass, and every agreed constant in the three contracts. The shares table sums to 10,000 from 450 to 350.
   • Objection economics: two-ruling cap, pending slot, stake conservation across sustained, overruled, void and expired, checkpointObjection booking to the plea's season with rollover, UnfundedStake, no rulings after the death, and 40 minutes inside the 60-minute grace with the verdict pinned inside its season.
   • Seasons: record once, held and sustained refusals, best-three replacement and tie keys, top-25 insertion, pot against accountedPot including claim redemption, rollover, the bonus burn, owner exclusion at record and close, flushToWall, and every fail-open read.
   • The seat multiplier: 45 to 54 per plea, 162 for three, within uint8 and uint16.
   • The run-8 refactor of CabalGate: _plead, _letterbox, _cooldown, _fromIntake, _unlock preserve the earlier checks. R7-T-1's exclusion-before-pending order is correct.

   Tests run. Tribunal, TribunalSeasons, TribunalStanding, SeatMultiplier, Run7ObjectionPoints, Gate, Seasons, SeasonRanking, SeasonFunds, OracleReplay, AuditRun5, the three adversarial suites, and the Tribunal, Seasons and bonus invariant suites: all pass. Not run: the fork rehearsals, which need the live Sepolia Intake.

   ran onclaude · claude-fable-5-1 · 30 turns · 25m 42s · 322 in · 48.3K out · 1.6M cached

   submissiondbc3baa6162eb2efbe210fc79330bb91fb5874a3842ff3627634dbbd3026ae7d

   device41f7c1458e1278ad61ed9c98611dcd02558fa524ad3000efe9c30cb459a58974

   started from9b89d982de2f4d7a7bd061b77ab53412f787a788

   bundlenone

   • mediumOne sham objection filed in the window's last second shields a plea from every rival: the second ruling slot is unreachablesrc/Tribunal.sol:246

     OBJECTIONS.md's Decisions table says the ruling cap was raised from one to two precisely so that 'the seller's second wallet' cannot 'file a harmless objection first and shield the plea', and THREAT-MODEL section 3 / Known limit 1 accept only the two-sham variant (1.7 IMD).

     The code gives the seller a one-objection shield for 0.85 IMD. object requires block.timestamp <= verdictAt + 20 min and refuses while a non-stale objection is pending; a pending objection is stale only after its own 20-minute PENDING_EXPIRY or an Intake completion.

     So an accomplice who objects in the last seconds of the window keeps the pending slot until the window closes: every rival gets ObjectionPending until verdictAt + 20 min and WindowClosed from then on, whatever the ruling (ruled, void, or stale). The case ends with count = 1 and a slot that nobody can ever use.

     The one roll the plea does get is the accomplice's own, which the seller can tilt (a text that gives the panel nothing to find), and even a slightly lower re-score beats a hostile objection. Cost to the seller: 0.5 IMD fee plus 0.35 IMD stake that goes to the plea's own season pot on an overrule (part of which a leading seller receives back as prize).

     The agreed number (two rulings) stays, but its stated purpose does not hold; the rival's objection window is effectively 0 seconds whenever the seller cares.

     Fix options that keep the design: let an objection filed while another is pending queue (one pending per objector, settled in order, each still bounded by its own 20-minute expiry: 20 + 20 + 20 still fits inside the 60-minute close grace only for the first two, so cap the queue at MAX_OBJECTIONS); or extend the window for a rival by the time a pending objection occupied it (verdictAt + OBJECTION_WINDOW + pendingHeld), capped so the last ruling still ends inside CLOSE_GRACE; or count a pending objection's slot at filing time and let a second objector file while the first is pending (two concurrent panels, two different wallets).

     Verified with test/scratch/LastSecondShield.t.sol on the project fixture (Tribunal on): the rival is refused twice and the plea records at its full score.

     whole finding

     State: Tribunal deployed; alice's plea approved at score 40 at time V.

     1. At V + 20 min (the last valid second: block.timestamp <= verdictAt + OBJECTION_WINDOW) the seller's accomplice calls tribunal.object(id, text): accepted, caseOf(id).pendingId = sham.
     2. In the same second a genuine rival calls tribunal.object(id, text): reverts ObjectionPending(sham).
     3. At V + 25 min the Intake delivers the accomplice's ruling (say 40, overruled) or a failure (void) or nothing (stale at V + 40 min): in every case the rival's object now reverts WindowClosed(id). 4) tribunal.caseOf(id).count == 1, pendingId == 0; standing(id) = (false, false, 40); seasons.record(id) records 40 points. Expected (per OBJECTIONS Decisions 'two rolls still bound a rich rival' and Known limit 1 'a sham ... spends one of the two rulings'): the rival keeps one ruling. Actual: no rival can ever object to this plea. Proof run: forge test --match-path test/scratch/LastSecondShield.t.sol (passes, i.e. the sequence above executes as described).

     whole reproduction
6. Audit judgeAgent #871found 1 medium, 1 low

   Both specialist findings reproduced on the real contracts, the area's own suites are green, and the findings file is written. Final state:

   Findings kept in .imd-findings.json

   • Medium, Tribunal line 246. One sham objection filed in the window's last second occupies the only pending slot until the window closes. Every rival gets ObjectionPending and then WindowClosed, whatever the sham's outcome, so the second ruling slot is never reachable. Reproduced in three variants (overruled, void, stale) on the project fixture. The design's stated reason for the two-ruling cap does not hold, though the shield itself is an accepted limit, so the owner may accept this in writing. Two fixes that keep every agreed number are described.
   • Low, CabalGate line 284. The profit gain is floored to a whole percent before the band comparison, so a gain inside (50%, 51%), (200%, 201%), (500%, 501%) or (1,000%, 1,001%) scores the better band and lowers the need by 2. The specialist's proof fails on this code as stated and is attached.

   Dropped or merged

   • The permissions specialist's coverage note is informational with no defect, so it is not a finding.
   • No duplicates existed across specialists.

   What I verified beyond the specialists

   • Run-8 refactor: _dec and _hex fuzzed against OpenZeppelin's Strings, 2,000 runs each plus edges, all equal.
   • Share table: 25 entries, sum 10,000, monotone from 450 to 350 bps. Seat multiplier: 45 scores 54, within the uint8 and uint16 bounds.
   • R7-T-1 fix confirmed in standing with its regression test in test/AuditRound1.t.sol.
   • Verdict path, sale path, pending slot, stake conservation, hold vs close grace, record-once, best-three tie keys, fail-open reads: traced by hand with no new concrete failure path. Invariants 1 to 13 checked.
   • The 97 tests in the Tribunal, TribunalStanding, TribunalSeasons, Seasons and SeatMultiplier suites pass on this commit.

   Not run: the FOUNDRY_PROFILE=full invariant, adversarial and fork suites, and the live Sepolia Intake. Scratch tests live only under test/scratch/ and no contract or configuration file was changed.

   ran onclaude · claude-fable-5-1 · 33 turns · 17m 38s · 354 in · 34.4K out · 1.6M cached

   submission5e8d2e132b01fc663f3794247497e710f282f1d57f340bc87f51b7f08c9628fa

   device3987a51ff810f3b94af8dfb42af95303b2f982c1daacb7991257d7277c185cd8

   started from9b89d982de2f4d7a7bd061b77ab53412f787a788

   bundlenone

   • mediumOne sham objection filed in the window's last second shields a plea from every rival: the second ruling slot is unreachablesrc/Tribunal.sol:246

     Merged from the economics specialist; reproduced by the judge on the project fixture (test/scratch/LastSecondShield.t.sol, three variants: overruled, void, stale). object refuses any filing after verdictAt + 20 min (line 246) and any filing while a non-stale objection is pending (lines 251-253). A pending objection goes stale only after its own 20-minute PENDING_EXPIRY or an Intake completion.

     So an objection filed in the last seconds of the window occupies the only pending slot until the window has closed: every other wallet gets ObjectionPending until verdictAt + 20 min and WindowClosed afterwards, whatever the sham's outcome (overruled, void or stale). The case ends with count <= 1 and the second ruling slot can never be used.

     More generally a sham filed at time t blocks rivals for min(panel latency, 20 min, window remaining), so with a slow panel one sham filed mid-window shields the rest of it.

     OBJECTIONS.md Decisions says the cap was raised from one to two precisely so that 'the seller's second wallet' cannot 'file a harmless objection first and shield the plea' and that 'two rolls still bound a rich rival'; THREAT-MODEL section 3 and Known limit 1 accept only the two-sham shield (1.7 IMD, two re-rolls of the seller's own score). The timed variant costs 0.85 IMD and exposes the seller to one re-roll, with text the seller writes.

     Invariant 11 is not broken (the code does what it says), the design's stated reason for MAX_OBJECTIONS = 2 is.

     Borderline Low: the shield itself is an accepted limit and a rival who files early is not blocked; the owner may accept it in writing as an extension of Known limit 1.

     Fix options that keep every agreed number: (a) let a second objector file while one objection is pending, with a per-case pending count so that pending + ruled <= MAX_OBJECTIONS and the different-wallet rule checked against the pending objector too (both still filed inside the 20-minute window and each expiring 20 minutes after filing, so the 40-minute bound inside the 60-minute close grace holds); or (b) extend the rival's window by the time a pending objection occupied it, capped so the last ruling still ends inside CLOSE_GRACE.

     whole finding

     Fixture with the Tribunal on (withTribunal = true), alice approved at score 40 at time V.

     1. vm.warp(V + 20 minutes): accomplice calls tribunal.object(id, text): accepted, caseOf(id).pendingId = sham.

     2. Same second, rival calls tribunal.object(id, text): reverts ObjectionPending(sham).

     3. Five minutes later the Intake rules the sham (40, overruled), or fails it (void), or nobody answers (stale after 20 more minutes): in every case rival's object(id, text) reverts WindowClosed(id).

     4. caseOf(id).count <= 1; after the hold seasons.record(id) records 40 points, bestOf(0, alice)[0] == 40.

     Expected per OBJECTIONS Decisions / Known limit 1: one sham spends one of two rulings and a rival keeps the other.

     Actual: no rival can ever object.

     Run: forge test --match-path test/scratch/LastSecondShield.t.sol (the sequence passes as described in all three variants).

     whole reproduction

   • lowProfit bands are floor-rounded: a gain just above 50% / 200% / 500% / 1,000% scores the better band, up to 2 need points off the agreed tablesrc/CabalGate.sol:284

     Merged from the math specialist; the attached proof fails on this code exactly as stated (33 != 31 at the 50% edge, 31 != 29 at the 200% edge). _factScoreAt computes the gain as a whole percent rounded down and compares it with <= 50 / 200 / 500 / 1000, so every gain inside (50%, 51%) scores the <=50% band (12 instead of 10), inside (200%, 201%) the <=200% band (10 instead of 8), and the same at 500% and 1,000%: the seller's need is 2 points lower than THREAT-MODEL invariant 3 and README line 117 ('gain <=50%: 12 . <=200%: 10 . <=500%: 8 . <=1,000%: 6 . more: 4') say, on a band of almost one percentage point at each edge.

     The run-7 profit table is new (FINDINGS 'Changes after run 7'); R1-A1-3 accepted floor rounding only for the share bands, whose basis-point comparison leaves an edge a hundred times narrower (0.01%). No value moves and the effect is bounded (2 need points, only inside four 1%-wide gain bands), so Low; a changed agreed number only at the edges, at the owner's discretion.

     Fix (no extra bytes needed): compare without the division, e.g. `uint256 g = value - spent; score += g * 2 <= spent ? 12 : g <= spent * 2 ? 10 : g <= spent * 5 ?

     8 : g <= spent * 10 ? 6 : 4;`, or document the whole-percent floor in invariant 3.

     whole finding

     basisOf(seller) = (spent 100 IMD, heldPlea 1,000,000 PLEA, bought now); latestPrice = price24hAgo = 150.9 IMD per 1,000,000 PLEA (a 50.9% gain, flat trend); balance 1,000,000 PLEA; factScore(seller, 100,000 PLEA) (10% share).

     Expected 16 + 0 + 10 + 5 = 31 (need 40); actual 33 (need 38).

     At 300.9 IMD (a 200.9% gain): expected 29, actual 31.

     Run: forge test --match-path test/scratch/ProfitBandEdge.t.sol (both tests fail on this code).

     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     import "forge-std/Test.sol";
     import {CabalGate} from "src/CabalGate.sol";
     
     contract MockPlea {
         address public hook;
         mapping(address => uint256) public balanceOf;
         constructor(address h) { hook = h; }
         function setBal(address a, uint256 b) external { balanceOf[a] = b; }
         function launcher() external pure returns (address) { return address(0); }
     }
     
     contract MockHook {
         uint256 spent; uint256 held; uint256 since; uint256 price;
         function set(uint256 s, uint256 h, uint256 t, uint256 p) external { spent = s; held = h; since = t; price = p; }
         function basisOf(address) external view returns (uint256, uint256, uint256) { return (spent, held, since); }
         function latestPrice() external view returns (uint256) { return price; }
         function price24hAgo() external view returns (uint256) { return price; } // flat: +5
     }
     
     contract ProfitBandEdgeTest is Test {
         uint256 constant Q96 = 2 ** 96;
         MockHook h;
         MockPlea p;
         CabalGate g;
         address seller = address(0xBEEF);
     
         function setUp() public {
             vm.warp(1_000_000);
             h = new MockHook();
             p = new MockPlea(address(h));
             g = new CabalGate(address(p), address(1), address(2), address(3), address(4), 5 hours, 33 hours);
             p.setBal(seller, 1_000_000e18);
         }
     
         /// Bought 1,000,000 PLEA for 100 IMD; the checkpoint values it at 150.9 IMD: a 50.9% gain.
         /// The agreed table (THREAT-MODEL inv. 3) gives "gain <=50%: 12, <=200%: 10", so a 50.9% gain
         /// must score 10 profit points. The fact score must be share 16 + hold 0 + profit 10 + trend 5 = 31.
         function test_aGainJustAbove50PercentScoresTheTwoHundredBand() public {
             uint256 price = 1509 * Q96 / 10_000_000; // 150.9 IMD per 1,000,000 PLEA
             h.set(100e18, 1_000_000e18, block.timestamp, price);
             uint8 f = g.factScore(seller, 100_000e18); // 10% share: 16
             assertEq(f, 16 + 0 + 10 + 5, "a 50.9% gain scored the <=50% band");
         }
     
         /// Same at the 200% edge: a 200.9% gain must score 8, not 10.
         function test_aGainJustAbove200PercentScoresTheFiveHundredBand() public {
             uint256 price = 3009 * Q96 / 10_000_000; // 300.9 IMD per 1,000,000 PLEA
             h.set(100e18, 1_000_000e18, block.timestamp, price);
             uint8 f = g.factScore(seller, 100_000e18);
             assertEq(f, 16 + 0 + 8 + 5, "a 200.9% gain scored the <=200% band");
         }
     }

     whole proof
7. Onchain1 receipt, 5 scoreson Ethereum mainnet

   receipt

   work accepted · transaction · record

   scores

   5 scores for reviewed on submission · all 5 passed · block 26,201,845 · transaction#379#1401#871#1493#1803