Repaired bundle packaging: the local source archive is approximately 6.5 MiB, below the 8 MiB limit. Offline Slither remains available; contracts and protected dependencies are unchanged.

Checks passed: build, 76 tests, formatting, generator/ABI checks, and Slither with zero High findings. One opt-in fork suite was skipped.

Created launch.json with the approved deployment order and constructor arguments.

Local manifest/ABI checks and forge build passed. forge test with the required seed: 76 passed, 0 failed, 1 optional fork skip.

Only launch.json changed outside permitted scratch files.

The review is complete. The findings file is on disk at the repository root, and the only file I created outside it, the scratch test, has been removed.

Outcome: the arithmetic in this tree is sound. One low-severity finding, no critical, high or medium.

What I covered in the Math Precision, Boundary and Numerical Gap areas:

• Callback and settle checks in src/Registry.sol. Signature and answer length guards run before any calldata read. The exact panel rule, the date window arithmetic, the threshold compare and the kind-3 list envelope all match the specification. The latest valid attestation second and the earliest abandon second never coincide.
• Shared fact hashing. The hash the registry stores over the raw answer equals the hash a caller produces over the decoded list, because the list check forces clean address words.
• Direct snapshot bits. The 13 bit positions the composer sets match the mask the registry reads and the thresholds in CATALOG.md.
• Spec windows and the type-width parser. Window guards and the digit accumulator have no underflow or overflow paths. The id counter stops at 65,534 as specified.
• Renderer tables and encoders. The community step formula, the ring counts, the hive offset tables, the percent-encoding lookup, the Base64 allocation and the hostile-returndata bounds all check out. The Slither divide-before-multiply line is the ordinary ceiling formula and is not a defect.
• Catalog constants match the hex anchors and op codes in CATALOG.md. The Intake getter shape matches the reference ABI.

The one finding is in src/Composer.sol at the height bound. Off mainnet, the bound models the head as one block per 12 seconds since the Merge, which ignores missed slots. At the pinned header timestamp it returns 25,847,988 against a real head of 25,789,604. The 601 window and community spec validation on test chains therefore accept blocks that do not exist yet, so a paid 601 request on Sepolia cannot be answered until mainnet catches up. Mainnet uses block.number and is unaffected, which keeps this low.

The full suite ran green before I reported, and the coverage record answers all 14 entry points plus four invariant rows.

The review is complete and .imd-findings.json is written at the repository root. The working tree is otherwise untouched (the scratch probe was removed; git status shows only the findings file).

Outcome: no defect found in the control-flow area. The Registry, its callback path and the periphery libraries behave as docs/REBUILD.md specifies on every path I traced.

What I covered

• Registry entry points: all 14 listed ones, each with a holds row and the checks, state changes and failure paths traced from the Execution Trace, Periphery and First Principles guides.
• Callback verification: the nine checks and reason codes, the clear-then-check order, the bounded dates against the strict 31-day abandon boundary, the prepared-slot layout that keeps deliveries free of zero-to-nonzero writes, and the community-slot bookkeeping under out-of-order deliveries and miss-then-retry (confirmed by a scratch test, since I had verified it only by reasoning).
• Periphery: AttestationHash, Text, Base64Fast, Questions, SpecGrammar, Catalog, HiveData and the Renderer's bounded decoding of registry replies.
• Dependencies and artifacts: the real Intake v2 source matches the interface the Registry assumes (same requests tuple, ids never zero or reused, fixed-stipend call), the exported ABIs equal the compiled ones, and the deploy script passes the seven constructor arguments in the brief's order.
• The full offline suite passes (76 tests).

One info-level note, with reproduction. Once the Intake marks the registry's own request completed, settle accepts an attestation from any payer's panel for the same question, including when the completion was a refusal delivered with empty failure args, which invokes no callback and leaves the pair pending. REBUILD 3.4 states this limit explicitly, so it is recorded for the judge as accepted design rather than as a defect.

Static-analysis leads were all checked: the strict-equality lines compare state and kind codes, the unused returns are the ECDSA error word and the Intake's unrelated tuple fields, the Base64 divide-before-multiply is the standard length formula, and the mint reentrancy lead is guarded by nonReentrant with a hookless token.

Not re-measured: the maximum-state tokenURI gas and the Glamsterdam gas model, which I accepted from test/NOTES.md and the passing GasTest rather than reproducing on Sepolia.

Review complete. The findings file is written and the tree is otherwise untouched (the scratch probe was removed after it ran).

Outcome: no reproducible defect in the assigned area. Access control, trust gaps and asymmetries in the Registry hold as the specification describes them. The file .imd-findings.json carries two info-level trust assumptions and a coverage row for every one of the 14 listed entry points plus three invariants, all holds.

What I checked

• Every state-changing entry point of the Registry was traced for caller assumption, guard, state change and failure path against the Pashov Access Control, Trust Gap and Asymmetry checklists and the Trail of Bits entry-point inventory.
• A scratch Foundry probe with six adversarial sequences ran green on the current code: a stranger's own Intake request naming the registry as callback cannot touch any pair, card transfers and operator approvals move only the card, abandon authorization and the strict 31-day boundary, another claimant's attestation is refused on settle, shared-fact application needs list membership, and the registry holds no IMD or allowance after any call.
• The existing 76-test suite passed offline. The real Intake v2 reference confirms the requests() getter shape and the completion flow the registry relies on.
• Mainnet state of the seven constructor dependencies was read through a public RPC stand-in: price 0.5 IMD, curator settled, 18 decimals, callback gas 200000, executor has code. The constructor's outside-the-floor checks pass today. No launch.json exists yet, so there was no manifest to inspect.

The two info findings record documented trust assumptions with concrete scenarios so the judge has actor and preconditions: settle accepts a true attestation bought by any payer for the same question once the registry's own delivery failed (spec 3.4 accepts this), and the Intake owner's price, callback gas and writer powers plus the single attester key have no remedy inside the registry (spec 3.10 accepts this).

Not reached: the Renderer's rendering paths and the Composer's question text beyond their trust boundaries with the Registry, which belong to the other specialists.

The review is complete and .imd-findings.json is in the repository root.

Result: the economic, invariant and flow-gap area of the Registry holds against the specification. Every value flow, the request state machine, the community slot accounting, the abandon and date boundaries, and the Intake v2 periphery behave as docs/REBUILD.md requires. The offline suite of 76 tests passes on this tree. I found one low-severity trust-boundary defect and no critical or high issues, so no proof file is attached.

The finding (low), at src/Registry.sol:406: the settle completion gate reads only the Intake's completed flag. Intake v2 sets that flag on a status 1 or 2 completion even when it makes no failure call. A shared fact in that state stays pending for 31 days, since nobody may abandon it earlier. During that window any payer who buys a second panel on the registry's own 1201 body and receives a true list can settle it as the permanent top-32 list. The specification's stated guarantee that the registry's own verdict always arrives first does not hold there. The precondition is the plane's behaviour, not the attacker's, which is why it is low. I reproduced the full path in a scratch test and offered two options for the author: an immediate shared-fact abandon once the Intake reports completion, or a disclosure line.

Coverage: all 14 listed entry points have rows. Thirteen are holds with reasons, settle is finding. Five extra rows record the invariants I checked: zero IMD residue and allowance, one pending request per pair and per fact, exact community listing, the attestation-versus-abandon timing, and the Intake v2 interface match.

Leads closed rather than reported: the Slither strict-equality and timestamp lines are state codes and the spec's own date rules. The Aderyn reentrancy line is a trusted view call under a reentrancy guard. Text buffers are bounds-checked, and the list-entry floor rejected my own low test address, confirming that guard works. Not reached in depth: Renderer internals and the Composer's template bytes beyond the golden-hash tests, which are outside my area.

Added failure-path tests, seven fuzz properties, and stateful invariants covering payments, cards, oracle requests, and callbacks.

Validation passed: build, formatting, and seeded offline tests—101 passed, zero failed, one optional fork skip. Invariants completed 24,576 randomized actions.

Changes are confined to test/. No reproducible contract defects found.

The review is complete. The findings file .imd-findings.json holds 3 findings and an 18-row coverage record covering all 14 entry points.

What I kept from the specialists

• Finding 1 (low, merged from three specialists): the settle gate at src/Registry.sol:407 opens on any Intake completion, including a status-1/2 completion with empty args that calls nothing on the registry. I reproduced both the shared-fact path and the personal-pair path in test/scratch/Judge.t.sol. For a shared fact, a stranger's attester-signed list for the same question becomes the permanent list, and nobody can abandon for 31 days. The spec documents the limit, but its stated guarantee that the registry's own verdict always arrives first does not hold in that state. The flow, economics and permissions reports describe the same root cause, so they are one finding.
• Finding 2 (low, from audit_math): the height bound in src/Composer.sol:28 overshoots the real mainnet head by about 58,000 blocks at the anchored timestamp, so off-mainnet 601 windows and spec validation accept unmined blocks. Reproduced with exact numbers. Mainnet is unaffected and the spec itself prescribes this formula, so it stays low.
• Finding 3 (info): the documented Intake-owner and single-attester trust assumptions, with the mock reproduction of the price-zero and lowered-stipend paths.

What I checked myself and found clean

• Every state-changing entry point was traced and marked holds, except settle, which carries finding 1.
• Maximal community specs of kinds 1 through 4 register and then compose within the 1,000/512/16,384 limits, so no fee-then-unusable-spec defect exists.
• The manifest matches the spec's seven constructor arguments and deploy order. Mainnet reads today pass the constructor's outside-the-floor checks. Sizes, formatting and the full offline suite are green.
• The aderyn reentrancy and slither unused-return lines did not reproduce as defects. The tryRecover error is checked and mintCard is guarded.

No critical or high findings, so no proof files are attached. The scratch tests remain under test/scratch/ for the author to rerun.

Implemented Sworn’s eight-route frontend and static export with verified ABIs and deployment manifest.

Build/typecheck, 26 unit tests, 40 layout checks, Chromium/WebKit interactions, and 17 fork checks pass. Changed files total 2.68 MB, below the 8 MiB budget.

Build instructions, validation evidence, screenshots, and limitations are in web/README.md and web/TEST-NOTES.md. Design documentation is in docs/DESIGN.md to respect the path budget.

Real wallet/passkey onboarding and live settlement/Sepolia replay remain unverified.

Recorded three findings in .imd-findings.json. Website files remain unchanged.

• High — bug: Following “Transaction steps” from #/claim?trait=601 destroys the prepared request, changes unsent steps to “unknown,” and removes confirmation. Preserve the query in local anchor links.
• High — fidelity: Explorer offers paid fact requests without their required live IMD price. Display the fetched price beside each request link.
• Medium — bug: Explorer’s automatic refresh removes its results and loses reading position. At 390px, document height fell from 5,443px to 1,245px and scroll position jumped from 3,754px to 401px. Retain results while refreshing the same wallet.

Each finding includes the exact source snippet, change, reason and reproduction.

Clean installation, typecheck, production build, all 26 unit/export tests and 40 route/width checks passed in a temporary copy. The rebuilt export matched the submission byte for byte. Chromium and WebKit interactions passed; both reproduced the claim-link reset. All 45 asset hashes and the pinned implementation ABIs matched.

The visual idea is clear: a terminal interface makes wallet evidence readable through a green, thirteen-family hive.

“Met” below means supported by inspected implementation, independent checks or the supplied fork evidence; no live transaction was signed.

Fixed all three findings: Claim links preserve prepared requests, Explorer shows live prices, and refresh retains results and reading position.

Rebuilt dist/ and its manifest. Build, typecheck, Chromium/WebKit regressions, 27 unit/export tests, 40 layout checks and 17 fork checks passed.

Responses are in .imd-responses.json; evidence is in web/TEST-NOTES.md.

All three original findings are fixed. One new high bug is recorded in [.imd-findings.json][findings]. Website files remain unchanged.

High — bug: switching RPC or losing health blanks the entire Explorer

At [pages.tsx:445][bug], Explorer reads site.health!.block while existing facts remain available. Switching RPC or failing a health refresh sets health to null, causing an uncaught exception and removing the entire application.

Change the result-render guard to require both facts and health, preserving loading/error/retry controls when health is unavailable. This satisfies the required RPC switching and recovery behavior.

Reproduction: at 390×844, open #/explorer?address=0x000000000000000000000000000000000000c1a1, wait for all 25 facts, then choose ethereum-rpc.publicnode.com in Public RPC. Chromium reports Cannot read properties of null (reading 'block'); rows fall 25→0, main elements 1→0, and body text length 3633→0. WebKit reproduces the same blank page. Returning HTTP 503 during the scheduled health refresh also reproduces it; restoring RPC responses does not recover the application. No signing or broadcasting was attempted.

The isolated production rebuild matches the committed export byte for byte. Typechecking, 27 unit/export tests, 40 route/width checks, and seven revision groups in each browser passed. Manifest verification covers all 45 assets, 1,012,986 bytes, the pinned ABIs and exact handoff/network values.

The checklist retains submitted implementation evidence for unchanged requirements; signed flows rely on the existing, explicitly qualified [fork evidence][fork].

Fixed the Explorer crash on RPC changes and health failures. Retry and scheduled recovery work; healthy refreshes preserve results and scroll.

Rebuilt dist/ and its manifest. Build, typecheck, 27 unit tests, 40 route/width checks, and Chromium/WebKit regressions passed.

Recorded the finding response in .imd-responses.json and evidence under docs/frontend/.

The previous high finding is fixed. pages.tsx:438 now guards results on both facts and health.

Rechecked at 390×844 in Chromium 156 and WebKit 27.2, without a wallet fixture:

• Met — user-switchable RPC: changing endpoints preserves navigation and reloads all 25 facts.
• Met — outage and recovery: injected HTTP 503 responses show unavailability and Retry reads. Keyboard retry and the scheduled callback restore results without reloading.
• Met — healthy refresh: all 25 row nodes, page height and scroll position remain unchanged.
• Met — application stability: all six scenarios pass on recheck with no application page errors.

Met — deployment export: all 45 assets’ hashes, pinned ABI bytes and canonical hashes, handoff fields, and unchanged network configuration verify. Publication and naming remain after review. Other accepted requirements retain their documented coverage in web/TEST-NOTES.md; this round focused on settling the supplied finding.

Sworn presents verifiable wallet facts through a restrained terminal interface and a hive-shaped card.

.imd-findings.json contains {"findings":[]}. Site files are unchanged.